commonmarker 0.20.1 → 0.22.0

data/ext/commonmarker/node.h

@@ -21,6 +21,7 @@ typedef struct {
   cmark_delim_type delimiter;
   unsigned char bullet_char;
   bool tight;
+  bool checked; // For task list extension
 } cmark_list;
 
 typedef struct {

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;
   }
 }
 
@@ -75,11 +89,7 @@ static cmark_node *open_tasklist_item(cmark_syntax_extension *self,
   cmark_parser_advance_offset(parser, (char *)input, 3, false);
 
   // Either an upper or lower case X means the task is completed.
-  if (strstr((char*)input, "[x]") || strstr((char*)input, "[X]")) {
-    parent_container->as.opaque = (void *)CMARK_TASKLIST_CHECKED;
-  } else {
-    parent_container->as.opaque = (void *)CMARK_TASKLIST_NOCHECKED;
-  }
+  parent_container->as.list.checked = (strstr((char*)input, "[x]") || strstr((char*)input, "[X]"));
 
   return NULL;
 }
@@ -90,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);
@@ -111,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=\"\" /> ");
@@ -121,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");
 
@@ -131,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

@@ -1,52 +1,46 @@
 # frozen_string_literal: true
 
-require 'ruby-enum'
 module CommonMarker
   # For Ruby::Enum, these must be classes, not modules
   module Config
-    class Parse
-      include Ruby::Enum
-
-      define :DEFAULT, 0
-      define :VALIDATE_UTF8, (1 << 9)
-      define :SMART, (1 << 10)
-      define :LIBERAL_HTML_TAG, (1 << 12)
-      define :FOOTNOTES, (1 << 13)
-      define :STRIKETHROUGH_DOUBLE_TILDE, (1 << 14)
-      define :UNSAFE, (1 << 17)
-    end
-
-    class Render
-      include Ruby::Enum
-
-      define :DEFAULT, 0
-      define :SOURCEPOS, (1 << 1)
-      define :HARDBREAKS, (1 << 2)
-      define :NOBREAKS, (1 << 4)
-      define :GITHUB_PRE_LANG, (1 << 11)
-      define :TABLE_PREFER_STYLE_ATTRIBUTES, (1 << 15)
-      define :FULL_INFO_STRING, (1 << 16)
-      define :UNSAFE, (1 << 17)
-    end
+    # See https://github.com/github/cmark-gfm/blob/master/src/cmark-gfm.h#L673
+    OPTS = {
+      parse: {
+        DEFAULT: 0,
+        VALIDATE_UTF8: (1 << 9),
+        SMART: (1 << 10),
+        LIBERAL_HTML_TAG: (1 << 12),
+        FOOTNOTES: (1 << 13),
+        STRIKETHROUGH_DOUBLE_TILDE: (1 << 14),
+        UNSAFE: (1 << 17)
+      }.freeze,
+      render: {
+        DEFAULT: 0,
+        SOURCEPOS: (1 << 1),
+        HARDBREAKS: (1 << 2),
+        NOBREAKS: (1 << 4),
+        GITHUB_PRE_LANG: (1 << 11),
+        TABLE_PREFER_STYLE_ATTRIBUTES: (1 << 15),
+        FULL_INFO_STRING: (1 << 16),
+        UNSAFE: (1 << 17),
+        FOOTNOTES: (1 << 13)
+      }.freeze
+    }.freeze
 
     def self.process_options(option, type)
-      type = Config.const_get(type.capitalize)
-      if option.is_a?(Symbol)
-        check_option(option, type)
-        type.to_h[option]
-      elsif option.is_a?(Array)
-        option = [nil] if option.empty?
+      case option
+      when Symbol
+        OPTS.fetch(type).fetch(option)
+      when Array
+        raise TypeError if option.none?
+
         # 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, :|)
+        OPTS.fetch(type).fetch_values(*option).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}"
+        raise TypeError, "option type must be a valid symbol or array of symbols within the #{name}::OPTS[:#{type}] context"
       end
+    rescue KeyError => e
+      raise TypeError, "option ':#{e.key}' does not exist for #{name}::OPTS[:#{type}]"
     end
   end
 end

data/lib/commonmarker/node.rb

@@ -11,7 +11,7 @@ module CommonMarker
     #
     # blk - A {Proc} representing the action to take for each child
     def walk(&block)
-      return enum_for(:walk) unless block_given?
+      return enum_for(:walk) unless block
 
       yield self
       each do |child|
@@ -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
@@ -27,29 +27,27 @@ module CommonMarker
             list_tight
             fence_info
           ].map do |name|
-            begin
-              [name, __send__(name)]
-            rescue NodeError
-              nil
-            end
+            [name, __send__(name)]
+          rescue NodeError
+            nil
           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

@@ -6,9 +6,10 @@ require 'stringio'
 module CommonMarker
   class Renderer
     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
@@ -18,11 +19,12 @@ module CommonMarker
 
     def out(*args)
       args.each do |arg|
-        if arg == :children
+        case arg
+        when :children
           @node.each { |child| out(child) }
-        elsif arg.is_a?(Array)
+        when Array
           arg.each { |x| render(x) }
-        elsif arg.is_a?(Node)
+        when Node
           render(arg)
         else
           @stream.write(arg)
@@ -34,7 +36,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
@@ -55,11 +57,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
 
@@ -111,7 +113,8 @@ module CommonMarker
             )
             (?=\s|>|/>)
           }xi,
-          '<\1')
+          '<\1'
+        )
       else
         str
       end
@@ -119,13 +122,14 @@ 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]}\""
     end
 
     def option_enabled?(opt)
-      (@opts & CommonMarker::Config::Render.value(opt)) != 0
+      (@opts & CommonMarker::Config::OPTS.dig(:render, opt)) != 0
     end
   end
 end