mmmd 0.1.0

data/lib/mmmd/renderers/html.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require_relative "../util"
+
+module MMMD
+  module Renderers
+    module HTMLConstants
+      ELEMENT_MAP = {
+        "PointBlank::DOM::InlinePre" => {
+          tag: "code",
+          style: "white-space: pre;"
+        },
+        "PointBlank::DOM::InlineBreak" => {
+          tag: "br"
+        },
+        "PointBlank::DOM::InlineStrong" => {
+          tag: "strong"
+        },
+        "PointBlank::DOM::InlineEmphasis" => {
+          tag: "em"
+        },
+        "PointBlank::DOM::InlineUnder" => {
+          tag: "span",
+          style: "text-decoration: underline;"
+        },
+        "PointBlank::DOM::InlineStrike" => {
+          tag: "s"
+        },
+        "PointBlank::DOM::InlineLink" => {
+          tag: "a",
+          href: true,
+          title: true
+        },
+        "PointBlank::DOM::InlineImage" => {
+          tag: "img",
+          src: true,
+          inline: true,
+          alt: true,
+          title: true
+        },
+        "PointBlank::DOM::ULBlock" => {
+          tag: "ul"
+        },
+        "PointBlank::DOM::OLBlock" => {
+          tag: "ol"
+        },
+        "PointBlank::DOM::IndentBlock" => {
+          tag: "pre"
+        },
+        "PointBlank::DOM::ULListElement" => {
+          tag: "li"
+        },
+        "PointBlank::DOM::OLListElement" => {
+          tag: "li"
+        },
+        "PointBlank::DOM::Paragraph" => {
+          tag: "p"
+        },
+        "PointBlank::DOM::SetextHeading1" => {
+          tag: "h1"
+        },
+        "PointBlank::DOM::SetextHeading2" => {
+          tag: "h2"
+        },
+        "PointBlank::DOM::ATXHeading1" => {
+          tag: "h1"
+        },
+        "PointBlank::DOM::ATXHeading2" => {
+          tag: "h2"
+        },
+        "PointBlank::DOM::ATXHeading3" => {
+          tag: "h3"
+        },
+        "PointBlank::DOM::ATXHeading4" => {
+          tag: "h4"
+        },
+        "PointBlank::DOM::ATXHeading5" => {
+          tag: "h5"
+        },
+        "PointBlank::DOM::ATXHeading6" => {
+          tag: "h6"
+        },
+        "PointBlank::DOM::Document" => {
+          tag: "main"
+        },
+        "PointBlank::DOM::CodeBlock" => {
+          tag: "pre",
+          outer: {
+            tag: "code"
+          }
+        },
+        "PointBlank::DOM::QuoteBlock" => {
+          tag: "blockquote"
+        },
+        "PointBlank::DOM::HorizontalRule" => {
+          tag: "hr",
+          inline: true
+        },
+        "PointBlank::DOM::Text" => {
+          sanitize: true
+        },
+        "PointBlank::DOM::InlineAutolink" => {
+          tag: "a",
+          href: true
+        }
+      }.freeze
+
+      # Class for managing styles and style overrides
+      class MapManager
+        class << self
+          # Define a default mapping for specified class
+          # @param key [String] class name
+          # @param mapping [Hash] mapping
+          # @return [void]
+          def define_mapping(key, mapping)
+            @mapping ||= ELEMENT_MAP.dup
+            @mapping[key] = mapping
+          end
+
+          # Get computed mapping
+          # @return [Hash]
+          def mapping
+            @mapping ||= ELEMENT_MAP.dup
+          end
+        end
+
+        def initialize(overrides)
+          @mapping = self.class.mapping
+          @mapping = @mapping.merge(overrides["mapping"]) if overrides["mapping"]
+        end
+
+        attr_reader :mapping
+      end
+    end
+
+    # HTML Renderer
+    class HTML
+      def initialize(dom, options)
+        @document = dom
+        @options = options
+        @options["linewrap"] ||= 80
+        @options["init_level"] ||= 2
+        @options["indent"] ||= 2
+        mapmanager = HTMLConstants::MapManager.new(options)
+        @mapping = mapmanager.mapping
+        return unless @options["nowrap"]
+
+        @options["init_level"] = 0
+        @mapping.delete("PointBlank::DOM::Document")
+      end
+
+      # Render document to HTML
+      def render
+        text = _render(@document, @options, level: @options["init_level"])
+        @options["init_level"].times { text = indent(text) }
+        if @options["nowrap"]
+          text
+        else
+          [
+            preambule,
+            remove_pre_spaces(text),
+            postambule
+          ].join("\n")
+        end
+      end
+
+      private
+
+      # Find and remove extra spaces inbetween preformatted text
+      # @param string [String]
+      # @return [String]
+      def remove_pre_spaces(string)
+        output = []
+        buffer = []
+        open = nil
+        string.lines.each do |line|
+          opentoken = line.match?(/<pre>/)
+          closetoken = line.match?(/<\/pre>/)
+          if closetoken
+            open = false
+            buffer = strip_leading_spaces_in_buffer(buffer)
+            output.append(*buffer)
+            buffer = []
+          end
+          (open ? buffer : output).append(line)
+          open = true if opentoken && !closetoken
+        end
+        output.append(*buffer) unless buffer.empty?
+        output.join('')
+      end
+
+      # Strip leading spaces in the buffer
+      # @param lines [Array<String>]
+      # @return [Array<String>]
+      def strip_leading_spaces_in_buffer(buffer)
+        minprefix = buffer.map { |x| x.match(/^ */)[0] }
+                          .min_by(&:length)
+        buffer.map do |line|
+          line.delete_prefix(minprefix)
+        end
+      end
+
+      # Word wrapping algorithm
+      # @param text [String]
+      # @param width [Integer]
+      # @return [String]
+      def wordwrap(text, width)
+        words = text.split(/( +|<[^>]+>)/)
+        output = []
+        line = ""
+        length = 0
+        until words.empty?
+          word = words.shift
+          wordlength = word.length
+          if length + wordlength + 1 > width
+            output.append(line.lstrip)
+            line = word
+            length = wordlength
+            next
+          end
+          length += wordlength
+          line += word
+        end
+        output.append(line.lstrip)
+        output.join("\n")
+      end
+
+      def _render(element, options, inline: false, level: 0, literaltext: false)
+        modeswitch = element.is_a?(::PointBlank::DOM::LeafBlock) ||
+                     element.is_a?(::PointBlank::DOM::Paragraph)
+        inline ||= modeswitch
+        level += 1 unless inline
+        text = if element.children.empty?
+                 element.content
+               else
+                 literal = @mapping[element.class.name]
+                           &.fetch(:inline, false) ||
+                           literaltext
+                 element.children.map do |child|
+                   _render(child, options, inline: inline,
+                                           level: level,
+                                           literaltext: literal)
+                 end.join(inline ? '' : "\n")
+               end
+        run_filters(text, element, level: level,
+                                   inline: inline,
+                                   modeswitch: modeswitch,
+                                   literaltext: literaltext)
+      end
+
+      def run_filters(text, element, level:, inline:, modeswitch:,
+                                     literaltext:)
+        element_style = @mapping[element.class.name]
+        return text unless element_style
+        return text if literaltext
+
+        hsize = @options["linewrap"] - (level * @options["indent"])
+        text = wordwrap(text, hsize) if modeswitch
+        if element_style[:sanitize]
+          text = MMMD::EntityUtils.encode_entities(text)
+        end
+        if element_style[:inline]
+          innerclose(element, element_style, text)
+        else
+          openclose(text, element, element_style, inline)
+        end
+      end
+
+      def openclose(text, element, element_style, inline)
+        opentag, closetag = construct_tags(element_style, element)
+        if inline
+          opentag + text + closetag
+        else
+          [opentag,
+           indent(text),
+           closetag].join("\n")
+        end
+      end
+
+      def innerclose(element, style, text)
+        props = element.properties
+        tag = "<#{style[:tag]}"
+        tag += " style=#{style[:style].inspect}" if style[:style]
+        tag += " href=#{read_link(element)}" if style[:href]
+        tag += " alt=#{text.inspect}" if style[:alt]
+        tag += " src=#{read_link(element)}" if style[:src]
+        tag += " title=#{read_title(element)}" if style[:title] && props[:title]
+        tag += ">"
+        if style[:outer]
+          outeropen, outerclose = construct_tags(style[:outer], element)
+          tag = outeropen + tag + outerclose
+        end
+        tag
+      end
+
+      def construct_tags(style, element)
+        return ["", ""] unless style && style[:tag]
+
+        props = element.properties
+        opentag = "<#{style[:tag]}"
+        closetag = "</#{style[:tag]}>"
+        opentag += " style=#{style[:style].inspect}" if style[:style]
+        opentag += " href=#{read_link(element)}" if style[:href]
+        opentag += " src=#{read_link(element)}" if style[:src]
+        opentag += " title=#{read_title(element)}" if style[:title] &&
+                                                      props[:title]
+        opentag += ">"
+        if style[:outer]
+          outeropen, outerclose = construct_tags(style[:outer], element)
+          opentag = outeropen + opentag
+          closetag += outerclose
+        end
+        [opentag, closetag]
+      end
+
+      def read_title(element)
+        title = element.properties[:title]
+        title = ::MMMD::EntityUtils.encode_entities(title)
+        title.inspect
+      end
+
+      def read_link(element)
+        link = element.properties[:uri]
+        link.inspect
+      end
+
+      def indent(text)
+        text.lines.map do |line|
+          "#{' ' * @options["indent"]}#{line}"
+        end.join('')
+      end
+
+      def preambule
+        head = @options['head']
+        headinfo = "#{indent(<<~HEAD.rstrip)}\n  " if head
+          <head>
+            #{head.is_a?(Array) ? head.join("\n") : head}
+          </head>
+        HEAD
+        headinfo ||= "  "
+        @options['preambule'] or <<~TEXT.rstrip
+          <!DOCTYPE HTML>
+          <html>
+          #{headinfo}<body>
+        TEXT
+      end
+
+      def postambule
+        @options['postambule'] or <<~TEXT
+            </body>
+          </html>
+        TEXT
+      end
+    end
+  end
+end