commonmarker 0.23.1 → 0.23.5

data/ext/commonmarker/table.c

@@ -114,60 +114,94 @@ 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;
+  int int_overflow_abort = 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;
+      }
+
+      // make sure we never wrap row->n_columns
+      // offset will != len and our exit will clean up as intended
+      if (row->n_columns == UINT16_MAX) {
+          int_overflow_abort = 1;
+          break;
+      }
+      row->n_columns += 1;
+      row->cells = cmark_llist_append(parser->mem, row->cells, cell);
+    }
 
-      if (string[cell_end_offset] == '\n' || string[cell_end_offset] == '\r') {
-        row->paragraph_offset = cell_end_offset;
+    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 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);
-      }
-    }
-
-    offset += cell_matched + pipe_matched;
+        // Scan past the (optional) leading pipe.
+        offset += scan_table_cell_end(string, len, offset);
 
-    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 || int_overflow_abort) {
     free_table_row(parser->mem, row);
     row = NULL;
   }
@@ -199,8 +233,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 +240,48 @@ 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 may be optimized out, don't rely on it for security boundaries
+  if (!marker_row) {
+      return parent_container;
+  }
+  
   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));
+    // row_from_string can return NULL, add additional check to ensure n_columns match
+    if (!marker_row || !header_row || header_row->n_columns != marker_row->n_columns) {
+        free_table_row(parser->mem, marker_row);
+        free_table_row(parser->mem, header_row);
+        return parent_container;
+    }
   }
 
   if (!cmark_node_set_type(parent_container, CMARK_NODE_TABLE)) {
@@ -257,13 +296,13 @@ 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);
 
+  // allocate alignments based on marker_row->n_columns
+  // since we populate the alignments array based on marker_row->cells
   uint8_t *alignments =
-      (uint8_t *)parser->mem->calloc(header_row->n_columns, sizeof(uint8_t));
+      (uint8_t *)parser->mem->calloc(marker_row->n_columns, sizeof(uint8_t));
   cmark_llist *it = marker_row->cells;
   for (i = 0; it; it = it->next, ++i) {
     node_cell *node = (node_cell *)it->data;
@@ -332,6 +371,12 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
   row = row_from_string(self, parser, input + cmark_parser_get_first_nonspace(parser),
       len - cmark_parser_get_first_nonspace(parser));
 
+  if (!row) {
+      // clean up the dangling node
+      cmark_node_free(table_row_block);
+      return NULL;
+  }
+
   {
     cmark_llist *tmp;
     int i, table_columns = get_n_table_columns(parent_container);

data/lib/commonmarker/config.rb

@@ -30,7 +30,7 @@ module CommonMarker
         TABLE_PREFER_STYLE_ATTRIBUTES: (1 << 15),
         FULL_INFO_STRING: (1 << 16),
       }.freeze,
-      format: %i[html xml commonmark plaintext].freeze
+      format: [:html, :xml, :commonmark, :plaintext].freeze,
     }.freeze
 
     def self.process_options(option, type)

data/lib/commonmarker/node/inspect.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'pp'
+require "pp"
 
 module CommonMarker
   class Node
@@ -8,33 +8,23 @@ module CommonMarker
       PP_INDENT_SIZE = 2
 
       def inspect
-        PP.pp(self, +'', Float::INFINITY)
+        PP.pp(self, +"", Float::INFINITY)
       end
 
       # @param printer [PrettyPrint] pp
       def pretty_print(printer)
-        printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", '>') do
+        printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", ">") do
           printer.breakable
 
-          attrs = %i[
-            sourcepos
-            string_content
-            url
-            title
-            header_level
-            list_type
-            list_start
-            list_tight
-            fence_info
-          ].map do |name|
+          attrs = [:sourcepos, :string_content, :url, :title, :header_level, :list_type, :list_start, :list_tight, :fence_info].map do |name|
             [name, __send__(name)]
           rescue NodeError
             nil
           end.compact
 
           printer.seplist(attrs) do |name, value|
-            printer.text "#{name}="
-            printer.pp value
+            printer.text("#{name}=")
+            printer.pp(value)
           end
 
           if first_child
@@ -46,8 +36,8 @@ module CommonMarker
                 children << node
                 node = node.next
               end
-              printer.text 'children='
-              printer.pp children
+              printer.text("children=")
+              printer.pp(children)
             end
           end
         end

data/lib/commonmarker/node.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'commonmarker/node/inspect'
+require "commonmarker/node/inspect"
 
 module CommonMarker
   class Node
@@ -27,7 +27,7 @@ module CommonMarker
     # Returns a {String}.
     def to_html(options = :DEFAULT, extensions = [])
       opts = Config.process_options(options, :render)
