Merge: doc: fixed some typos and other misc. corrections

[nit.git] / lib / markdown2 / markdown_html_rendering.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# HTML rendering of Markdown documents
module markdown_html_rendering

import markdown_rendering
import markdown_github
import markdown_wikilinks

# Markdown document renderer to HTML
class HtmlRenderer
        super MdRenderer

        # HTML output under construction
        private var html: Buffer is noinit

        # Render `document` as HTML
        redef fun render(document) do
                reset
                enter_visit(document)
                return html.write_to_string
        end

        redef fun visit(node) do node.render_html(self)

        # Reset `headings` and internal state
        fun reset do
                html = new Buffer
                if enable_heading_ids then headings.clear
        end

        # Last char visited
        #
        # Used to avoid double blank lines.
        private var last_char: nullable Char = null

        # Add `string` to `html`
        private fun add(string: String) do
                html.append(string)
                if not html.is_empty then
                        last_char = html.last
                end
        end

        # Add a raw `html` string to the output
        #
        # Raw means that the string will not be escaped.
        fun add_raw(html: String) do add html

        # Add `text` string to the output
        #
        # The string will be escaped.
        fun add_text(text: String) do add html_escape(text, true)

        # Add a blank line to the output
        fun add_line do
                if last_char != null and last_char != '\n' then
                        add "\n"
                end
        end

        # Escape `string` to HTML
        #
        # When `keep_entities`, HTML entities will not be escaped.
        fun html_escape(string: String, keep_entities: Bool): String do
                var buf: nullable Buffer = null
                for i in [0..string.length[ do
                        var c = string.chars[i]
                        var sub = null
                        if c == '&' and (not keep_entities or string.search_from(re_entity, i) == null) then
                                sub = "&"
                        else if c == '<' then
                                sub = "&lt;"
                        else if c == '>' then
                                sub = "&gt;"
                        else if c == '"' then
                                sub = "&quot;"
                        else
                                if buf != null then buf.add c
                                continue
                        end
                        if buf == null then
                                buf = new Buffer
                                for j in [0..i[ do buf.add string.chars[j]
                        end
                        buf.append sub
                end

                if buf == null then return string
                return buf.to_s
        end

        # HTML entity pattern
        private var re_entity: Regex = "^&(#x[a-f0-9]\{1,8\}|#[0-9]\{1,8\}|[a-z][a-z0-9]\{1,31\});".to_re

        # Encode the `uri` string
        fun encode_uri(uri: String): String do
                var buf = new Buffer

                var i = 0
                while i < uri.length do
                        var c = uri.chars[i]
                        if (c >= '0' and c <= '9') or
                           (c >= 'a' and c <= 'z') or
                           (c >= 'A' and c <= 'Z') or
                           c == ';' or c == ',' or c == '/' or c == '?' or
                           c == ':' or c == '@' or c == '=' or c == '+' or
                           c == '$' or c == '-' or c == '_' or c == '.' or
                           c == '!' or c == '~' or c == '*' or c == '(' or
                           c == ')' or c == '#' or c == '\''
                        then
                                buf.add c
                        else if c == '&' then
                                buf.append "&amp;"
                        else if c == '%' and uri.search_from(re_uri_code, i) != null then
                                buf.append uri.substring(i, 3)
                                i += 2
                        else
                                var bytes = c.to_s.bytes
                                for b in bytes do buf.append "%{b.to_i.to_hex}".to_upper
                        end
                        i += 1
                end

                return buf.to_s
        end

        # URI encode pattern
        private var re_uri_code: Regex = "^%[a-zA-Z0-9]\{2\}".to_re

        # Add `id` tags to headings
        var enable_heading_ids = false is optional, writable

        # Associate headings ids to blocks
        var headings = new ArrayMap[String, MdHeading]

        # Strip heading id
        fun strip_id(text: String): String do
                # strip id
                var b = new FlatBuffer
                for c in text do
                        if c == ' ' then
                                b.add '_'
                        else
                                if not c.is_letter and
                                   not c.is_digit and
                                   not allowed_id_chars.has(c) then continue
                                b.add c
                        end
                end
                var res = b.to_s
                if res.is_empty then res = "_"
                var key = res
                # check for multiple id definitions
                if headings.has_key(key) then
                        var i = 1
                        key = "{res}_{i}"
                        while headings.has_key(key) do
                                i += 1
                                key = "{res}_{i}"
                        end
                end
                return key
        end

        # Allowed characters in ids
        var allowed_id_chars: Array[Char] = ['-', '_', ':', '.']
end

redef class MdNode

        # Render `self` as HTML
        fun render_html(v: HtmlRenderer) do visit_all(v)
end

# Blocks

redef class MdBlockQuote
        redef fun render_html(v) do
                v.add_line
                v.add_raw "<blockquote>"
                v.add_line
                visit_all(v)
                v.add_line
                v.add_raw "</blockquote>"
                v.add_line
        end
end

redef class MdCodeBlock
        redef fun render_html(v) do
                var info = self.info
                v.add_line
                v.add_raw "<pre>"
                v.add_raw "<code"
                if info != null and not info.is_empty then
                        v.add_raw " class=\"language-{info.split(" ").first}\""
                end
                v.add_raw ">"
                var literal = self.literal or else ""
                var lines = literal.split("\n")
                for i in [0..lines.length[ do
                        var line = lines[i]
                        v.add_raw v.html_escape(line, false)
                        if i < lines.length - 1 then
                                v.add_raw "\n"
                        end
                end
                v.add_raw "</code>"
                v.add_raw "</pre>"
                v.add_line
        end
end

redef class MdHeading
        redef fun render_html(v) do
                v.add_line
                if v.enable_heading_ids then
                        var id = self.id
                        if id == null then
                                id = v.strip_id(title)
                                v.headings[id] = self
                                self.id = id
                        end
                        v.add_raw "<h{level} id=\"{id}\">"
                else
                        v.add_raw "<h{level}>"
                end
                visit_all(v)
                v.add_raw "</h{level}>"
                v.add_line
        end

        #
        var id: nullable String = null

        #
        fun title: String do
                var v = new RawTextVisitor
                return v.render(self)
        end
end

redef class MdUnorderedList
        redef fun render_html(v) do
                v.add_line
                v.add_raw "<ul>"
                v.add_line
                visit_all(v)
                v.add_line
                v.add_raw "</ul>"
                v.add_line
        end
end

redef class MdOrderedList
        redef fun render_html(v) do
                var start = self.start_number
                v.add_line
                v.add_raw "<ol"
                if start != 1 then
                        v.add_raw " start=\"{start}\""
                end
                v.add_raw ">"
                v.add_line
                visit_all(v)
                v.add_line
                v.add_raw "</ol>"
                v.add_line
        end
end

redef class MdListItem
        redef fun render_html(v) do
                v.add_raw "<li>"
                visit_all(v)
                v.add_raw "</li>"
                v.add_line
        end
end

redef class MdParagraph
        redef fun render_html(v) do
                var is_tight = is_in_tight_list
                if not is_tight then
                        v.add_line
                        v.add_raw "<p>"
                end
                visit_all(v)
                if not is_tight then
                        v.add_raw "</p>"
                        v.add_line
                end
        end
end

redef class MdThematicBreak
        redef fun render_html(v) do
                v.add_line
                v.add_raw "<hr />"
                v.add_line
        end
end

redef class MdHtmlBlock
        redef fun render_html(v) do
                v.add_line
                var literal = self.literal or else ""
                var lines = literal.split("\n")
                for i in [0..lines.length[ do
                        var line = lines[i]
                        if not line.trim.is_empty then
                                v.add_raw line
                        end
                        if i < lines.length - 1 then
                                v.add_raw "\n"
                        end
                end
                v.add_line
        end
end

# Inlines

redef class MdHardLineBreak
        redef fun render_html(v) do
                v.add_raw "<br />"
                v.add_line
        end
end

redef class MdSoftLineBreak
        redef fun render_html(v) do
                v.add_raw "\n"
        end
end

redef class MdCode
        redef fun render_html(v) do
                v.add_raw "<code>"
                v.add_raw v.html_escape(literal, false)
                v.add_raw "</code>"
        end
end

redef class MdEmphasis
        redef fun render_html(v) do
                v.add_raw "<em>"
                visit_all(v)
                v.add_raw "</em>"
        end
end

redef class MdStrongEmphasis
        redef fun render_html(v) do
                v.add_raw "<strong>"
                visit_all(v)
                v.add_raw "</strong>"
        end
end

redef class MdHtmlInline
        redef fun render_html(v) do
                v.add_raw literal
        end
end

redef class MdImage
        redef fun render_html(v) do
                var url = self.destination
                var title = self.title
                v.add_raw "<img"
                v.add_raw " src=\"{v.encode_uri(url)}\""

                var alt_text = self.alt_text
                v.add_raw " alt=\"{alt_text}\""

                if title != null and not title.is_empty then
                        v.add_raw " title=\""
                        v.add_text title
                        v.add_raw "\""
                end

                v.add_raw " />"
        end

        private fun alt_text: String do
                var v = new RawTextVisitor
                return v.render(self)
        end
end

redef class MdLink
        redef fun render_html(v) do
                var url = self.destination
                var title = self.title
                v.add_raw "<a"
                v.add_raw " href=\"{v.encode_uri(url)}\""
                if title != null and not title.is_empty then
                        v.add_raw " title=\""
                        v.add_text title
                        v.add_raw "\""
                end
                v.add_raw ">"
                visit_all(v)
                v.add_raw "</a>"
        end
end

redef class MdText
        redef fun render_html(v) do
                v.add_text literal
        end
end

# Github mode

redef class MdStrike
        redef fun render_html(v) do
                v.add_raw "<del>"
                visit_all(v)
                v.add_raw "</del>"
        end
end

redef class MdSuper
        redef fun render_html(v) do
                v.add_raw "<sup>"
                visit_all(v)
                v.add_raw "</sup>"
        end
end

# Wikilinks mode

redef class MdWikilink

        # Dummy rendering of wikilinks
        #
        # Clients should redefine this.
        redef fun render_html(v) do
                v.add_raw "<wiki link=\"{v.encode_uri(link)}\">"
                visit_all(v)
                v.add_raw "</wiki>"
        end
end