module doc_down
import markdown
-import highlight
+import htmlight
private import parser_util
redef class MDoc
var comment: String is lazy do
var lines = content.to_a
if not lines.is_empty then lines.shift
- return content.join("\n").html_escape
+ return lines.join("\n")
end
# Full comment HTML escaped.
- var documentation: String is lazy do return content.join("\n").html_escape
+ var documentation: String is lazy do return content.join("\n")
- private var markdown_proc: MarkdownProcessor is lazy do
- return original_mentity.model.nitdoc_md_processor
+ private var markdown_proc: MarkdownProcessor is lazy, writable do
+ return original_mentity.as(not null).model.nitdoc_md_processor
end
- private var inline_proc: MarkdownProcessor is lazy do
- return original_mentity.model.nitdoc_inline_processor
+ private var inline_proc: MarkdownProcessor is lazy, writable do
+ return original_mentity.as(not null).model.nitdoc_inline_processor
end
# Renders the synopsis as a HTML comment block.
var syn = inline_proc.process(content.first)
res.add "<span class=\"synopsys nitdoc\">{syn}</span>"
return res
+ end
+ # Renders the synopsis as a HTML comment block.
+ var md_synopsis: Writable is lazy do
+ if content.is_empty then return ""
+ return content.first
end
# Renders the comment without the synopsis as a HTML comment block.
return lines_to_html(lines)
end
+ #
+ var md_comment: Writable is lazy do
+ if content.is_empty then return ""
+ var lines = content.to_a
+ lines.shift
+ return lines.join("\n")
+ end
+
# Renders the synopsis and the comment as a HTML comment block.
var html_documentation: Writable is lazy do return lines_to_html(content.to_a)
+ # Renders the synopsis and the comment as a HTML comment block.
+ var md_documentation: Writable is lazy do return lines_to_md(content.to_a)
+
# Renders markdown line as a HTML comment block.
private fun lines_to_html(lines: Array[String]): Writable do
var res = new Template
+ var decorator = markdown_proc.decorator.as(NitdocDecorator)
+ decorator.current_mdoc = self
res.add "<div class=\"nitdoc\">"
# do not use DocUnit as synopsys
if not lines.is_empty then
not lines.first.has_prefix("\t") then
# parse synopsys
var syn = inline_proc.process(lines.shift)
- res.add "<p class=\"synopsys\">{syn}</p>"
+ res.add "<h1 class=\"synopsys\">{syn}</h1>"
end
end
# check for annotations
# add other lines
res.add markdown_proc.process(lines.join("\n"))
res.add "</div>"
+ decorator.current_mdoc = null
return res
+ end
+ private fun lines_to_md(lines: Array[String]): Writable do
+ var res = new Template
+ if not lines.is_empty then
+ var syn = lines.first
+ if not syn.has_prefix(" ") and not syn.has_prefix("\t") and
+ not syn.trim.has_prefix("#") then
+ lines.shift
+ res.add "# {syn}\n"
+ end
+ end
+ res.add lines.join("\n")
+ return res
end
end
-private class NitdocDecorator
+# The specific markdown decorator used internally to process MDoc object.
+#
+# You should use the various methods of `MDoc` like `MDoc::html_documentation`
+#
+# The class is public so specific behavior can be plugged on it.
+class NitdocDecorator
super HTMLDecorator
- var toolcontext = new ToolContext
+ private var toolcontext = new ToolContext
+
+ # The currently processed mdoc.
+ #
+ # Unfortunately, this seems to be the simpler way to get the currently processed `MDoc` object.
+ var current_mdoc: nullable MDoc = null
redef fun add_code(v, block) do
- var meta = "nit"
- if block isa BlockFence and block.meta != null then
- meta = block.meta.to_s
- end
+ var meta = block.meta or else "nit"
+
# Do not try to highlight non-nit code.
if meta != "nit" and meta != "nitish" then
v.add "<pre class=\"{meta}\"><code>"
return
end
# Try to parse code
- var code = code_from_block(block)
+ var code = block.raw_content
var ast = toolcontext.parse_something(code)
if ast isa AError then
v.add "<pre class=\"{meta}\"><code>"
return
end
v.add "<pre class=\"nitcode\"><code>"
- var hl = new HighlightVisitor
+ var hl = new HtmlightVisitor
hl.line_id_prefix = ""
- hl.enter_visit(ast)
+ hl.highlight_node(ast)
v.add(hl.html)
v.add "</code></pre>\n"
end
append_code(v, text, from, to)
else
v.add "<code class=\"nitcode\">"
- var hl = new HighlightVisitor
+ var hl = new HtmlightVisitor
hl.line_id_prefix = ""
- hl.enter_visit(ast)
+ hl.highlight_node(ast)
v.add(hl.html)
end
v.add "</code>"
end
- fun code_from_text(buffer: Text, from, to: Int): String do
+ private fun code_from_text(buffer: Text, from, to: Int): String do
var out = new FlatBuffer
for i in [from..to[ do out.add buffer[i]
return out.write_to_string
end
-
- fun code_from_block(block: BlockCode): String do
- var infence = block isa BlockFence
- var text = new FlatBuffer
- var line = block.block.first_line
- while line != null do
- if not line.is_empty then
- var str = line.value
- if not infence and str.has_prefix(" ") then
- text.append str.substring(4, str.length - line.trailing)
- else
- text.append str
- end
- end
- text.append "\n"
- line = line.next
- end
- return text.write_to_string
- end
end
# Decorator for span elements.
return
end
v.add "<code class=\"nitcode\">"
- var hl = new HighlightVisitor
- hl.enter_visit(ast)
+ var hl = new HtmlightVisitor
+ hl.highlight_node(ast)
v.add(hl.html)
v.add "</code>"
end
redef class Model
# Get a markdown processor for Nitdoc comments.
- var nitdoc_md_processor: MarkdownProcessor is lazy do
+ var nitdoc_md_processor: MarkdownProcessor is lazy, writable do
var proc = new MarkdownProcessor
- proc.emitter.decorator = new NitdocDecorator
+ proc.decorator = new NitdocDecorator
return proc
end
# Get a markdown inline processor for Nitdoc comments.
#
# This processor is specificaly designed to inlinable doc elements like synopsys.
- var nitdoc_inline_processor: MarkdownProcessor is lazy do
+ var nitdoc_inline_processor: MarkdownProcessor is lazy, writable do
var proc = new MarkdownProcessor
- proc.emitter.decorator = new InlineDecorator
+ proc.decorator = new InlineDecorator
return proc
end
end
nitlanguage / nit.git / blobdiff