-      _render_html(opts, extensions).force_encoding('utf-8')
+      _render_html(opts, extensions).force_encoding("utf-8")
     end
 
     # Public: Convert the node to an XML string.
@@ -37,7 +37,7 @@ module CommonMarker
     # Returns a {String}.
     def to_xml(options = :DEFAULT)
       opts = Config.process_options(options, :render)
-      _render_xml(opts).force_encoding('utf-8')
+      _render_xml(opts).force_encoding("utf-8")
     end
 
     # Public: Convert the node to a CommonMark string.
@@ -48,7 +48,7 @@ module CommonMarker
     # Returns a {String}.
     def to_commonmark(options = :DEFAULT, width = 120)
       opts = Config.process_options(options, :render)
-      _render_commonmark(opts, width).force_encoding('utf-8')
+      _render_commonmark(opts, width).force_encoding("utf-8")
     end
 
     # Public: Convert the node to a plain text string.
@@ -59,7 +59,7 @@ module CommonMarker
     # Returns a {String}.
     def to_plaintext(options = :DEFAULT, width = 120)
       opts = Config.process_options(options, :render)
-      _render_plaintext(opts, width).force_encoding('utf-8')
+      _render_plaintext(opts, width).force_encoding("utf-8")
     end
 
     # Public: Iterate over the children (if any) of the current pointer.
@@ -76,7 +76,7 @@ module CommonMarker
 
     # Deprecated: Please use `each` instead
     def each_child(&block)
-      warn '[DEPRECATION] `each_child` is deprecated.  Please use `each` instead.'
+      warn("[DEPRECATION] `each_child` is deprecated.  Please use `each` instead.")
       each(&block)
     end
   end

data/lib/commonmarker/renderer/html_renderer.rb

@@ -9,8 +9,8 @@ module CommonMarker
 
     def header(node)
       block do
-        out('<h', node.header_level, "#{sourcepos(node)}>", :children,
-            '</h', node.header_level, '>')
+        out("<h", node.header_level, "#{sourcepos(node)}>", :children,
+          "</h", node.header_level, ">")
       end
     end
 
@@ -19,10 +19,10 @@ module CommonMarker
         out(:children)
       else
         block do
-          container("<p#{sourcepos(node)}>", '</p>') do
+          container("<p#{sourcepos(node)}>", "</p>") do
             out(:children)
             if node.parent.type == :footnote_definition && node.next.nil?
-              out(' ')
+              out(" ")
               out_footnote_backref
             end
           end
@@ -36,16 +36,16 @@ module CommonMarker
 
       block do
         if node.list_type == :bullet_list
-          container("<ul#{sourcepos(node)}>\n", '</ul>') do
+          container("<ul#{sourcepos(node)}>\n", "</ul>") do
             out(:children)
           end
         else
           start = if node.list_start == 1
-                    "<ol#{sourcepos(node)}>\n"
-                  else
-                    "<ol start=\"#{node.list_start}\"#{sourcepos(node)}>\n"
-                  end
-          container(start, '</ol>') do
+            "<ol#{sourcepos(node)}>\n"
+          else
+            "<ol start=\"#{node.list_start}\"#{sourcepos(node)}>\n"
+          end
+          container(start, "</ol>") do
             out(:children)
           end
         end
@@ -57,26 +57,26 @@ module CommonMarker
     def list_item(node)
       block do
         tasklist_data = tasklist(node)
-        container("<li#{sourcepos(node)}#{tasklist_data}>#{' ' if tasklist?(node)}", '</li>') do
+        container("<li#{sourcepos(node)}#{tasklist_data}>#{" " if tasklist?(node)}", "</li>") do
           out(:children)
         end
       end
     end
 
     def tasklist(node)
-      return '' unless tasklist?(node)
+      return "" unless tasklist?(node)
 
       state = if checked?(node)
-                'checked="" disabled=""'
-              else
-                'disabled=""'
-              end
+        'checked="" disabled=""'
+      else
+        'disabled=""'
+      end
       "><input type=\"checkbox\" #{state} /"
     end
 
     def blockquote(node)
       block do
-        container("<blockquote#{sourcepos(node)}>\n", '</blockquote>') do
+        container("<blockquote#{sourcepos(node)}>\n", "</blockquote>") do
           out(:children)
         end
       end
