mdlint 0.1.0 → 0.2.0

data/lib/mdlint/renderer/html_renderer.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "uri"
+
+module Mdlint
+  module Renderer
+    class HtmlRenderer
+      NAMED_ENTITIES = {
+        "amp" => "&", "apos" => "'", "gt" => ">", "lt" => "<", "quot" => '"',
+        "nbsp" => "\u00a0", "copy" => "©", "reg" => "®", "trade" => "™",
+        "AElig" => "Æ", "aelig" => "æ", "Dcaron" => "Ď", "dcaron" => "ď",
+        "ouml" => "ö", "Ouml" => "Ö", "auml" => "ä", "Auml" => "Ä", "uuml" => "ü", "Uuml" => "Ü",
+        "frac12" => "½", "frac14" => "¼", "frac34" => "¾", "HilbertSpace" => "ℋ",
+        "DifferentialD" => "ⅆ", "ClockwiseContourIntegral" => "∲", "ngE" => "≧̸"
+      }.freeze
+
+      def initialize(options = {})
+        @options = options
+        @reference_definitions = {}
+        @footnote_definitions = {}
+        @footnote_order = []
+      end
+
+      def render(tokens)
+        @reference_definitions = {}
+        @footnote_definitions = {}
+        @footnote_order = []
+        collect_reference_definitions(tokens)
+        output = render_sequence(tokens, 0).first
+        output << render_footnotes unless @footnote_order.empty?
+        output
+      end
+
+      private
+
+      def render_sequence(tokens, index, closing_type = nil)
+        output = +""
+        while index < tokens.length
+          token = tokens[index]
+          if closing_type && token.type == closing_type
+            return [output, index + 1]
+          end
+
+          case token.type
+          when :heading_open
+            content, index = render_until_inline(tokens, index + 1, :heading_close)
+            output << "<#{token.tag}>#{render_inline(content)}</#{token.tag}>\n"
+          when :paragraph_open
+            content, index = render_until_inline(tokens, index + 1, :paragraph_close)
+            output << "<p>#{render_inline(content)}</p>\n"
+          when :bullet_list_open, :ordered_list_open
+            list, index = render_sequence(tokens, index + 1, token.type == :bullet_list_open ? :bullet_list_close : :ordered_list_close)
+            tag = token.type == :bullet_list_open ? "ul" : "ol"
+            start = token.type == :ordered_list_open ? token.attrs[:start].to_i : 1
+            start_attribute = token.type == :ordered_list_open && start != 1 ? " start=\"#{start}\"" : ""
+            output << "<#{tag}#{start_attribute}>\n#{list}</#{tag}>\n"
+          when :list_item_open
+            item, index = render_sequence(tokens, index + 1, :list_item_close)
+            task = token.attrs[:task] ? task_checkbox(token.attrs[:checked]) : ""
+            if token.attrs[:tight] == false
+              output << "<li>#{task}\n#{item}</li>\n"
+            else
+              item = collapse_tight_item(item)
+              output << "<li>#{task}#{item}</li>\n"
+            end
+          when :blockquote_open
+            content, index = render_sequence(tokens, index + 1, :blockquote_close)
+            if token.attrs[:alert]
+              alert = escape_attribute(token.attrs[:alert])
+              output << "<aside class=\"markdown-alert markdown-alert-#{alert}\">\n#{content}</aside>\n"
+            else
+              output << "<blockquote>\n#{content}</blockquote>\n"
+            end
+          when :fence
+            output << fenced_code(token)
+            index += 1
+          when :code_block
+            output << "<pre><code>#{escape_raw(token.content)}</code></pre>\n"
+            index += 1
+          when :math_block
+            output << "<div class=\"math-block\">#{escape_raw(token.content)}</div>\n"
+            index += 1
+          when :footnote_definition
+            @footnote_definitions[token.attrs[:label]] ||= token
+            index += 1
+          when :hr
+            output << "<hr />\n"
+            index += 1
+          when :html_block
+            output << token.content
+            output << "\n" unless token.content.end_with?("\n")
+            index += 1
+          when :table
+            output << render_table(token)
+            index += 1
+          when :directive
+            output << render_directive(token)
+            index += 1
+          when :front_matter, :reference_definition
+            index += 1
+          else
+            index += 1
+          end
+        end
+
+        [output, index]
+      end
+
+      def render_until_inline(tokens, index, closing_type)
+        inline = tokens[index..]&.find { |token| token.type == :inline }
+        closing_index = tokens[index..]&.index { |token| token.type == closing_type }
+        [inline, index + (closing_index || 0) + 1]
+      end
+
+      def render_inline(token)
+        return "" unless token
+        return escape(token.content) if token.children.empty?
+
+        render_inline_tokens(token.children)
+      end
+
+      def render_inline_tokens(tokens)
+        output = +""
+        index = 0
+        while index < tokens.length
+          token = tokens[index]
+          case token.type
+          when :text
+            output << escape(token.content)
+          when :strong_open, :em_open, :s_open
+            close_type = { strong_open: :strong_close, em_open: :em_close, s_open: :s_close }.fetch(token.type)
+            tag = { strong_open: "strong", em_open: "em", s_open: "del" }.fetch(token.type)
+            close_index = find_close(tokens, index, close_type)
+            output << "<#{tag}>#{render_inline_tokens(tokens[(index + 1)...close_index])}</#{tag}>"
+            index = close_index
+          when :code_inline
+            output << "<code>#{escape_raw(token.content)}</code>"
+          when :math_inline
+            output << "<span class=\"math-inline\">#{escape(token.content)}</span>"
+          when :footnote_ref
+            label = escape_attribute(token.attrs[:label])
+            @footnote_order << token.attrs[:label] unless @footnote_order.include?(token.attrs[:label])
+            number = @footnote_order.index(token.attrs[:label]) + 1
+            output << "<sup id=\"fnref-#{label}\"><a href=\"#fn-#{label}\">#{number}</a></sup>"
+          when :link_open
+            close_index = find_close(tokens, index, :link_close)
+            reference = @reference_definitions[token.attrs[:reference_label]]
+            unless reference || token.markup != "reference"
+              literal = reference_literal(token, tokens[(index + 1)...close_index])
+              output << escape(literal)
+              index = close_index
+              next
+            end
+            href = token.attrs[:href] || reference&.fetch(:url, "") || ""
+            title = token.attrs[:title] || reference&.fetch(:title, nil)
+            title = title.to_s.gsub(/\\([!\"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])/, '\\1') if title
+            title_attribute = title ? " title=\"#{escape_attribute(title)}\"" : ""
+            unescape_url = token.markup != "autolink"
+            output << "<a href=\"#{escape_url_attribute(href, unescape: unescape_url)}\"#{title_attribute}>#{render_inline_tokens(tokens[(index + 1)...close_index])}</a>"
+            index = close_index
+          when :image
+            reference = @reference_definitions[token.attrs[:reference_label]]
+            source = token.attrs[:src] || reference&.fetch(:url, nil)
+            unless source
+              label = token.attrs[:reference_label]
+              suffix = token.attrs[:reference_kind] == :full ? "[#{label}]" : ""
+              output << escape("![#{token.attrs[:alt] || token.content}]#{suffix}")
+              index += 1
+              next
+            end
+            attrs = "src=\"#{escape_url_attribute(source, unescape: true)}\" alt=\"#{escape_attribute(image_alt(token.attrs[:alt] || token.content))}\""
+            title = token.attrs[:title] || reference&.fetch(:title, nil)
+            attrs += " title=\"#{escape_attribute(title)}\"" if title
+            output << "<img #{attrs} />"
+          when :softbreak
+            output << "\n"
+          when :hardbreak
+            output << "<br />\n"
+          when :html_inline
+            output << token.content
+          end
+          index += 1
+        end
+        output
+      end
+
+      def render_table(token)
+        rows = token.meta.fetch(:rows, [])
+        return "" if rows.empty?
+
+        header = rows.first.map { |cell| "<th>#{render_cell(cell)}</th>" }.join
+        body = rows.drop(1).map do |row|
+          cells = row.map { |cell| "<td>#{render_cell(cell)}</td>" }.join
+          "<tr>#{cells}</tr>\n"
+        end.join
+        "<table>\n<thead><tr>#{header}</tr></thead>\n<tbody>\n#{body}</tbody>\n</table>\n"
+      end
+
+      def collapse_tight_item(item)
+        match = item.match(/\A<p>(.*)<\/p>\n\z/m)
+        return match[1] if match
+        return "\n#{item}" if item.start_with?("<hr />\n")
+
+        item.sub(/\A<p>(.*)<\/p>\n(?=<(?:ul|ol)>)/m, "\\1\n")
+      end
+
+      def collect_reference_definitions(tokens)
+        tokens.each do |token|
+          next unless token.type == :reference_definition
+
+          label = token.attrs[:label]
+          @reference_definitions[label] ||= {
+            url: token.attrs[:url],
+            title: token.attrs[:title]
+          }
+        end
+      end
+
+      def render_footnotes
+        output = +"<section class=\"footnotes\">\n<ol>\n"
+        @footnote_order.each do |label|
+          token = @footnote_definitions[label]
+          content = token ? render_footnote_content(token.attrs[:content]) : ""
+          safe_label = escape_attribute(label)
+          output << "<li id=\"fn-#{safe_label}\">#{content} <a href=\"#fnref-#{safe_label}\">↩︎</a></li>\n"
+        end
+        output << "</ol>\n</section>\n"
+      end
+
+      def render_footnote_content(content)
+        inner_tokens = Parser.parse("#{content}\n", @options)
+        render_sequence(inner_tokens, 0).first
+      end
+
+      def render_directive(token)
+        name = token.meta[:name].to_s.downcase
+        return token.content unless %w[note tip important warning caution message details].include?(name)
+
+        lines = token.content.gsub(/\r\n/, "\n").split("\n", -1)
+        lines.shift
+        lines.pop while lines.last.to_s.empty?
+        lines.pop if lines.last.to_s.strip == ":::"
+        inner_source = lines.join("\n")
+        inner_source += "\n" unless inner_source.empty?
+        inner_tokens = Parser.parse(inner_source, @options)
+        inner_html = render_sequence(inner_tokens, 0).first
+        title = token.meta[:title].to_s
+
+        if name == "details"
+          summary = title.empty? ? "Details" : title
+          "<details>\n<summary>#{escape(summary)}</summary>\n#{inner_html}</details>\n"
+        else
+          title_html = title.empty? ? "" : "<p class=\"markdown-directive-title\">#{escape(title)}</p>\n"
+          "<aside class=\"markdown-directive markdown-directive-#{escape_attribute(name)}\">\n#{title_html}#{inner_html}</aside>\n"
+        end
+      end
+
+      def render_cell(value)
+        inline_tokens = Parser::InlineParser.new(@options).parse(value.to_s)
+        render_inline_tokens(inline_tokens)
+      end
+
+      def image_alt(value)
+        tokens = Parser::InlineParser.new(@options).parse(value.to_s)
+        tokens.filter_map do |token|
+          case token.type
+          when :text, :code_inline, :math_inline
+            token.content
+          when :image
+            token.attrs[:alt] || token.content
+          end
+        end.join
+      end
+
+      def fenced_code(token)
+        language = token.info.to_s.split.first
+        language = decode_entities(language.to_s).gsub(/\\([!\"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])/, '\\1')
+        class_attribute = language && !language.empty? ? " class=\"language-#{escape_attribute(language)}\"" : ""
+        "<pre><code#{class_attribute}>#{escape_raw(token.content)}</code></pre>\n"
+      end
+
+      def task_checkbox(checked)
+        checked_attribute = checked ? " checked" : ""
+        "<input type=\"checkbox\" disabled#{checked_attribute}> "
+      end
+
+      def find_close(tokens, index, close_type)
+        tokens[(index + 1)..]&.index { |token| token.type == close_type }&.+(index + 1) || tokens.length
+      end
+
+      def reference_literal(token, inner_tokens)
+        inner = inner_tokens.to_a.map { |inner_token| inner_token.content || "" }.join
+        if token.attrs[:reference_kind] == :full
+          "[#{inner}][#{token.attrs[:reference_label]}]"
+        else
+          "[#{inner}]"
+        end
+      end
+
+      def escape(value)
+        CGI.escapeHTML(decode_entities(value.to_s)).gsub("&#39;", "'")
+      end
+
+      def escape_attribute(value)
+        CGI.escapeHTML(decode_entities(value.to_s)).gsub("`", "&#39;")
+      end
+
+      def escape_url_attribute(value, unescape: true)
+        encoded = unescape ? value.to_s.gsub(/\\([!\"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])/, '\\1') : value.to_s
+        encoded = decode_entities(encoded)
+        encoded = URI::DEFAULT_PARSER.escape(encoded, /[^A-Za-z0-9\-._~;\/:?@&=+$,#%!()*']/)
+        CGI.escapeHTML(encoded).gsub("`", "&#39;")
+      end
+
+      def escape_raw(value)
+        CGI.escapeHTML(value.to_s).gsub("&#39;", "'")
+      end
+
+      def decode_entities(value)
+        value.gsub(/&#x([0-9a-f]+);|&#([0-9]+);|&([A-Za-z][A-Za-z0-9]+);/i) do
+          codepoint = if Regexp.last_match(1)
+                        Integer(Regexp.last_match(1).to_s, 16)
+                      elsif Regexp.last_match(2)
+                        Regexp.last_match(2).to_i
+                      end
+          if codepoint
+            begin
+              if codepoint.zero?
+                "\uFFFD"
+              elsif codepoint > 0x10ffff || (0xd800..0xdfff).cover?(codepoint)
+                Regexp.last_match(0)
+              else
+                [codepoint].pack("U")
+              end
+            rescue RangeError
+              Regexp.last_match(0)
+            end
+          else
+            NAMED_ENTITIES.fetch(Regexp.last_match(3), Regexp.last_match(0))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mdlint/renderer/md_renderer.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require "set"
+require_relative "../text_width"
 
 module Mdlint
   module Renderer
     class MdRenderer
-      BULLET_MARKERS = %w[- *].freeze
+      BULLET_MARKERS = ["-"].freeze
       HORIZONTAL_RULE = "_" * 70
+      LINE_START_PROHIBITED = /\A[、。，．！？!?、)]|\A[）】」』〉》〕］｝…]/
+      LINE_END_PROHIBITED = /[「『（【〈《〔［｛]\z/
 
       def initialize(options = {})
         @options = options
@@ -103,6 +106,24 @@ module Mdlint
             output << token.content
             output << "\n" unless token.content.end_with?("\n")
             i += 1
+          when :front_matter
+            output << token.content
+            output << "\n" unless token.content.end_with?("\n")
+            output << "\n"
+            i += 1
+          when :directive
+            output << token.content
+            output << "\n" unless token.content.end_with?("\n")
+            output << "\n"
+            i += 1
+          when :table
+            render_table(token, output)
+            i += 1
+          when :math_block, :footnote_definition
+            output << token.content
+            output << "\n" unless token.content.end_with?("\n")
+            output << "\n"
+            i += 1
           when :reference_definition
             # Skip - will be output at the end
             i += 1
@@ -177,23 +198,57 @@ module Mdlint
           words.each do |word|
             if current_line.empty?
               current_line = word
-            elsif (current_line.length + 1 + word.length) <= width
+            elsif (TextWidth.measure(current_line) + 1 + TextWidth.measure(word)) <= width
               current_line += " " + word
             else
-              lines << current_line
+              lines.concat(split_to_width(current_line, width))
               current_line = word
             end
           end
 
-          lines << current_line unless current_line.empty?
+          lines.concat(split_to_width(current_line, width)) unless current_line.empty?
           lines << "" if idx < paragraphs.length - 1
         end
 
         lines.join("\n")
       end
 
+      def split_to_width(text, width)
+        return [text] if TextWidth.measure(text) <= width
+
+        chunks = []
+        remaining = text
+        while !remaining.empty?
+          chunk = TextWidth.take(remaining, width).to_s
+          break if chunk.empty?
+
+          if remaining.length > chunk.length && chunk.match?(LINE_END_PROHIBITED)
+            moved = chunk[-1].to_s
+            chunk = chunk[0...-1].to_s
+            remaining = moved + (remaining[chunk.length + 1..] || "")
+          end
+
+          if remaining.match?(LINE_START_PROHIBITED)
+            first = remaining[0].to_s
+            first_width = TextWidth.measure(first)
+            if TextWidth.measure(chunk) + first_width <= width
+              chunk = chunk.to_s + first
+              remaining = remaining[1..] || ""
+            elsif chunk.length > 1
+              moved = chunk[-1].to_s
+              chunk = chunk[0...-1].to_s
+              remaining = moved + remaining.to_s
+            end
+          end
+
+          chunks << chunk
+          remaining = remaining[chunk.length..] || ""
+        end
+        chunks
+      end
+
       def render_bullet_list(tokens, start_index, output)
-        marker = BULLET_MARKERS[@bullet_list_depth % 2]
+        marker = BULLET_MARKERS[@bullet_list_depth % BULLET_MARKERS.length]
         @bullet_list_depth += 1
         i = start_index + 1
 
@@ -236,6 +291,7 @@ module Mdlint
       end
 
       def render_list_item(tokens, start_index, output, prefix)
+        open_token = tokens[start_index]
         i = start_index + 1
         item_content = []
 
@@ -260,10 +316,70 @@ module Mdlint
         end
 
         content = item_content.join("\n").strip
-        output << "#{prefix}#{content}\n"
+        task_prefix = if open_token.attrs[:task]
+                        checked = open_token.attrs[:checked] ? "x" : " "
+                        "[#{checked}] "
+                      else
+                        ""
+                      end
+        output << "#{prefix}#{task_prefix}#{content}\n"
         i + 1
       end
 
+      def render_table(token, output)
+        rows = token.meta.fetch(:rows, [])
+        return if rows.empty?
+
+        alignments = token.meta.fetch(:alignments, [])
+        if @options.fetch(:table_align, true)
+          column_count = rows.map(&:length).max || 0
+          widths = column_count.times.map do |index|
+            [rows.map { |row| TextWidth.measure(row[index].to_s) }.max || 0, 3].max
+          end
+          output << "| #{render_table_row(rows.first, widths, alignments)} |\n"
+          separators = widths.each_index.map { |index| table_separator(alignments[index], widths[index]) }
+          output << "| #{separators.join(" | ")} |\n"
+          rows.drop(1).each { |row| output << "| #{render_table_row(row, widths, alignments)} |\n" }
+        else
+          header = rows.first
+          output << "| #{header.join(" | ")} |\n"
+          separators = header.each_index.map { |index| table_separator(alignments[index], 3) }
+          output << "| #{separators.join(" | ")} |\n"
+          rows.drop(1).each { |row| output << "| #{row.join(" | ")} |\n" }
+        end
+        output << "\n"
+      end
+
+      def render_table_row(row, widths, alignments)
+        widths.each_index.map do |index|
+          value = row[index].to_s
+          padding = widths[index] - TextWidth.measure(value)
+          case alignments[index]
+          when :right
+            " " * padding + value
+          when :center
+            left = padding / 2
+            " " * left + value + " " * (padding - left)
+          else
+            value + " " * padding
+          end
+        end.join(" | ")
+      end
+
+      def table_separator(alignment, width)
+        width = [width, 3].max
+        case alignment
+        when :center
+          ":#{"-" * width}:"
+        when :left
+          ":#{"-" * width}"
+        when :right
+          "#{"-" * width}:"
+        else
+          "-" * width
+        end
+      end
+
       def collect_paragraph_content(tokens, start_index, content_array)
         i = start_index + 1
         while i < tokens.length && tokens[i].type != :paragraph_close
@@ -276,6 +392,7 @@ module Mdlint
       end
 
       def render_blockquote(tokens, start_index, output)
+        open_token = tokens[start_index]
         i = start_index + 1
         inner_output = []
 
@@ -294,6 +411,11 @@ module Mdlint
         end
 
         quoted = inner_output.join.chomp.split("\n").map { |l| "> #{l}".rstrip }.join("\n")
+        if open_token.attrs[:alert]
+          label = open_token.attrs[:alert].upcase
+          quoted = "> [!#{label}]\n#{quoted}" unless quoted.empty?
+          quoted = "> [!#{label}]" if quoted.empty?
+        end
         output << "#{quoted}\n\n"
         i + 1
       end
@@ -365,6 +487,10 @@ module Mdlint
             else
               output << "#{backticks}#{content}#{backticks}"
             end
+          when :math_inline
+            output << "$#{token.content}$"
+          when :footnote_ref
+            output << "[^#{token.attrs[:label]}]"
           when :strong_open
             markup = token.markup.empty? ? "**" : token.markup
             close_index = find_close_token(tokens, i, :strong_close)
@@ -377,6 +503,11 @@ module Mdlint
             inner = render_inline_tokens(tokens[(i + 1)...close_index])
             output << "#{markup}#{inner}#{markup}"
             i = close_index
+          when :s_open
+            close_index = find_close_token(tokens, i, :s_close)
+            inner = render_inline_tokens(tokens[(i + 1)...close_index])
+            output << "~~#{inner}~~"
+            i = close_index
           when :link_open
             close_index = find_close_token(tokens, i, :link_close)
             inner = render_inline_tokens(tokens[(i + 1)...close_index])
@@ -413,12 +544,17 @@ module Mdlint
             i = close_index
           when :image
             alt = token.attrs[:alt] || token.content || ""
-            src = token.attrs[:src] || ""
-            title = token.attrs[:title]
-            if title
-              output << "![#{alt}](#{src} \"#{title}\")"
+            reference = @reference_definitions[token.attrs[:reference_label]]
+            src = token.attrs[:src] || reference&.fetch(:url, nil)
+            unless src
+              output << "![#{alt}]"
             else
-              output << "![#{alt}](#{src})"
+              title = token.attrs[:title] || reference&.fetch(:title, nil)
+              if title
+                output << "![#{alt}](#{src} \"#{title}\")"
+              else
+                output << "![#{alt}](#{src})"
+              end
             end
           when :softbreak
             output << "\n"

data/lib/mdlint/renderer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "renderer/md_renderer"
+require_relative "renderer/html_renderer"
 
 module Mdlint
   module Renderer
@@ -8,6 +9,10 @@ module Mdlint
       def render(tokens, options = {})
         MdRenderer.new(options).render(tokens)
       end
+
+      def render_html(tokens, options = {})
+        HtmlRenderer.new(options).render(tokens)
+      end
     end
   end
 end

data/lib/mdlint/text_width.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mdlint
+  module TextWidth
+    class << self
+      def measure(text)
+        text.to_s.each_codepoint.sum { |codepoint| wide?(codepoint) ? 2 : 1 }
+      end
+
+      def take(text, maximum)
+        width = 0
+        result = +""
+        text.each_char do |character|
+          character_width = measure(character)
+          break if width + character_width > maximum
+
+          result << character
+          width += character_width
+        end
+        result
+      end
+
+      private
+
+      def wide?(codepoint)
+        (0x1100..0x115F).cover?(codepoint) ||
+          (0x2329..0x232A).cover?(codepoint) ||
+          (0x2E80..0xA4CF).cover?(codepoint) ||
+          (0xAC00..0xD7A3).cover?(codepoint) ||
+          (0xF900..0xFAFF).cover?(codepoint) ||
+          (0xFE10..0xFE19).cover?(codepoint) ||
+          (0xFE30..0xFE6F).cover?(codepoint) ||
+          (0xFF00..0xFF60).cover?(codepoint) ||
+          (0xFFE0..0xFFE6).cover?(codepoint) ||
+          (0x1F300..0x1FAFF).cover?(codepoint)
+      end
+    end
+  end
+end