commonmarker 0.23.1 → 0.23.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f620ec82d102c4726e551911d21a5d87e7185010ba711f6ddc35495184c90ba
-  data.tar.gz: cf14b3a68481564facd7fbb46c90c822757d168db7eb41786b3a2d0ee3173e66
+  metadata.gz: be9868bfb1c9bf09a7f274abf44ef7692be355141e7a4a3d956b3f889869cefd
+  data.tar.gz: 8b09575b5209fcb2f80919dd46a89de97f52e61fc8f7b2d6d49c2243ff8c18ee
 SHA512:
-  metadata.gz: 6a4d50388ad098dd9ccfd7e733e9a1274841e4b5d929d76e4f2e75ec10c55889ee85ef55afdb5ef5665214e6abde73e75bcd647fd2a53c6aa985a9396922992b
-  data.tar.gz: a1e587570999fbc0c5f6423f7dcf375a8b2ffee2339939e2ca80807b5950c042656a498ea4acfaf3b60ba45d14fdc8f4655a0a936a06d966a89d3f9133a32188
+  metadata.gz: fffd100b88072cd573d8c3c13a81e437a08b69e48225b7abc2f8d20ffa188b021f1f779dab7d38b85c0d611261db7e4024a47ceeb7f08cba6334d8d5fc3f9e86
+  data.tar.gz: ee8039d05a8cb7a31803a1da6f4f20ea77e7420a3549e1edcb11190e3f65edbff54ed88707d5576de02b7ae8d1195061e40b75c83ab34357964820bca8b30795

data/Rakefile

@@ -1,108 +1,109 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'rake/clean'
-require 'rake/extensiontask'
-require 'digest/md5'
+require "date"
+require "rake/clean"
+require "rake/extensiontask"
+require "digest/md5"
 
-host_os = RbConfig::CONFIG['host_os']
-require 'devkit' if host_os == 'mingw32'
+host_os = RbConfig::CONFIG["host_os"]
+require "devkit" if host_os == "mingw32"
 
 task default: [:test]
 
 # Gem Spec
-gem_spec = Gem::Specification.load('commonmarker.gemspec')
+gem_spec = Gem::Specification.load("commonmarker.gemspec")
 
 # Ruby Extension
-Rake::ExtensionTask.new('commonmarker', gem_spec) do |ext|
-  ext.lib_dir = File.join('lib', 'commonmarker')
+Rake::ExtensionTask.new("commonmarker", gem_spec) do |ext|
+  ext.lib_dir = File.join("lib", "commonmarker")
 end
 
 # Packaging
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
 
 # Testing
-require 'rake/testtask'
+require "rake/testtask"
 
-Rake::TestTask.new('test:unit') do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/test_*.rb'
+Rake::TestTask.new("test:unit") do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/test_*.rb"
   t.verbose = true
   t.warning = false
 end
 
-task 'test:unit' => :compile
+desc "Run unit tests"
+task "test:unit" => :compile
 
-desc 'Run unit and conformance tests'
-task test: %w[test:unit]
+desc "Run unit and conformance tests"
+task test: ["test:unit"]
 
-require 'rubocop/rake_task'
+require "rubocop/rake_task"
 
 RuboCop::RakeTask.new(:rubocop)
 
-desc 'Run benchmarks'
+desc "Run benchmarks"
 task :benchmark do