@@ -93,17 +93,17 @@ module CommonMarker
         if option_enabled?(:GITHUB_PRE_LANG)
           out("<pre#{sourcepos(node)}")
           out(' lang="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
-          out('><code>')
+          out("><code>")
         else
           out("<pre#{sourcepos(node)}><code")
           if node.fence_info && !node.fence_info.empty?
             out(' class="language-', node.fence_info.split(/\s+/)[0], '">')
           else
-            out('>')
+            out(">")
           end
         end
         out(escape_html(node.string_content))
-        out('</code></pre>')
+        out("</code></pre>")
       end
     end
 
@@ -112,7 +112,7 @@ module CommonMarker
         if option_enabled?(:UNSAFE)
           out(tagfilter(node.string_content))
         else
-          out('<!-- raw HTML omitted -->')
+          out("<!-- raw HTML omitted -->")
         end
       end
     end
@@ -121,22 +121,22 @@ module CommonMarker
       if option_enabled?(:UNSAFE)
         out(tagfilter(node.string_content))
       else
-        out('<!-- raw HTML omitted -->')
+        out("<!-- raw HTML omitted -->")
       end
     end
 
     def emph(_)
-      out('<em>', :children, '</em>')
+      out("<em>", :children, "</em>")
     end
 
     def strong(_)
-      out('<strong>', :children, '</strong>')
+      out("<strong>", :children, "</strong>")
     end
 
     def link(node)
-      out('<a href="', node.url.nil? ? '' : escape_href(node.url), '"')
+      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>')
+      out(">", :children, "</a>")
     end
 
     def image(node)
@@ -145,7 +145,7 @@ module CommonMarker
         out(' alt="', :children, '"')
       end
       out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
-      out(' />')
+      out(" />")
     end
 
     def text(node)
@@ -153,9 +153,9 @@ module CommonMarker
     end
 
     def code(node)
-      out('<code>')
+      out("<code>")
       out(escape_html(node.string_content))
-      out('</code>')
+      out("</code>")
     end
 
     def linebreak(_node)
@@ -166,7 +166,7 @@ module CommonMarker
       if option_enabled?(:HARDBREAKS)
         out("<br />\n")
       elsif option_enabled?(:NOBREAKS)
-        out(' ')
+        out(" ")
       else
         out("\n")
       end
@@ -199,17 +199,17 @@ module CommonMarker
 
     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
+      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")
       @column_index += 1
     end
 
     def strikethrough(_)
-      out('<del>', :children, '</del>')
+      out("<del>", :children, "</del>")
     end
 
     def footnote_reference(node)
@@ -242,7 +242,7 @@ module CommonMarker
     end
 
     def tasklist?(node)
-      node.type_string == 'tasklist'
+      node.type_string == "tasklist"
     end
 
     def checked?(node)

data/lib/commonmarker/renderer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'stringio'
+require "set"
+require "stringio"
 
 module CommonMarker
   class Renderer
@@ -9,9 +9,9 @@ module CommonMarker
 
     def initialize(options: :DEFAULT, extensions: [])
       @opts = Config.process_options(options, :render)
-      @stream = StringIO.new(+'')
+      @stream = StringIO.new(+"")
       @need_blocksep = false
-      @warnings = Set.new []
+      @warnings = Set.new([])
       @in_tight = false
       @in_plain = false
       @tagfilter = extensions.include?(:tagfilter)
@@ -121,7 +121,7 @@ module CommonMarker
     end
 
     def sourcepos(node)
-      return '' unless option_enabled?(:SOURCEPOS)
+      return "" unless option_enabled?(:SOURCEPOS)
 
       s = node.sourcepos
       " data-sourcepos=\"#{s[:start_line]}:#{s[:start_column]}-" \

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CommonMarker
-  VERSION = '0.23.1'
+  VERSION = "0.23.5"
 end

data/lib/commonmarker.rb

@@ -1,15 +1,15 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'commonmarker/commonmarker'
-require 'commonmarker/config'
-require 'commonmarker/node'
-require 'commonmarker/renderer'
-require 'commonmarker/renderer/html_renderer'
-require 'commonmarker/version'
+require "commonmarker/commonmarker"
+require "commonmarker/config"
+require "commonmarker/node"
+require "commonmarker/renderer"
+require "commonmarker/renderer/html_renderer"
+require "commonmarker/version"
 
 begin
-  require 'awesome_print'
+  require "awesome_print"
 rescue LoadError; end # rubocop:disable Lint/SuppressedException
 module CommonMarker
   # Public:  Parses a Markdown string into an HTML string.
@@ -23,9 +23,7 @@ module CommonMarker
     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)
-    html.force_encoding('UTF-8')
+    Node.markdown_to_html(text.encode("UTF-8"), opts, extensions)
   end
 
   # Public: Parses a Markdown string into a `document` node.
@@ -39,7 +37,7 @@ module CommonMarker
     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')
+    text = text.encode("UTF-8")
     Node.parse_document(text, text.bytesize, opts, extensions)
   end
 end