qiita_marker 0.23.6.2 → 0.23.9.0

data/ext/qiita_marker/scanners.h

@@ -15,6 +15,10 @@ bufsize_t _scan_autolink_uri(const unsigned char *p);
 bufsize_t _scan_autolink_email(const unsigned char *p);
 bufsize_t _scan_html_tag(const unsigned char *p);
 bufsize_t _scan_liberal_html_tag(const unsigned char *p);
+bufsize_t _scan_html_comment(const unsigned char *p);
+bufsize_t _scan_html_pi(const unsigned char *p);
+bufsize_t _scan_html_declaration(const unsigned char *p);
+bufsize_t _scan_html_cdata(const unsigned char *p);
 bufsize_t _scan_html_block_start(const unsigned char *p);
 bufsize_t _scan_html_block_start_7(const unsigned char *p);
 bufsize_t _scan_html_block_end_1(const unsigned char *p);
@@ -37,6 +41,10 @@ bufsize_t _scan_footnote_definition(const unsigned char *p);
 #define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n)
 #define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n)
 #define scan_liberal_html_tag(c, n) _scan_at(&_scan_liberal_html_tag, c, n)
+#define scan_html_comment(c, n) _scan_at(&_scan_html_comment, c, n)
+#define scan_html_pi(c, n) _scan_at(&_scan_html_pi, c, n)
+#define scan_html_declaration(c, n) _scan_at(&_scan_html_declaration, c, n)
+#define scan_html_cdata(c, n) _scan_at(&_scan_html_cdata, c, n)
 #define scan_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n)
 #define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n)
 #define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n)

data/ext/qiita_marker/strikethrough.c

