markly 0.5.1 → 0.7.0

data/ext/markly/table.c

@@ -114,60 +114,87 @@ static cmark_strbuf *unescape_pipes(cmark_mem *mem, unsigned char *string, bufsi
 static table_row *row_from_string(cmark_syntax_extension *self,
                                   cmark_parser *parser, unsigned char *string,
                                   int len) {
+  // Parses a single table row. It has the following form:
+  // `delim? table_cell (delim table_cell)* delim? newline`
+  // Note that cells are allowed to be empty.
+  //
+  // From the GitHub-flavored Markdown specification:
+  //
+  // > Each row consists of cells containing arbitrary text, in which inlines
+  // > are parsed, separated by pipes (|). A leading and trailing pipe is also
+  // > recommended for clarity of reading, and if there’s otherwise parsing
+  // > ambiguity.
+
   table_row *row = NULL;
   bufsize_t cell_matched = 1, pipe_matched = 1, offset;
-  int cell_end_offset;
+  int expect_more_cells = 1;
+  int row_end_offset = 0;
 
   row = (table_row *)parser->mem->calloc(1, sizeof(table_row));
   row->n_columns = 0;
   row->cells = NULL;
 
+  // Scan past the (optional) leading pipe.
   offset = scan_table_cell_end(string, len, 0);
 
   // Parse the cells of the row. Stop if we reach the end of the input, or if we
   // cannot detect any more cells.
-  while (offset < len && (cell_matched || pipe_matched)) {
+  while (offset < len && expect_more_cells) {
     cell_matched = scan_table_cell(string, len, offset);
     pipe_matched = scan_table_cell_end(string, len, offset + cell_matched);
 
     if (cell_matched || pipe_matched) {
-      cell_end_offset = offset + cell_matched - 1;
+      // We are guaranteed to have a cell, since (1) either we found some
+      // content and cell_matched, or (2) we found an empty cell followed by a
+      // pipe.
+      cmark_strbuf *cell_buf = unescape_pipes(parser->mem, string + offset,
+          cell_matched);
+      cmark_strbuf_trim(cell_buf);
+
+      node_cell *cell = (node_cell *)parser->mem->calloc(1, sizeof(*cell));
+      cell->buf = cell_buf;
+      cell->start_offset = offset;
+      cell->end_offset = offset + cell_matched - 1;
+
+      while (cell->start_offset > 0 && string[cell->start_offset - 1] != '|') {
+        --cell->start_offset;
+        ++cell->internal_offset;
+      }
+
+      row->n_columns += 1;
+      row->cells = cmark_llist_append(parser->mem, row->cells, cell);
+    }
+
+    offset += cell_matched + pipe_matched;
+
+    if (pipe_matched) {
+      expect_more_cells = 1;
+    } else {
+      // We've scanned the last cell. Check if we have reached the end of the row
+      row_end_offset = scan_table_row_end(string, len, offset);
+      offset += row_end_offset;
 
-      if (string[cell_end_offset] == '\n' || string[cell_end_offset] == '\r') {
-        row->paragraph_offset = cell_end_offset;
+      // If the end of the row is not the end of the input,
+      // the row is not a real row but potentially part of the paragraph
+      // preceding the table.
+      if (row_end_offset && offset != len) {
+        row->paragraph_offset = offset;
 
         cmark_llist_free_full(parser->mem, row->cells, (cmark_free_func)free_table_cell);
         row->cells = NULL;
         row->n_columns = 0;
-      } else {
-        cmark_strbuf *cell_buf = unescape_pipes(parser->mem, string + offset,
-            cell_matched);
-        cmark_strbuf_trim(cell_buf);
-
-        node_cell *cell = (node_cell *)parser->mem->calloc(1, sizeof(*cell));
-        cell->buf = cell_buf;
-        cell->start_offset = offset;
-        cell->end_offset = cell_end_offset;
-
-        while (cell->start_offset > 0 && string[cell->start_offset - 1] != '|') {
-          --cell->start_offset;
-          ++cell->internal_offset;
-        }
 
-        row->n_columns += 1;
-        row->cells = cmark_llist_append(parser->mem, row->cells, cell);
-      }
-    }
+        // Scan past the (optional) leading pipe.
+        offset += scan_table_cell_end(string, len, offset);
 
-    offset += cell_matched + pipe_matched;
-
-    if (!pipe_matched) {
-      pipe_matched = scan_table_row_end(string, len, offset);
-      offset += pipe_matched;
+        expect_more_cells = 1;
+      } else {
+        expect_more_cells = 0;
+      }
     }
   }
 
-  if (offset != len || !row->n_columns) {
+  if (offset != len || row->n_columns == 0) {
     free_table_row(parser->mem, row);
     row = NULL;
   }
@@ -199,8 +226,6 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
                                             cmark_parser *parser,
                                             cmark_node *parent_container,
                                             unsigned char *input, int len) {
-  bufsize_t matched =
-      scan_table_start(input, len, cmark_parser_get_first_nonspace(parser));
   cmark_node *table_header;
   table_row *header_row = NULL;
   table_row *marker_row = NULL;
@@ -208,41 +233,37 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   const char *parent_string;
   uint16_t i;
 
-  if (!matched)
-    return parent_container;
-
-  parent_string = cmark_node_get_string_content(parent_container);
-
-  cmark_arena_push();
-
-  header_row = row_from_string(self, parser, (unsigned char *)parent_string,
-                               (int)strlen(parent_string));
-
-  if (!header_row) {
-    free_table_row(parser->mem, header_row);
-    cmark_arena_pop();
+  if (!scan_table_start(input, len, cmark_parser_get_first_nonspace(parser))) {
     return parent_container;
   }
 
+  // Since scan_table_start was successful, we must have a marker row.
   marker_row = row_from_string(self, parser,
                                input + cmark_parser_get_first_nonspace(parser),
                                len - cmark_parser_get_first_nonspace(parser));
-
   assert(marker_row);
 
-  if (header_row->n_columns != marker_row->n_columns) {
-    free_table_row(parser->mem, header_row);
+  cmark_arena_push();
+
+  // Check for a matching header row. We call `row_from_string` with the entire
+  // (potentially long) parent container as input, but this should be safe since
+  // `row_from_string` bails out early if it does not find a row.
+  parent_string = cmark_node_get_string_content(parent_container);
+  header_row = row_from_string(self, parser, (unsigned char *)parent_string,
+                               (int)strlen(parent_string));
+  if (!header_row || header_row->n_columns != marker_row->n_columns) {
     free_table_row(parser->mem, marker_row);
+    free_table_row(parser->mem, header_row);
     cmark_arena_pop();
     return parent_container;
   }
 
   if (cmark_arena_pop()) {
+    marker_row = row_from_string(
+        self, parser, input + cmark_parser_get_first_nonspace(parser),
+        len - cmark_parser_get_first_nonspace(parser));
     header_row = row_from_string(self, parser, (unsigned char *)parent_string,
                                  (int)strlen(parent_string));
-    marker_row = row_from_string(self, parser,
-                                 input + cmark_parser_get_first_nonspace(parser),
-                                 len - cmark_parser_get_first_nonspace(parser));
   }
 
   if (!cmark_node_set_type(parent_container, CMARK_NODE_TABLE)) {
@@ -257,9 +278,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   }
 
   cmark_node_set_syntax_extension(parent_container, self);
-
   parent_container->as.opaque = parser->mem->calloc(1, sizeof(node_table));
-
   set_n_table_columns(parent_container, header_row->n_columns);
 
   uint8_t *alignments =

data/lib/markly/renderer/generic.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'stringio'
+
+module Markly
+  module Renderer
+    class Generic
+      def initialize(flags: DEFAULT, extensions: [])
+        @flags = flags
+        @stream = StringIO.new(+'')
+        @need_blocksep = false
+        @in_tight = false
+        @in_plain = false
+        @tagfilter = extensions.include?(:tagfilter)
+      end
+
+      attr_accessor :in_tight
+      attr_accessor :in_plain
+
+      def out(*args)
+        args.each do |arg|
+          if arg == :children
+            @node.each { |child| out(child) }
+          elsif arg.is_a?(Array)
+            arg.each { |x| render(x) }
+          elsif arg.is_a?(Node)
+            render(arg)
+          else
+            @stream.write(arg)
+          end
+        end
+      end
+
+      def render(node)
+        @node = node
+        if node.type == :document
+          document(node)
+          @stream.string
+        elsif @in_plain && node.type != :text && node.type != :softbreak
+          node.each { |child| render(child) }
+        else
+          send(node.type, node)
+        end
+      end
+
+      def document(_node)
+        out(:children)
+      end
+
+      def code_block(node)
+        code_block(node)
+      end
+
+      def reference_def(_node); end
+
+      def cr
+        return if @stream.string.empty? || @stream.string[-1] == "\n"
+
+        out("\n")
+      end
+
+      def blocksep
+        out("\n")
+      end
+
+      def containersep
+        cr unless @in_tight
+      end
+
+      def block
+        cr
+        yield
+        cr
+      end
+
+      def container(starter, ender)
+        out(starter)
+        yield
+        out(ender)
+      end
+
+      def plain
+        old_in_plain = @in_plain
+        @in_plain = true
+        yield
+        @in_plain = old_in_plain
+      end
+
+      private
+
+      def escape_href(str)
+        @node.html_escape_href(str)
+      end
+
+      def escape_html(str)
+        @node.html_escape_html(str)
+      end
+
+      def tagfilter(str)
+        if @tagfilter
+          str.gsub(
+            %r{
+              <
+              (
+              title|textarea|style|xmp|iframe|
+              noembed|noframes|script|plaintext
+              )
+              (?=\s|>|/>)
+            }xi,
+            '&lt;\1'
+          )
+        else
+          str
+        end
+      end
+
+      def source_position(node)
+        return '' unless flag_enabled?(SOURCE_POSITION)
+
+        s = node.source_position
+        " data-sourcepos=\"#{s[:start_line]}:#{s[:start_column]}-" \
+          "#{s[:end_line]}:#{s[:end_column]}\""
+      end
+
+      def flag_enabled?(flag)
+        (@flags & flag) != 0
+      end
+    end
+  end
+end

data/lib/markly/renderer/html.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require_relative 'generic'
+require 'cgi'
+
+module Markly
+  module Renderer
+    class HTML < Generic
+      def initialize(ids: false, tight: false, **options)
+        super(**options)
+        
+        @ids = ids
+        @section = nil
+        @tight = tight
+      end
+      
+      def document(_)
+        @section = false
+        super
+        out("</ol>\n</section>\n") if @written_footnote_ix
+        out("</section>") if @section
+      end
+
+      def id_for(node)
+        if @ids
+          id = node.to_plaintext.chomp.downcase.gsub(/\s+/, '-')
+          
+          return " id=\"#{CGI.escape_html id}\""
+        end
+      end
+
+      def header(node)
+        block do
+          if @ids
+            out('</section>') if @section
+            @section = true
+            out("<section#{id_for(node)}>")
+          end
+          
+          out('<h', node.header_level, "#{source_position(node)}>", :children,
+              '</h', node.header_level, '>')
+        end
+      end
+
+      def paragraph(node)
+        if @tight && node.parent.type != :blockquote
+          out(:children)
+        else
+          block do
+            container("<p#{source_position(node)}>", '</p>') do
+              out(:children)
+              if node.parent.type == :footnote_definition && node.next.nil?
+                out(' ')
+                out_footnote_backref
+              end
+            end
+          end
+        end
+      end
+
+      def list(node)
+        old_tight = @tight
+        @tight = node.list_tight
+
+        block do
+          if node.list_type == :bullet_list
+            container("<ul#{source_position(node)}>\n", '</ul>') do
+              out(:children)
+            end
+          else
+            start = if node.list_start == 1
+                      "<ol#{source_position(node)}>\n"
+                    else
+                      "<ol start=\"#{node.list_start}\"#{source_position(node)}>\n"
+                    end
+            container(start, '</ol>') do
+              out(:children)
+            end
+          end
+        end
+
+        @tight = old_tight
+      end
+
+      def list_item(node)
+        block do
+          tasklist_data = tasklist(node)
+          container("<li#{source_position(node)}#{tasklist_data}>#{' ' if tasklist?(node)}", '</li>') do
+            out(:children)
+          end
+        end
+      end
+
+      def tasklist(node)
+        return '' unless tasklist?(node)
+
+        state = if checked?(node)
+                  'checked="" disabled=""'
+                else
+                  'disabled=""'
+        end
+        "><input type=\"checkbox\" #{state} /"
+      end
+
+      def blockquote(node)
+        block do
+          container("<blockquote#{source_position(node)}>\n", '</blockquote>') do
+            out(:children)
+          end
+        end
+      end
+
+      def hrule(node)
+        block do
+          out("<hr#{source_position(node)} />")
+        end
+      end
+
+      def code_block(node)
+        block do
+          if flag_enabled?(GITHUB_PRE_LANG)
+            out("<pre#{source_position(node)}")
+            out(' lang="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
+            out('><code>')
+          else
+            out("<pre#{source_position(node)}><code")
+            if node.fence_info && !node.fence_info.empty?
+              out(' class="language-', node.fence_info.split(/\s+/)[0], '">')
+            else
+              out('>')
+            end
+          end
+          out(escape_html(node.string_content))
+          out('</code></pre>')
+        end
+      end
+
+      def html(node)
+        block do
+          if flag_enabled?(UNSAFE)
+            out(tagfilter(node.string_content))
+          else
+            out('<!-- raw HTML omitted -->')
+          end
+        end
+      end
+
+      def inline_html(node)
+        if flag_enabled?(UNSAFE)
+          out(tagfilter(node.string_content))
+        else
+          out('<!-- raw HTML omitted -->')
+        end
+      end
+
+      def emph(_)
+        out('<em>', :children, '</em>')
+      end
+
+      def strong(_)
+        out('<strong>', :children, '</strong>')
+      end
+
+      def link(node)
+        out('<a href="', node.url.nil? ? '' : escape_href(node.url), '"')
+        out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
+        out('>', :children, '</a>')
+      end
+
+      def image(node)
+        out('<img src="', escape_href(node.url), '"')
+        plain do
+          out(' alt="', :children, '"')
+        end
+        out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
+        out(' />')
+      end
+
+      def text(node)
+        out(escape_html(node.string_content))
+      end
+
+      def code(node)
+        out('<code>')
+        out(escape_html(node.string_content))
+        out('</code>')
+      end
+
+      def linebreak(_node)
+        out("<br />\n")
+      end
+
+      def softbreak(_)
+        if flag_enabled?(HARD_BREAKS)
+          out("<br />\n")
+        elsif flag_enabled?(NO_BREAKS)
+          out(' ')
+        else
+          out("\n")
+        end
+      end
+
+      def table(node)
+        @alignments = node.table_alignments
+        @needs_close_tbody = false
+        out("<table#{source_position(node)}>\n", :children)
+        out("</tbody>\n") if @needs_close_tbody
+        out("</table>\n")
+      end
+
+      def table_header(node)
+        @column_index = 0
+
+        @in_header = true
+        out("<thead>\n<tr#{source_position(node)}>\n", :children, "</tr>\n</thead>\n")
+        @in_header = false
+      end
+
+      def table_row(node)
+        @column_index = 0
+        if !@in_header && !@needs_close_tbody
+          @needs_close_tbody = true
+          out("<tbody>\n")
+        end
+        out("<tr#{source_position(node)}>\n", :children, "</tr>\n")
+      end
+
+      def table_cell(node)
+        align = case @alignments[@column_index]
+                when :left then ' align="left"'
+                when :right then ' align="right"'
+                when :center then ' align="center"'
+                else; ''
+                end
+        out(@in_header ? "<th#{align}#{source_position(node)}>" : "<td#{align}#{source_position(node)}>", :children, @in_header ? "</th>\n" : "</td>\n")
+        @column_index += 1
+      end
+
+      def strikethrough(_)
+        out('<del>', :children, '</del>')
+      end
+
+      def footnote_reference(node)
+        out("<sup class=\"footnote-ref\"><a href=\"#fn#{node.string_content}\" id=\"fnref#{node.string_content}\">#{node.string_content}</a></sup>")
+        out(node.to_html)
+      end
+
+      def footnote_definition(_)
+        unless @footnote_ix
+          out("<section class=\"footnotes\" data-footnotes>\n<ol>\n")
+          @footnote_ix = 0
+        end
+
+        @footnote_ix += 1
+        out("<li id=\"fn#{@footnote_ix}\">\n", :children)
+        out("\n") if out_footnote_backref
+        out("</li>\n")
+        # </ol>
+        # </section>
+      end
+
+      private
+
+      def out_footnote_backref
+        return false if @written_footnote_ix == @footnote_ix
+
+        @written_footnote_ix = @footnote_ix
+
+        out("<a href=\"#fnref#{@footnote_ix}\" class=\"footnote-backref\">↩</a>")
+        true
+      end
+
+      def tasklist?(node)
+        node.type_string == 'tasklist'
+      end
+
+      def checked?(node)
+        node.tasklist_item_checked?
+      end
+    end
+  end
+end

data/lib/markly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markly
-	VERSION = '0.5.1'
+	VERSION = '0.7.0'
 end

data/lib/markly.rb

@@ -2,12 +2,12 @@
 # frozen_string_literal: true
 
 # The compiled library.
-require_relative 'markly/markly'
+require 'markly/markly'
 
 require_relative 'markly/flags'
 require_relative 'markly/node'
-require_relative 'markly/renderer'
-require_relative 'markly/renderer/html_renderer'
+require_relative 'markly/renderer/html'
+
 require_relative 'markly/version'
 
 module Markly

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markly
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Garen Torikian
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-31 00:00:00.000000000 Z
+date: 2022-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bake
@@ -150,10 +150,11 @@ files:
 - ext/markly/xml.c
 - lib/markly.rb
 - lib/markly/flags.rb
+- lib/markly/markly.bundle
 - lib/markly/node.rb
 - lib/markly/node/inspect.rb
-- lib/markly/renderer.rb
-- lib/markly/renderer/html_renderer.rb
+- lib/markly/renderer/generic.rb
+- lib/markly/renderer/html.rb
 - lib/markly/version.rb
 homepage: https://github.com/ioquatix/markly
 licenses:
@@ -175,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: CommonMark parser and renderer. Written in C, wrapped in Ruby.