commonmarker 0.19.0 → 0.21.1

data/ext/commonmarker/scanners.h

@@ -26,7 +26,6 @@ bufsize_t _scan_link_title(const unsigned char *p);
 bufsize_t _scan_spacechars(const unsigned char *p);
 bufsize_t _scan_atx_heading_start(const unsigned char *p);
 bufsize_t _scan_setext_heading_line(const unsigned char *p);
-bufsize_t _scan_thematic_break(const unsigned char *p);
 bufsize_t _scan_open_code_fence(const unsigned char *p);
 bufsize_t _scan_close_code_fence(const unsigned char *p);
 bufsize_t _scan_entity(const unsigned char *p);
@@ -50,7 +49,6 @@ bufsize_t _scan_footnote_definition(const unsigned char *p);
 #define scan_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n)
 #define scan_setext_heading_line(c, n)                                         \
   _scan_at(&_scan_setext_heading_line, c, n)
-#define scan_thematic_break(c, n) _scan_at(&_scan_thematic_break, c, n)
 #define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n)
 #define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n)
 #define scan_entity(c, n) _scan_at(&_scan_entity, c, n)

data/ext/commonmarker/table.c

@@ -16,6 +16,7 @@ cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
 
 typedef struct {
   uint16_t n_columns;
+  int paragraph_offset;
   cmark_llist *cells;
 } table_row;
 
@@ -115,6 +116,7 @@ static table_row *row_from_string(cmark_syntax_extension *self,
                                   int len) {
   table_row *row = NULL;
   bufsize_t cell_matched = 1, pipe_matched = 1, offset;
+  int cell_end_offset;
 
   row = (table_row *)parser->mem->calloc(1, sizeof(table_row));
   row->n_columns = 0;
@@ -129,20 +131,32 @@ static table_row *row_from_string(cmark_syntax_extension *self,
     pipe_matched = scan_table_cell_end(string, len, offset + cell_matched);
 
     if (cell_matched || pipe_matched) {
-      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;
+      cell_end_offset = offset + cell_matched - 1;
+
+      if (string[cell_end_offset] == '\n' || string[cell_end_offset] == '\r') {
+        row->paragraph_offset = cell_end_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);
       }
-      row->n_columns += 1;
-      row->cells = cmark_llist_append(parser->mem, row->cells, cell);
     }
 
     offset += cell_matched + pipe_matched;
@@ -161,6 +175,26 @@ static table_row *row_from_string(cmark_syntax_extension *self,
   return row;
 }
 
+static void try_inserting_table_header_paragraph(cmark_parser *parser,
+                                                 cmark_node *parent_container,
+                                                 unsigned char *parent_string,
+                                                 int paragraph_offset) {
+  cmark_node *paragraph;
+  cmark_strbuf *paragraph_content;
+
+  paragraph = cmark_node_new_with_mem(CMARK_NODE_PARAGRAPH, parser->mem);
+
+  paragraph_content = unescape_pipes(parser->mem, parent_string, paragraph_offset);
+  cmark_strbuf_trim(paragraph_content);
+  cmark_node_set_string_content(paragraph, (char *) paragraph_content->ptr);
+  cmark_strbuf_free(paragraph_content);
+  parser->mem->free(paragraph_content);
+
+  if (!cmark_node_insert_before(parent_container, paragraph)) {
+    parser->mem->free(paragraph);
+  }
+}
+
 static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
                                             cmark_parser *parser,
                                             cmark_node *parent_container,
@@ -217,6 +251,11 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
     return parent_container;
   }
 
+  if (header_row->paragraph_offset) {
+    try_inserting_table_header_paragraph(parser, parent_container, (unsigned char *)parent_string,
+                                         header_row->paragraph_offset);
+  }
+
   cmark_node_set_syntax_extension(parent_container, self);
 
   parent_container->as.opaque = parser->mem->calloc(1, sizeof(node_table));

data/ext/commonmarker/tasklist.c

@@ -9,19 +9,33 @@ typedef enum {
   CMARK_TASKLIST_CHECKED,
 } cmark_tasklist_type;
 
+// Local constants
+static const char *TYPE_STRING = "tasklist";
+
 static const char *get_type_string(cmark_syntax_extension *extension, cmark_node *node) {
-  return "tasklist";
+  return TYPE_STRING;
 }
 