@@ -67,6 +67,7 @@ static delimiter *insert(cmark_syntax_extension *self, cmark_parser *parser,
   strikethrough->end_column = closer->inl_text->start_column + closer->inl_text->as.literal.len - 1;
   cmark_node_free(closer->inl_text);
 
+done:
   delim = closer;
   while (delim != NULL && delim != opener) {
     tmp_delim = delim->previous;
@@ -76,7 +77,6 @@ static delimiter *insert(cmark_syntax_extension *self, cmark_parser *parser,
 
   cmark_inline_parser_remove_delimiter(inline_parser, opener);
 
-done:
   return res;
 }
 

data/ext/qiita_marker/table.c

@@ -11,13 +11,21 @@
 #include "table.h"
 #include "cmark-gfm-core-extensions.h"
 
+// Custom node flag, initialized in `create_table_extension`.
+static cmark_node_internal_flags CMARK_NODE__TABLE_VISITED;
+
 cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
     CMARK_NODE_TABLE_CELL;
 
+typedef struct {
+  cmark_strbuf *buf;
+  int start_offset, end_offset, internal_offset;
+} node_cell;
+
 typedef struct {
   uint16_t n_columns;
   int paragraph_offset;
-  cmark_llist *cells;
+  node_cell *cells;
 } table_row;
 
 typedef struct {
@@ -29,24 +37,24 @@ typedef struct {
   bool is_header;
 } node_table_row;
 
-typedef struct {
-  cmark_strbuf *buf;
-  int start_offset, end_offset, internal_offset;
-} node_cell;
-
-static void free_table_cell(cmark_mem *mem, void *data) {
-  node_cell *cell = (node_cell *)data;
+static void free_table_cell(cmark_mem *mem, node_cell *cell) {
   cmark_strbuf_free((cmark_strbuf *)cell->buf);
   mem->free(cell->buf);
-  mem->free(cell);
+}
+
+static void free_row_cells(cmark_mem *mem, table_row *row) {
+  while (row->n_columns > 0) {
+    free_table_cell(mem, &row->cells[--row->n_columns]);
+  }
+  mem->free(row->cells);
+  row->cells = NULL;
 }
 
 static void free_table_row(cmark_mem *mem, table_row *row) {
   if (!row)
     return;
 
-  cmark_llist_free_full(mem, row->cells, (cmark_free_func)free_table_cell);
-
+  free_row_cells(mem, row);
   mem->free(row);
 }
 
@@ -111,6 +119,24 @@ static cmark_strbuf *unescape_pipes(cmark_mem *mem, unsigned char *string, bufsi
   return res;
 }
 
+// Adds a new cell to the end of the row. A pointer to the new cell is returned
+// for the caller to initialize.
+static node_cell* append_row_cell(cmark_mem *mem, table_row *row) {
+  const uint32_t n_columns = row->n_columns + 1;
+  // realloc when n_columns is a power of 2
+  if ((n_columns & (n_columns-1)) == 0) {
+    // make sure we never wrap row->n_columns
+    // offset will != len and our exit will clean up as intended
+    if (n_columns > UINT16_MAX) {
+      return NULL;
+    }
+    // Use realloc to double the size of the buffer.
+    row->cells = (node_cell *)mem->realloc(row->cells, (2 * n_columns - 1) * sizeof(node_cell));
+  }
+  row->n_columns = (uint16_t)n_columns;
+  return &row->cells[n_columns-1];
+}
+
 static table_row *row_from_string(cmark_syntax_extension *self,
                                   cmark_parser *parser, unsigned char *string,
                                   int len) {
@@ -152,24 +178,22 @@ static table_row *row_from_string(cmark_syntax_extension *self,
           cell_matched);
       cmark_strbuf_trim(cell_buf);
 
-      node_cell *cell = (node_cell *)parser->mem->calloc(1, sizeof(*cell));
+      node_cell *cell = append_row_cell(parser->mem, row);
+      if (!cell) {
+        int_overflow_abort = 1;
+        cmark_strbuf_free(cell_buf);
+        parser->mem->free(cell_buf);
+        break;
+      }
       cell->buf = cell_buf;
       cell->start_offset = offset;
       cell->end_offset = offset + cell_matched - 1;
+      cell->internal_offset = 0;
 
-      while (cell->start_offset > 0 && string[cell->start_offset - 1] != '|') {
+      while (cell->start_offset > row->paragraph_offset && 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);
     }
 
     offset += cell_matched + pipe_matched;
@@ -187,9 +211,7 @@ static table_row *row_from_string(cmark_syntax_extension *self,
       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;
+        free_row_cells(parser->mem, row);
 
         // Scan past the (optional) leading pipe.
         offset += scan_table_cell_end(string, len, offset);
@@ -240,6 +262,10 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   const char *parent_string;
   uint16_t i;
 
+  if (parent_container->flags & CMARK_NODE__TABLE_VISITED) {
+    return parent_container;
+  }
+
   if (!scan_table_start(input, len, cmark_parser_get_first_nonspace(parser))) {
     return parent_container;
   }
@@ -267,6 +293,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
     free_table_row(parser->mem, marker_row);
     free_table_row(parser->mem, header_row);
     cmark_arena_pop();
+    parent_container->flags |= CMARK_NODE__TABLE_VISITED;
     return parent_container;
   }
 
@@ -303,9 +330,8 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   // since we populate the alignments array based on marker_row->cells
   uint8_t *alignments =
       (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;
+  for (i = 0; i < marker_row->n_columns; ++i) {
+    node_cell *node = &marker_row->cells[i];
     bool left = node->buf->ptr[0] == ':', right = node->buf->ptr[node->buf->size - 1] == ':';
 
     if (left && right)
@@ -328,10 +354,8 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   ntr->is_header = true;
 
   {
-    cmark_llist *tmp;
-
-    for (tmp = header_row->cells; tmp; tmp = tmp->next) {
-      node_cell *cell = (node_cell *) tmp->data;
+    for (i = 0; i < header_row->n_columns; ++i) {
+      node_cell *cell = &header_row->cells[i];
       cmark_node *header_cell = cmark_parser_add_child(parser, table_header,
           CMARK_NODE_TABLE_CELL, parent_container->start_column + cell->start_offset);
       header_cell->start_line = header_cell->end_line = parent_container->start_line;
@@ -378,11 +402,10 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
   }
 
   {
-    cmark_llist *tmp;
     int i, table_columns = get_n_table_columns(parent_container);
 
-    for (tmp = row->cells, i = 0; tmp && i < table_columns; tmp = tmp->next, ++i) {
-      node_cell *cell = (node_cell *) tmp->data;
+    for (i = 0; i < row->n_columns && i < table_columns; ++i) {
+      node_cell *cell = &row->cells[i];
       cmark_node *node = cmark_parser_add_child(parser, table_row_block,
           CMARK_NODE_TABLE_CELL, parent_container->start_column + cell->start_offset);
       node->internal_offset = cell->internal_offset;
@@ -785,6 +808,7 @@ static int escape(cmark_syntax_extension *self, cmark_node *node, int c) {
 cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension *self = cmark_syntax_extension_new("table");
 
+  cmark_register_node_flag(&CMARK_NODE__TABLE_VISITED);
   cmark_syntax_extension_set_match_block_func(self, matches);
   cmark_syntax_extension_set_open_block_func(self, try_opening_table_block);
   cmark_syntax_extension_set_get_type_string_func(self, get_type_string);

data/ext/qiita_marker/xml.c

@@ -11,6 +11,7 @@
 #include "syntax_extension.h"
 
 #define BUFFER_SIZE 100
+#define MAX_INDENT 40
 
 // Functions to convert cmark_nodes to XML strings.
 
@@ -26,7 +27,7 @@ struct render_state {
 
 static CMARK_INLINE void indent(struct render_state *state) {
   int i;
-  for (i = 0; i < state->indent; i++) {
+  for (i = 0; i < state->indent && i < MAX_INDENT; i++) {
     cmark_strbuf_putc(state->xml, ' ');
   }
 }

data/lib/qiita_marker/config.rb

@@ -38,20 +38,22 @@ module QiitaMarker
       format: [:html, :xml, :commonmark, :plaintext].freeze,
     }.freeze
 
-    def self.process_options(option, type)
-      case option
-      when Symbol
-        OPTS.fetch(type).fetch(option)
-      when Array
-        raise TypeError if option.none?
+    class << self
+      def process_options(option, type)
+        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
-        OPTS.fetch(type).fetch_values(*option).inject(0, :|)
-      else
-        raise TypeError, "option type must be a valid symbol or array of symbols within the #{name}::OPTS[:#{type}] context"
+          # neckbearding around. the map will both check the opts and then bitwise-OR it
+          OPTS.fetch(type).fetch_values(*option).inject(0, :|)
+        else
+          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
-    rescue KeyError => e
-      raise TypeError, "option ':#{e.key}' does not exist for #{name}::OPTS[:#{type}]"
     end
   end
 end

data/lib/qiita_marker/renderer/html_renderer.rb

@@ -9,8 +9,15 @@ module QiitaMarker
 
     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
 
@@ -133,8 +140,12 @@ module QiitaMarker
       out("<em>", :children, "</em>")
     end
 
-    def strong(_)
-      out("<strong>", :children, "</strong>")
+    def strong(node)
+      if node.parent&.type == :strong
+        out(:children)
+      else
+        out("<strong>", :children, "</strong>")
+      end
     end
 
     def link(node)

data/lib/qiita_marker/renderer.rb

@@ -113,7 +113,7 @@ module QiitaMarker
             )
             (?=\s|>|/>)
           }xi,
-          '<\1'
+          '<\1',
         )
       else
         str

data/lib/qiita_marker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QiitaMarker
-  VERSION = "0.23.6.2"
+  VERSION = "0.23.9.0"
 end

data/lib/qiita_marker.rb

@@ -12,32 +12,34 @@ begin
   require "awesome_print"
 rescue LoadError; end # rubocop:disable Lint/SuppressedException
 module QiitaMarker
-  # Public:  Parses a Markdown string into an HTML string.
-  #
-  # text - A {String} of text
-  # option - Either a {Symbol} or {Array of Symbol}s indicating the render options
-  # extensions - An {Array of Symbol}s indicating the extensions to use
-  #
-  # Returns a {String} of converted HTML.
-  def self.render_html(text, options = :DEFAULT, extensions = [])
-    raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+  class << self
+    # Public:  Parses a Markdown string into an HTML string.
+    #
+    # text - A {String} of text
+    # option - Either a {Symbol} or {Array of Symbol}s indicating the render options
+    # extensions - An {Array of Symbol}s indicating the extensions to use
+    #
+    # Returns a {String} of converted HTML.
+    def render_html(text, options = :DEFAULT, extensions = [])
+      raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
 
-    opts = Config.process_options(options, :render)
-    Node.markdown_to_html(text.encode("UTF-8"), opts, extensions)
-  end
+      opts = Config.process_options(options, :render)
+      Node.markdown_to_html(text.encode("UTF-8"), opts, extensions)
+    end
 
-  # Public: Parses a Markdown string into a `document` node.
-  #
-  # string - {String} to be parsed
-  # option - A {Symbol} or {Array of Symbol}s indicating the parse options
-  # extensions - An {Array of Symbol}s indicating the extensions to use
-  #
-  # Returns the `document` node.
-  def self.render_doc(text, options = :DEFAULT, extensions = [])
-    raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+    # Public: Parses a Markdown string into a `document` node.
+    #
+    # string - {String} to be parsed
+    # option - A {Symbol} or {Array of Symbol}s indicating the parse options
+    # extensions - An {Array of Symbol}s indicating the extensions to use
+    #
+    # Returns the `document` node.
+    def render_doc(text, options = :DEFAULT, extensions = [])
+      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)
+      opts = Config.process_options(options, :parse)
+      text = text.encode("UTF-8")
+      Node.parse_document(text, text.bytesize, opts, extensions)
+    end
   end
 end

data/qiita_marker.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.executables = ["qiita_marker"]
   s.require_paths = ["lib", "ext"]
-  s.required_ruby_version = [">= 2.7", "< 4.0"]
+  s.required_ruby_version = [">= 3.0", "< 4.0"]
 
   s.metadata["rubygems_mfa_required"] = "true"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita_marker
 version: !ruby/object:Gem::Version
-  version: 0.23.6.2
+  version: 0.23.9.0
 platform: ruby
 authors:
 - Qiita Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-21 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -252,7 +252,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
   - - "<"
     - !ruby/object:Gem::Version
       version: '4.0'
@@ -262,7 +262,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Qiita Marker is a Ruby library for Markdown processing, based on CommonMarker.