-  if ENV['FETCH_PROGIT']
-    `rm -rf test/progit`
-    `git clone https://github.com/progit/progit.git test/progit`
-    langs = %w[ar az be ca cs de en eo es es-ni fa fi fr hi hu id it ja ko mk nl no-nb pl pt-br ro ru sr th tr uk vi zh zh-tw]
+  if ENV["FETCH_PROGIT"]
+    %x(rm -rf test/progit)
+    %x(git clone https://github.com/progit/progit.git test/progit)
+    langs = ["ar", "az", "be", "ca", "cs", "de", "en", "eo", "es", "es-ni", "fa", "fi", "fr", "hi", "hu", "id", "it", "ja", "ko", "mk", "nl", "no-nb", "pl", "pt-br", "ro", "ru", "sr", "th", "tr", "uk", "vi", "zh", "zh-tw"]
     langs.each do |lang|
-      `cat test/progit/#{lang}/*/*.markdown >> test/benchinput.md`
+      %x(cat test/progit/#{lang}/*/*.markdown >> test/benchinput.md)
     end
   end
-  $LOAD_PATH.unshift 'lib'
-  load 'test/benchmark.rb'
+  $LOAD_PATH.unshift("lib")
+  load "test/benchmark.rb"
 end
 
-desc 'Match C style of cmark'
+desc "Match C style of cmark"
 task :format do
-  sh 'clang-format -style llvm -i ext/commonmarker/*.c ext/commonmarker/*.h'
+  sh "clang-format -style llvm -i ext/commonmarker/*.c ext/commonmarker/*.h"
 end
 
 # Documentation
-require 'rdoc/task'
+require "rdoc/task"
 
-desc 'Generate API documentation'
+desc "Generate API documentation"
 RDoc::Task.new do |rd|
-  rd.rdoc_dir = 'docs'
-  rd.main     = 'README.md'
-  rd.rdoc_files.include 'README.md', 'lib/**/*.rb', 'ext/commonmarker/commonmarker.c'
-
-  rd.options << '--markup tomdoc'
-  rd.options << '--inline-source'
-  rd.options << '--line-numbers'
-  rd.options << '--all'
-  rd.options << '--fileboxes'
+  rd.rdoc_dir = "docs"
+  rd.main     = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb", "ext/commonmarker/commonmarker.c")
+
+  rd.options << "--markup tomdoc"
+  rd.options << "--inline-source"
+  rd.options << "--line-numbers"
+  rd.options << "--all"
+  rd.options << "--fileboxes"
 end
 
-desc 'Generate the documentation and run a web server'
+desc "Generate the documentation and run a web server"
 task serve: [:rdoc] do
-  require 'webrick'
+  require "webrick"
 
-  puts 'Navigate to http://localhost:3000 to see the docs'
+  puts "Navigate to http://localhost:3000 to see the docs"
 
-  server = WEBrick::HTTPServer.new Port: 3000
-  server.mount '/', WEBrick::HTTPServlet::FileHandler, 'docs'
-  trap('INT') { server.stop }
+  server = WEBrick::HTTPServer.new(Port: 3000)
+  server.mount("/", WEBrick::HTTPServlet::FileHandler, "docs")
+  trap("INT") { server.stop }
   server.start
 end
 
-desc 'Generate and publish docs to gh-pages'
+desc "Generate and publish docs to gh-pages"
 task publish: [:rdoc] do
-  require 'tmpdir'
-  require 'shellwords'
+  require "tmpdir"
+  require "shellwords"
 
   Dir.mktmpdir do |tmp|
     system "mv docs/* #{tmp}"
-    system 'git checkout origin/gh-pages'
-    system 'rm -rf *'
+    system "git checkout origin/gh-pages"
+    system "rm -rf *"
     system "mv #{tmp}/* ."
     message = Shellwords.escape("Site updated at #{Time.now.utc}")
-    system 'git add .'
+    system "git add ."
     system "git commit -am #{message}"
-    system 'git push origin gh-pages --force'
-    system 'git checkout master'
-    system 'echo yolo'
+    system "git push origin gh-pages --force"
+    system "git checkout master"
+    system "echo yolo"
   end
 end

data/bin/commonmarker

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require 'ostruct'
 
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'commonmarker'
@@ -11,17 +10,13 @@ root = File.expand_path('..', __dir__)
 $LOAD_PATH.unshift File.expand_path('lib', root)
 
 def parse_options
-  options = OpenStruct.new
+  options = Struct.new(:active_extensions, :active_parse_options, :active_render_options, :output_format, :renderer)
+                  .new([], [:DEFAULT], [:DEFAULT], :html)
   extensions = CommonMarker.extensions
   parse_options = CommonMarker::Config::OPTS.fetch(:parse)
   render_options = CommonMarker::Config::OPTS.fetch(:render)
   format_options = CommonMarker::Config::OPTS.fetch(:format)
 
-  options.active_extensions = []
-  options.active_parse_options = [:DEFAULT]
-  options.active_render_options = [:DEFAULT]
-  options.output_format = :html
-
   option_parser = OptionParser.new do |opts|
     opts.banner = 'Usage: commonmarker [--html-renderer] [--extension=EXTENSION]'
     opts.separator '                    [--to=FORMAT]'

data/commonmarker.gemspec

@@ -1,37 +1,38 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'commonmarker/version'
+require "commonmarker/version"
 
 Gem::Specification.new do |s|
-  s.name = 'commonmarker'
+  s.name = "commonmarker"
   s.version = CommonMarker::VERSION
-  s.summary = 'CommonMark parser and renderer. Written in C, wrapped in Ruby.'
-  s.description = 'A fast, safe, extensible parser for CommonMark. This wraps the official libcmark library.'
-  s.authors = ['Garen Torikian', 'Ashe Connor']
-  s.homepage = 'https://github.com/gjtorikian/commonmarker'
-  s.license = 'MIT'
+  s.summary = "CommonMark parser and renderer. Written in C, wrapped in Ruby."
+  s.description = "A fast, safe, extensible parser for CommonMark. This wraps the official libcmark library."
+  s.authors = ["Garen Torikian", "Ashe Connor"]
+  s.homepage = "https://github.com/gjtorikian/commonmarker"
+  s.license = "MIT"
 
-  s.files         = %w[LICENSE.txt README.md Rakefile commonmarker.gemspec bin/commonmarker]
-  s.files        += Dir.glob('lib/**/*.rb')
-  s.files        += Dir.glob('ext/commonmarker/*.*')
-  s.test_files    = Dir.glob('test/**/*').reject { |f| f == 'test/benchinput.md' || f.start_with?('test/progit/') }
-  s.extensions    = ['ext/commonmarker/extconf.rb']
+  s.files         = ["LICENSE.txt", "README.md", "Rakefile", "commonmarker.gemspec", "bin/commonmarker"]
+  s.files        += Dir.glob("lib/**/*.rb")
+  s.files        += Dir.glob("ext/commonmarker/*.*")
+  s.extensions    = ["ext/commonmarker/extconf.rb"]
 
-  s.executables = ['commonmarker']
-  s.require_paths = %w[lib ext]
-  s.required_ruby_version = ['>= 2.6', '< 4.0']
+  s.executables = ["commonmarker"]
+  s.require_paths = ["lib", "ext"]
+  s.required_ruby_version = [">= 2.6", "< 4.0"]
 
-  s.rdoc_options += ['-x', 'ext/commonmarker/cmark/.*']
+  s.metadata["rubygems_mfa_required"] = "true"
 
-  s.add_development_dependency 'awesome_print'
-  s.add_development_dependency 'json', '~> 2.3'
-  s.add_development_dependency 'minitest', '~> 5.6'
-  s.add_development_dependency 'minitest-focus', '~> 1.1'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rake-compiler', '~> 0.9'
-  s.add_development_dependency 'rdoc', '~> 6.2'
-  s.add_development_dependency 'rubocop'
-  s.add_development_dependency 'rubocop-standard'
+  s.rdoc_options += ["-x", "ext/commonmarker/cmark/.*"]
+
+  s.add_development_dependency("awesome_print")
+  s.add_development_dependency("json", "~> 2.3")
+  s.add_development_dependency("minitest", "~> 5.6")
+  s.add_development_dependency("minitest-focus", "~> 1.1")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rake-compiler", "~> 0.9")
+  s.add_development_dependency("rdoc", "~> 6.2")
+  s.add_development_dependency("rubocop")
+  s.add_development_dependency("rubocop-standard")
 end

data/ext/commonmarker/blocks.c

@@ -468,7 +468,6 @@ static void process_footnotes(cmark_parser *parser) {
   while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
     cur = cmark_iter_get_node(iter);
     if (ev_type == CMARK_EVENT_EXIT && cur->type == CMARK_NODE_FOOTNOTE_DEFINITION) {
-      cmark_node_unlink(cur);
       cmark_footnote_create(map, cur);
     }
   }
@@ -485,6 +484,15 @@ static void process_footnotes(cmark_parser *parser) {
         if (!footnote->ix)
           footnote->ix = ++ix;
 
+        // store a reference to this footnote reference's footnote definition
+        // this is used by renderers when generating label ids
+        cur->parent_footnote_def = footnote->node;
+
+        // keep track of a) count of how many times this footnote def has been
+        // referenced, and b) which reference index this footnote ref is at.
+        // this is used by renderers when generating links and backreferences.
+        cur->footnote.ref_ix = ++footnote->node->footnote.def_count;
+
         char n[32];
         snprintf(n, sizeof(n), "%d", footnote->ix);
         cmark_chunk_free(parser->mem, &cur->as.literal);
@@ -515,13 +523,16 @@ static void process_footnotes(cmark_parser *parser) {
     qsort(map->sorted, map->size, sizeof(cmark_map_entry *), sort_footnote_by_ix);
     for (unsigned int i = 0; i < map->size; ++i) {
       cmark_footnote *footnote = (cmark_footnote *)map->sorted[i];
-      if (!footnote->ix)
+      if (!footnote->ix) {
+        cmark_node_unlink(footnote->node);
         continue;
+      }
       cmark_node_append_child(parser->root, footnote->node);
       footnote->node = NULL;
     }
   }
 
+  cmark_unlink_footnotes_map(map);
   cmark_map_free(map);
 }
 

data/ext/commonmarker/cmark-gfm_version.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_GFM_VERSION_H
 #define CMARK_GFM_VERSION_H
 
-#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 0)
-#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.0"
+#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 4)
+#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.4"
 
 #endif

data/ext/commonmarker/commonmark.c

@@ -477,7 +477,13 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
   case CMARK_NODE_FOOTNOTE_REFERENCE:
     if (entering) {
       LIT("[^");
-      OUT(cmark_chunk_to_cstr(renderer->mem, &node->as.literal), false, LITERAL);
+
+      char *footnote_label = renderer->mem->calloc(node->parent_footnote_def->as.literal.len + 1, sizeof(char));
+      memmove(footnote_label, node->parent_footnote_def->as.literal.data, node->parent_footnote_def->as.literal.len);
+
+      OUT(footnote_label, false, LITERAL);
+      renderer->mem->free(footnote_label);
+
       LIT("]");
     }
     break;
@@ -486,9 +492,13 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     if (entering) {
       renderer->footnote_ix += 1;
       LIT("[^");
-      char n[32];
-      snprintf(n, sizeof(n), "%d", renderer->footnote_ix);
-      OUT(n, false, LITERAL);
+
+      char *footnote_label = renderer->mem->calloc(node->as.literal.len + 1, sizeof(char));
+      memmove(footnote_label, node->as.literal.data, node->as.literal.len);
+
+      OUT(footnote_label, false, LITERAL);
+      renderer->mem->free(footnote_label);
+
       LIT("]:\n");
 
       cmark_strbuf_puts(renderer->prefix, "    ");

data/ext/commonmarker/commonmarker.c

@@ -115,25 +115,23 @@ static void rb_parent_removed(VALUE val) {
   RDATA(val)->dfree = rb_free_c_struct;
 }
 
-static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark_mem *mem) {
+static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions) {
   int options;
-  int extensions_len;
   VALUE rb_ext_name;
   int i;
 
-  Check_Type(rb_options, T_FIXNUM);
+  FIXNUM_P(rb_options);
+  options = FIX2INT(rb_options);
+
   Check_Type(rb_extensions, T_ARRAY);
 
-  options = FIX2INT(rb_options);
-  extensions_len = RARRAY_LEN(rb_extensions);
+  cmark_parser *parser = cmark_parser_new(options);
 
-  cmark_parser *parser = cmark_parser_new_with_mem(options, mem);
-  for (i = 0; i < extensions_len; ++i) {
-    rb_ext_name = RARRAY_PTR(rb_extensions)[i];
+  for (i = 0; i < RARRAY_LEN(rb_extensions); ++i) {
+    rb_ext_name = rb_ary_entry(rb_extensions, i);
 
     if (!SYMBOL_P(rb_ext_name)) {
       cmark_parser_free(parser);
-      cmark_arena_reset();
       rb_raise(rb_eTypeError, "extension names should be Symbols; got a %"PRIsVALUE"", rb_obj_class(rb_ext_name));
     }
 
@@ -142,7 +140,6 @@ static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark
 
     if (!syntax_extension) {
       cmark_parser_free(parser);
-      cmark_arena_reset();
       rb_raise(rb_eArgError, "extension %s not found", rb_id2name(SYM2ID(rb_ext_name)));
     }
 
@@ -157,33 +154,28 @@ static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark
  *
  */
 static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) {
-  char *str, *html;
-  int len;
+  char *html;
   cmark_parser *parser;
   cmark_node *doc;
-  Check_Type(rb_text, T_STRING);
-  Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_arena_mem_allocator());
+  Check_Type(rb_text, T_STRING);
 
-  str = (char *)RSTRING_PTR(rb_text);
-  len = RSTRING_LEN(rb_text);
+  parser = prepare_parser(rb_options, rb_extensions);
 
-  cmark_parser_feed(parser, str, len);
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
   doc = cmark_parser_finish(parser);
+
   if (doc == NULL) {
-    cmark_arena_reset();
+    cmark_parser_free(parser);
     rb_raise(rb_eNodeError, "error parsing document");
   }
 
-  cmark_mem *default_mem = cmark_get_default_mem_allocator();
-  html = cmark_render_html_with_mem(doc, FIX2INT(rb_options), parser->syntax_extensions, default_mem);
-  cmark_arena_reset();
+  html = cmark_render_html(doc, parser->options, parser->syntax_extensions);
 
-  VALUE ruby_html = rb_str_new2(html);
-  default_mem->free(html);
+  cmark_parser_free(parser);
+  cmark_node_free(doc);
 
-  return ruby_html;
+  return rb_utf8_str_new_cstr(html);
 }
 
 /*
@@ -191,33 +183,28 @@ static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VA
  *
  */
 static VALUE rb_markdown_to_xml(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) {
-  char *str, *xml;
-  int len;
+  char *xml;
   cmark_parser *parser;
   cmark_node *doc;
-  Check_Type(rb_text, T_STRING);
-  Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_arena_mem_allocator());
+  Check_Type(rb_text, T_STRING);
 
-  str = (char *)RSTRING_PTR(rb_text);
-  len = RSTRING_LEN(rb_text);
+  parser = prepare_parser(rb_options, rb_extensions);
 
-  cmark_parser_feed(parser, str, len);
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
   doc = cmark_parser_finish(parser);
+
   if (doc == NULL) {
-    cmark_arena_reset();
+    cmark_parser_free(parser);
     rb_raise(rb_eNodeError, "error parsing document");
   }
 
-  cmark_mem *default_mem = cmark_get_default_mem_allocator();
-  xml = cmark_render_xml_with_mem(doc, FIX2INT(rb_options), default_mem);
-  cmark_arena_reset();
+  xml = cmark_render_xml(doc, parser->options);
 
-  VALUE ruby_xml = rb_str_new2(xml);
-  default_mem->free(xml);
+  cmark_parser_free(parser);
+  cmark_node_free(doc);
 
-  return ruby_xml;
+  return rb_utf8_str_new_cstr(xml);
 }
 
 /*
@@ -308,18 +295,17 @@ static VALUE rb_node_new(VALUE self, VALUE type) {
 static VALUE rb_parse_document(VALUE self, VALUE rb_text, VALUE rb_len,
                                VALUE rb_options, VALUE rb_extensions) {
   char *text;
-  int len, options;
+  int len;
   cmark_parser *parser;
   cmark_node *doc;
   Check_Type(rb_text, T_STRING);
   Check_Type(rb_len, T_FIXNUM);
   Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_default_mem_allocator());
+  parser = prepare_parser(rb_options, rb_extensions);
 
   text = (char *)RSTRING_PTR(rb_text);
   len = FIX2INT(rb_len);
-  options = FIX2INT(rb_options);
 
   cmark_parser_feed(parser, text, len);
   doc = cmark_parser_finish(parser);
@@ -614,7 +600,6 @@ static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
  */
 static VALUE rb_render_xml(VALUE self, VALUE rb_options) {
   int options;
-  int i;
   cmark_node *node;
   Check_Type(rb_options, T_FIXNUM);
 
@@ -1270,6 +1255,7 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_define_singleton_method(module, "extensions", rb_extensions, 0);
   rb_eNodeError = rb_define_class_under(module, "NodeError", rb_eStandardError);
   rb_cNode = rb_define_class_under(module, "Node", rb_cObject);
+  rb_undef_alloc_func(rb_cNode);
   rb_define_singleton_method(rb_cNode, "markdown_to_html", rb_markdown_to_html,
                              3);
   rb_define_singleton_method(rb_cNode, "markdown_to_xml", rb_markdown_to_xml,