-char *cmark_gfm_extensions_get_tasklist_state(cmark_node *node) {
-  if (!node || ((int)node->as.opaque != CMARK_TASKLIST_CHECKED && (int)node->as.opaque != CMARK_TASKLIST_NOCHECKED))
+
+// Return 1 if state was set, 0 otherwise
+int cmark_gfm_extensions_set_tasklist_item_checked(cmark_node *node, bool is_checked) {
+  // The node has to exist, and be an extension, and actually be the right type in order to get the value.
+  if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING))
     return 0;
 
-  if ((int)node->as.opaque != CMARK_TASKLIST_CHECKED) {
-    return "checked";
+  node->as.list.checked = is_checked;
+  return 1;
+}
+
+bool cmark_gfm_extensions_get_tasklist_item_checked(cmark_node *node) {
+  if (!node || !node->extension || strcmp(cmark_node_get_type_string(node), TYPE_STRING))
+    return false;
+
+  if (node->as.list.checked) {
+    return true;
   }
   else {
-    return "unchecked";
+    return false;
   }
 }
 
@@ -74,11 +88,8 @@ static cmark_node *open_tasklist_item(cmark_syntax_extension *self,
   cmark_node_set_syntax_extension(parent_container, self);
   cmark_parser_advance_offset(parser, (char *)input, 3, false);
 
-  if (strstr((char*)input, "[x]")) {
-    parent_container->as.opaque = (void *)CMARK_TASKLIST_CHECKED;
-  } else {
-    parent_container->as.opaque = (void *)CMARK_TASKLIST_NOCHECKED;
-  }
+  // Either an upper or lower case X means the task is completed.
+  parent_container->as.list.checked = (strstr((char*)input, "[x]") || strstr((char*)input, "[X]"));
 
   return NULL;
 }
@@ -89,7 +100,7 @@ static void commonmark_render(cmark_syntax_extension *extension,
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   if (entering) {
     renderer->cr(renderer);
-    if ((int)node->as.opaque == CMARK_TASKLIST_CHECKED) {
+    if (node->as.list.checked) {
       renderer->out(renderer, node, "- [x] ", false, LITERAL);
     } else {
       renderer->out(renderer, node, "- [ ] ", false, LITERAL);
@@ -110,7 +121,7 @@ static void html_render(cmark_syntax_extension *extension,
     cmark_strbuf_puts(renderer->html, "<li");
     cmark_html_render_sourcepos(node, renderer->html, options);
     cmark_strbuf_putc(renderer->html, '>');
-    if ((int)node->as.opaque == CMARK_TASKLIST_CHECKED) {
+    if (node->as.list.checked) {
       cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" checked=\"\" disabled=\"\" /> ");
     } else {
       cmark_strbuf_puts(renderer->html, "<input type=\"checkbox\" disabled=\"\" /> ");
@@ -120,6 +131,15 @@ static void html_render(cmark_syntax_extension *extension,
   }
 }
 
+static const char *xml_attr(cmark_syntax_extension *extension,
+                            cmark_node *node) {
+  if (node->as.list.checked) {
+    return " completed=\"true\"";
+  } else {
+    return " completed=\"false\"";
+  }
+}
+
 cmark_syntax_extension *create_tasklist_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("tasklist");
 
@@ -130,6 +150,7 @@ cmark_syntax_extension *create_tasklist_extension(void) {
   cmark_syntax_extension_set_commonmark_render_func(ext, commonmark_render);
   cmark_syntax_extension_set_plaintext_render_func(ext, commonmark_render);
   cmark_syntax_extension_set_html_render_func(ext, html_render);
+  cmark_syntax_extension_set_xml_attr_func(ext, xml_attr);
 
   return ext;
 }

data/lib/commonmarker.rb

@@ -10,8 +10,7 @@ require 'commonmarker/version'
 
 begin
   require 'awesome_print'
-rescue LoadError; end
-
+rescue LoadError; end # rubocop:disable Lint/SuppressedException
 module CommonMarker
   # Public:  Parses a Markdown string into an HTML string.
   #
@@ -21,7 +20,8 @@ module CommonMarker
   #
   # Returns a {String} of converted HTML.
   def self.render_html(text, options = :DEFAULT, extensions = [])
-    fail TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+    raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+
     opts = Config.process_options(options, :render)
     text = text.encode('UTF-8')
     html = Node.markdown_to_html(text, opts, extensions)
@@ -36,7 +36,8 @@ module CommonMarker
   #
   # Returns the `document` node.
   def self.render_doc(text, options = :DEFAULT, extensions = [])
-    fail TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+    raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+
     opts = Config.process_options(options, :parse)
     text = text.encode('UTF-8')
     Node.parse_document(text, text.bytesize, opts, extensions)

data/lib/commonmarker/config.rb

@@ -37,16 +37,17 @@ module CommonMarker
       elsif option.is_a?(Array)
         option = [nil] if option.empty?
         # neckbearding around. the map will both check the opts and then bitwise-OR it
-        option.map { |o| check_option(o, type); type.to_h[o] }.inject(0, :|)
+        option.map do |o|
+          check_option(o, type)
+          type.to_h[o]
+        end.inject(0, :|)
       else
         raise TypeError, "option type must be a valid symbol or array of symbols within the #{type} context"
       end
     end
 
     def self.check_option(option, type)
-      unless type.key?(option)
-        raise TypeError, "option ':#{option}' does not exist for #{type}"
-      end
+      raise TypeError, "option ':#{option}' does not exist for #{type}" unless type.key?(option)
     end
   end
 end

data/lib/commonmarker/node.rb

@@ -53,7 +53,7 @@ module CommonMarker
     end
 
     # Public: Iterate over the children (if any) of the current pointer.
-    def each(&block)
+    def each
       return enum_for(:each) unless block_given?
 
       child = first_child

data/lib/commonmarker/node/inspect.rb

@@ -8,13 +8,13 @@ module CommonMarker
       PP_INDENT_SIZE = 2
 
       def inspect
-        PP.pp(self, String.new, Float::INFINITY)
+        PP.pp(self, +'', Float::INFINITY)
       end
 
-      # @param [PrettyPrint] pp
-      def pretty_print(pp)
-        pp.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", '>') do
-          pp.breakable
+      # @param printer [PrettyPrint] pp
+      def pretty_print(printer)
+        printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", '>') do
+          printer.breakable
 
           attrs = %i[
             sourcepos
@@ -34,22 +34,22 @@ module CommonMarker
             end
           end.compact
 
-          pp.seplist(attrs) do |name, value|
-            pp.text "#{name}="
-            pp.pp value
+          printer.seplist(attrs) do |name, value|
+            printer.text "#{name}="
+            printer.pp value
           end
 
           if first_child
-            pp.breakable
-            pp.group(PP_INDENT_SIZE) do
+            printer.breakable
+            printer.group(PP_INDENT_SIZE) do
               children = []
               node = first_child
               while node
                 children << node
                 node = node.next
               end
-              pp.text 'children='
-              pp.pp children
+              printer.text 'children='
+              printer.pp children
             end
           end
         end

data/lib/commonmarker/renderer.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-# rubocop:disable Standard/RailsViewRenderLiteral
-# rubocop:disable Standard/RailsControllerRenderLiteral
 
 require 'set'
 require 'stringio'
@@ -10,7 +8,7 @@ module CommonMarker
     attr_accessor :in_tight, :warnings, :in_plain
     def initialize(options: :DEFAULT, extensions: [])
       @opts = Config.process_options(options, :render)
-      @stream = StringIO.new(''.dup.force_encoding('utf-8'))
+      @stream = StringIO.new(+'')
       @need_blocksep = false
       @warnings = Set.new []
       @in_tight = false
@@ -36,7 +34,7 @@ module CommonMarker
       @node = node
       if node.type == :document
         document(node)
-        return @stream.string
+        @stream.string
       elsif @in_plain && node.type != :text && node.type != :softbreak
         node.each { |child| render(child) }
       else
@@ -57,11 +55,11 @@ module CommonMarker
       code_block(node)
     end
 
-    def reference_def(_node)
-    end
+    def reference_def(_node); end
 
     def cr
       return if @stream.string.empty? || @stream.string[-1] == "\n"
+
       out("\n")
     end
 
@@ -113,7 +111,8 @@ module CommonMarker
             )
             (?=\s|>|/>)
           }xi,
-          '<\1')
+          '<\1'
+        )
       else
         str
       end
@@ -121,6 +120,7 @@ module CommonMarker
 
     def sourcepos(node)
       return '' unless option_enabled?(:SOURCEPOS)
+
       s = node.sourcepos
       " data-sourcepos=\"#{s[:start_line]}:#{s[:start_column]}-" \
         "#{s[:end_line]}:#{s[:end_column]}\""

data/lib/commonmarker/renderer/html_renderer.rb

@@ -2,15 +2,9 @@
 
 module CommonMarker
   class HtmlRenderer < Renderer
-    def render(node)
-      super(node)
-    end
-
     def document(_)
       super
-      if @written_footnote_ix
-        out("</ol>\n</section>\n")
-      end
+      out("</ol>\n</section>\n") if @written_footnote_ix
     end
 
     def header(node)
@@ -71,12 +65,13 @@ module CommonMarker
 
     def tasklist(node)
       return '' unless tasklist?(node)
+
       state = if checked?(node)
-        'disabled=""'
-      else
-        'checked="" disabled=""'
-      end
-      return "><input type=\"checkbox\" #{state} /"
+                'checked="" disabled=""'
+              else
+                'disabled=""'
+              end
+      "><input type=\"checkbox\" #{state} /"
     end
 
     def blockquote(node)
@@ -97,9 +92,7 @@ module CommonMarker
       block do
         if option_enabled?(:GITHUB_PRE_LANG)
           out("<pre#{sourcepos(node)}")
-          if node.fence_info && !node.fence_info.empty?
-            out(' lang="', node.fence_info.split(/\s+/)[0], '"')
-          end
+          out(' lang="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
           out('><code>')
         else
           out("<pre#{sourcepos(node)}><code")
@@ -142,9 +135,7 @@ module CommonMarker
 
     def link(node)
       out('<a href="', node.url.nil? ? '' : escape_href(node.url), '"')
-      if node.title && !node.title.empty?
-        out(' title="', escape_html(node.title), '"')
-      end
+      out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
       out('>', :children, '</a>')
     end
 
@@ -153,9 +144,7 @@ module CommonMarker
       plain do
         out(' alt="', :children, '"')
       end
-      if node.title && !node.title.empty?
-        out(' title="', escape_html(node.title), '"')
-      end
+      out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
       out(' />')
     end
 
@@ -169,7 +158,7 @@ module CommonMarker
       out('</code>')
     end
 
-    def linebreak(node)
+    def linebreak(_node)
       out("<br />\n")
     end
 
@@ -210,9 +199,9 @@ module CommonMarker
 
     def table_cell(node)
       align = case @alignments[@column_index]
-              when :left; ' align="left"'
-              when :right; ' align="right"'
-              when :center; ' align="center"'
+              when :left then ' align="left"'
+              when :right then ' align="right"'
+              when :center then ' align="center"'
               else; ''
               end
       out(@in_header ? "<th#{align}#{sourcepos(node)}>" : "<td#{align}#{sourcepos(node)}>", :children, @in_header ? "</th>\n" : "</td>\n")
@@ -228,28 +217,27 @@ module CommonMarker
     end
 
     def footnote_definition(_)
-      if !@footnote_ix
+      unless @footnote_ix
         out("<section class=\"footnotes\">\n<ol>\n")
         @footnote_ix = 0
       end
 
       @footnote_ix += 1
-      out("<li id=\"fn#@footnote_ix\">\n", :children)
-      if out_footnote_backref
-        out("\n")
-      end
+      out("<li id=\"fn#{@footnote_ix}\">\n", :children)
+      out("\n") if out_footnote_backref
       out("</li>\n")
-#</ol>
-#</section>
+      # </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>")
+      out("<a href=\"#fnref#{@footnote_ix}\" class=\"footnote-backref\">↩</a>")
       true
     end
 
@@ -258,8 +246,7 @@ module CommonMarker
     end
 
     def checked?(node)
-      node.tasklist_state == 'checked'
+      node.tasklist_item_checked?
     end
-
   end
 end