commonmarker 0.21.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c1642f2a40e94bb6d7313e15132072165164ae450f33ecb91ab2602bd4e4030
-  data.tar.gz: f6f3bf78fe2a4c330f1edb7ffe77cee2c25ca9589f7df3e49a0efe1617a16121
+  metadata.gz: c52b70b0c680aae2d46b089b673745cbe586f1e27589bd81b1f3f0f091a7659d
+  data.tar.gz: 400efb13ab3ba9c72d451be4cd4cac8ee17688f70733d6d57771a093e412b63f
 SHA512:
-  metadata.gz: ed5866d1a0b1431c45223e23589538c7d8e58199caf6400fdaec84a95a9d634714be7be21900d65941ffb88656831db6920a9eb53b99161a74eba0f2a3fdc6bb
-  data.tar.gz: 7ad8a9b062ed1d7d87899b93507c4002fe5f18eba12ca22bc33c70e37851ac64aadfadd9f9418d33656bec2d523d2f687f4994327864170062cb24cef5117ec8
+  metadata.gz: 99309c1ab3c30c524adac6be1f75b3e63fe166b9248f8a8e74bd228a2428b10c794a56a3d5390786e4b33a869531f5879461c73d1ae7aaea66be491000779761
+  data.tar.gz: 2c4ac9a297cfb0204eb4355f0aa3e8471ddd2f6bf9162e7db2a71f16e32f3470779f86082e8aa9473ddf0f45ee3df41d133a7f073209c3d1441da4468266297d

data/README.md

@@ -1,6 +1,6 @@
 # CommonMarker
 
-[![Build Status](https://travis-ci.org/gjtorikian/commonmarker.svg)](https://travis-ci.org/gjtorikian/commonmarker) [![Gem Version](https://badge.fury.io/rb/commonmarker.svg)](http://badge.fury.io/rb/commonmarker)
+![Build Status](https://github.com/gjtorikian/commonmarker/workflows/CI/badge.svg) [![Gem Version](https://badge.fury.io/rb/commonmarker.svg)](http://badge.fury.io/rb/commonmarker)
 
 Ruby wrapper for [libcmark-gfm](https://github.com/github/cmark),
 GitHub's fork of the reference parser for CommonMark. It passes all of the C tests, and is therefore spec-complete. It also includes extensions to the CommonMark spec as documented in the [GitHub Flavored Markdown spec](http://github.github.com/gfm/), such as support for tables, strikethroughs, and autolinking.
@@ -139,16 +139,17 @@ CommonMarker accepts the same options that CMark does, as symbols. Note that the
 
 ### Render options
 
-| Name                             | Description                                                    |
-| ------------------               | -----------                                                    |
-| `:DEFAULT`                       | The default rendering system.                                  |
-| `:UNSAFE`                        | Allow raw/custom HTML and unsafe links.                        |
-| `:GITHUB_PRE_LANG`               | Use GitHub-style `<pre lang>` for fenced code blocks.          |
-| `:HARDBREAKS`                    | Treat `\n` as hardbreaks (by adding `<br/>`).                  |
-| `:NOBREAKS`                      | Translate `\n` in the source to a single whitespace.           |
-| `:SOURCEPOS`                     | Include source position in rendered HTML.                      |
-| `:TABLE_PREFER_STYLE_ATTRIBUTES` | Use `style` insted of `align` for table cells                  |
-| `:FULL_INFO_STRING`              | Include full info strings of code blocks in separate attribute |
+| Name                             | Description                                                     |
+| ------------------               | -----------                                                     |
+| `:DEFAULT`                       | The default rendering system.                                   |
+| `:UNSAFE`                        | Allow raw/custom HTML and unsafe links.                         |
+| `:GITHUB_PRE_LANG`               | Use GitHub-style `<pre lang>` for fenced code blocks.           |
+| `:HARDBREAKS`                    | Treat `\n` as hardbreaks (by adding `<br/>`).                   |
+| `:NOBREAKS`                      | Translate `\n` in the source to a single whitespace.            |
+| `:SOURCEPOS`                     | Include source position in rendered HTML.                       |
+| `:TABLE_PREFER_STYLE_ATTRIBUTES` | Use `style` insted of `align` for table cells.                  |
+| `:FULL_INFO_STRING`              | Include full info strings of code blocks in separate attribute. |
+| `:FOOTNOTES`                     | Render footnotes.                                               |
 
 ### Passing options
 
@@ -179,6 +180,76 @@ The available extensions are:
 * `:autolink` - This provides support for automatically converting URLs to anchor tags.
 * `:tagfilter` - This escapes [several "unsafe" HTML tags](https://github.github.com/gfm/#disallowed-raw-html-extension-), causing them to not have any effect.
 
+## Output formats
+
+Like CMark, CommonMarker can generate output in several formats: HTML, XML, plaintext, and commonmark are currently supported.
+
+### HTML
+
+The default output format, HTML, will be generated when calling `to_html` or using `--to=html` on the command line.
+
+```ruby
+doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
+puts(doc.to_html)
+
+<p><em>Hello</em> world!</p>
+```
+
+### XML
+
+XML will be generated when calling `to_xml` or using `--to=xml` on the command line.
+
+```ruby
+doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
+puts(doc.to_xml)
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE document SYSTEM "CommonMark.dtd">
+<document xmlns="http://commonmark.org/xml/1.0">
+  <paragraph>
+    <emph>
+      <text xml:space="preserve">Hello</text>
+    </emph>
+    <text xml:space="preserve"> world!</text>
+  </paragraph>
+</document>
+```
+
+### Plaintext
+
+Plaintext will be generated when calling `to_plaintext` or using `--to=plaintext` on the command line.
+
+```ruby
+doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
+puts(doc.to_plaintext)
+
+Hello world!
+```
+
+### Commonmark
+
+Commonmark will be generated when calling `to_commonmark` or using `--to=commonmark` on the command line.
+
+``` ruby
+text = <<-TEXT
+1. I am a numeric list.
+2. I continue the list.
+* Suddenly, an unordered list!
+* What fun!
+TEXT
+
+doc = CommonMarker.render_doc(text, :DEFAULT)
+puts(doc.to_commonmark)
+
+1.  I am a numeric list.
+2.  I continue the list.
+
+<!-- end list -->
+
+  - Suddenly, an unordered list\!
+  - What fun\!
+```
+
 ## Developing locally
 
 After cloning the repo:

data/bin/commonmarker

@@ -13,15 +13,18 @@ $LOAD_PATH.unshift File.expand_path('lib', root)
 def parse_options
   options = OpenStruct.new
   extensions = CommonMarker.extensions
-  parse_options = CommonMarker::Config::Parse
-  render_options = CommonMarker::Config::Render
+  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]'
     opts.separator '                    [--parse-option=OPTION]'
     opts.separator '                    [--render-option=OPTION]'
     opts.separator '                    [FILE..]'
@@ -43,6 +46,7 @@ def parse_options
     opts.on('-h', '--help', 'Prints this help') do
       puts opts
       puts
+      puts "Available formats: #{format_options.join(', ')}"
       puts "Available extentions: #{extensions.join(', ')}"
       puts "Available parse options: #{parse_options.keys.join(', ')}"
       puts "Available render options: #{render_options.keys.join(', ')}"
@@ -51,7 +55,16 @@ def parse_options
       exit
     end
 
-    opts.on('--html-renderer', 'Use the HtmlRenderer renderer rather than the native C renderer') do
+    opts.on('-tFORMAT', '--to=FORMAT', String, 'Specify output FORMAT') do |value|
+      value = value.to_sym
+      if format_options.include?(value)
+        options.output_format = value
+      else
+        abort("format '#{value}' not found")
+      end
+    end
+
+    opts.on('--html-renderer', 'Use the HtmlRenderer renderer rather than the native C renderer (only valid when format is html)') do
       options.renderer = true
     end
 
@@ -88,11 +101,23 @@ end
 
 options = parse_options
 
+abort("format '#{options.output_format}' does not support using the HtmlRenderer renderer") if
+  options.renderer && options.output_format != :html
+
 doc = CommonMarker.render_doc(ARGF.read, options.active_parse_options, options.active_extensions)
 
-if options.renderer
-  renderer = CommonMarker::HtmlRenderer.new(extensions: options.active_extensions)
-  STDOUT.write(renderer.render(doc))
-else
-  STDOUT.write(doc.to_html(options.active_render_options, options.active_extensions))
+case options.output_format
+when :html
+  if options.renderer
+    renderer = CommonMarker::HtmlRenderer.new(options: options.active_render_options, extensions: options.active_extensions)
+    $stdout.write(renderer.render(doc))
+  else
+    $stdout.write(doc.to_html(options.active_render_options, options.active_extensions))
+  end
+when :xml
+  $stdout.write(doc.to_xml(options.active_render_options))
+when :commonmark
+  $stdout.write(doc.to_commonmark(options.active_render_options))
+when :plaintext
+  $stdout.write(doc.to_plaintext(options.active_render_options))
 end

data/commonmarker.gemspec

@@ -21,13 +21,12 @@ Gem::Specification.new do |s|
 
   s.executables = ['commonmarker']
   s.require_paths = %w[lib ext]
+  s.required_ruby_version = ['>= 2.6', '< 4.0']
 
   s.rdoc_options += ['-x', 'ext/commonmarker/cmark/.*']
 
-  s.add_dependency 'ruby-enum', '~> 0.5'
-
   s.add_development_dependency 'awesome_print'
-  s.add_development_dependency 'json', '~> 1.8'
+  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'

data/ext/commonmarker/commonmarker.c

@@ -45,6 +45,13 @@ static VALUE encode_utf8_string(const char *c_string) {
   return string;
 }
 
+/* Encode a C string using the encoding from Ruby string +source+. */
+static VALUE encode_source_string(const char *c_string, VALUE source) {
+  VALUE string = rb_str_new2(c_string);
+  rb_enc_copy(string, source);
+  return string;
+}
+
 static void rb_mark_c_struct(void *data) {
   cmark_node *node = data;
   cmark_node *child;
@@ -179,6 +186,40 @@ static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VA
   return ruby_html;
 }
 
+/*
+ * Internal: Parses a Markdown string into an HTML string.
+ *
+ */
+static VALUE rb_markdown_to_xml(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) {
+  char *str, *xml;
+  int len;
+  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());
+
+  str = (char *)RSTRING_PTR(rb_text);
+  len = RSTRING_LEN(rb_text);
+
+  cmark_parser_feed(parser, str, len);
+  doc = cmark_parser_finish(parser);
+  if (doc == NULL) {
+    cmark_arena_reset();
+    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();
+
+  VALUE ruby_xml = rb_str_new2(xml);
+  default_mem->free(xml);
+
+  return ruby_xml;
+}
+
 /*
  * Internal: Creates a node based on a node type.
  *
@@ -567,6 +608,28 @@ static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
   return ruby_html;
 }
 
+/* Internal: Convert the node to an XML string.
+ *
+ * Returns a {String}.
+ */
+static VALUE rb_render_xml(VALUE self, VALUE rb_options) {
+  int options;
+  int i;
+  cmark_node *node;
+  Check_Type(rb_options, T_FIXNUM);
+
+  options = FIX2INT(rb_options);
+
+  Data_Get_Struct(self, cmark_node, node);
+
+  char *xml = cmark_render_xml(node, options);
+  VALUE ruby_xml = rb_str_new2(xml);
+
+  free(xml);
+
+  return ruby_xml;
+}
+
 /* Internal: Convert the node to a CommonMark string.
  *
  * Returns a {String}.
@@ -1130,7 +1193,8 @@ static VALUE rb_html_escape_href(VALUE self, VALUE rb_text) {
   if (houdini_escape_href(&buf, (const uint8_t *)RSTRING_PTR(rb_text),
                           RSTRING_LEN(rb_text))) {
     result = (char *)cmark_strbuf_detach(&buf);
-    return rb_str_new2(result);
+    return encode_source_string(result, rb_text);
+
   }
 
   return rb_text;
@@ -1150,7 +1214,7 @@ static VALUE rb_html_escape_html(VALUE self, VALUE rb_text) {
   if (houdini_escape_html0(&buf, (const uint8_t *)RSTRING_PTR(rb_text),
                            RSTRING_LEN(rb_text), 0)) {
     result = (char *)cmark_strbuf_detach(&buf);
-    return rb_str_new2(result);
+    return encode_source_string(result, rb_text);
   }
 
   return rb_text;
@@ -1208,6 +1272,8 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_cNode = rb_define_class_under(module, "Node", rb_cObject);
   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,
+                             3);
   rb_define_singleton_method(rb_cNode, "new", rb_node_new, 1);
   rb_define_singleton_method(rb_cNode, "parse_document", rb_parse_document, 4);
   rb_define_method(rb_cNode, "string_content", rb_node_get_string_content, 0);
@@ -1220,6 +1286,7 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_define_method(rb_cNode, "next", rb_node_next, 0);
   rb_define_method(rb_cNode, "insert_before", rb_node_insert_before, 1);
   rb_define_method(rb_cNode, "_render_html", rb_render_html, 2);
+  rb_define_method(rb_cNode, "_render_xml", rb_render_xml, 1);
   rb_define_method(rb_cNode, "_render_commonmark", rb_render_commonmark, -1);
   rb_define_method(rb_cNode, "_render_plaintext", rb_render_plaintext, -1);
   rb_define_method(rb_cNode, "insert_after", rb_node_insert_after, 1);

data/lib/commonmarker/config.rb

@@ -1,53 +1,47 @@
 # 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,
+      format: %i[html xml commonmark plaintext].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 do |o|
-          check_option(o, type)
-          type.to_h[o]
-        end.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"
+        raise TypeError, "option type must be a valid symbol or array of symbols within the #{name}::OPTS[:#{type}] context"
       end
-    end
-
-    def self.check_option(option, type)
-      raise TypeError, "option ':#{option}' does not exist for #{type}" unless type.key?(option)
+    rescue KeyError => e
+      raise TypeError, "option ':#{e.key}' does not exist for #{name}::OPTS[:#{type}]"
     end
   end
 end

data/lib/commonmarker/node/inspect.rb

@@ -11,7 +11,7 @@ module CommonMarker
         PP.pp(self, +'', Float::INFINITY)
       end
 
-      # @param [PrettyPrint] pp
+      # @param printer [PrettyPrint] pp
       def pretty_print(printer)
         printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", '>') do
           printer.breakable
@@ -27,11 +27,9 @@ 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
 
           printer.seplist(attrs) do |name, value|

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|
@@ -30,6 +30,16 @@ module CommonMarker
       _render_html(opts, extensions).force_encoding('utf-8')
     end
 
+    # Public: Convert the node to an XML string.
+    #
+    # options - A {Symbol} or {Array of Symbol}s indicating the render options
+    #
+    # Returns a {String}.
+    def to_xml(options = :DEFAULT)
+      opts = Config.process_options(options, :render)
+      _render_xml(opts).force_encoding('utf-8')
+    end
+
     # Public: Convert the node to a CommonMark string.
     #
     # options - A {Symbol} or {Array of Symbol}s indicating the render options

data/lib/commonmarker/renderer/html_renderer.rb

@@ -70,7 +70,7 @@ module CommonMarker
                 'checked="" disabled=""'
               else
                 'disabled=""'
-      end
+              end
       "><input type=\"checkbox\" #{state} /"
     end
 

data/lib/commonmarker/renderer.rb

@@ -6,6 +6,7 @@ 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(+'')
@@ -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)
@@ -127,7 +129,7 @@ module CommonMarker
     end
 
     def option_enabled?(opt)
-      (@opts & CommonMarker::Config::Render.value(opt)) != 0
+      (@opts & CommonMarker::Config::OPTS.dig(:render, opt)) != 0
     end
   end
 end

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CommonMarker
-  VERSION = '0.21.0'
+  VERSION = '0.23.0'
 end

data/test/benchmark.rb

@@ -19,10 +19,6 @@ dobench('redcarpet') do
   Redcarpet::Markdown.new(Redcarpet::Render::HTML, autolink: false, tables: false).render(benchinput)
 end
 
-dobench('github-markdown') do
-  GitHub::Markdown.render(benchinput)
-end
-
 dobench('commonmarker with to_html') do
   CommonMarker.render_html(benchinput)
 end

data/test/test_commands.rb

@@ -5,27 +5,68 @@ require 'test_helper'
 class TestCommands < Minitest::Test
   def test_basic
     out = make_bin('strong.md')
-    assert_equal out, '<p>I am <strong>strong</strong></p>'
+    assert_equal('<p>I am <strong>strong</strong></p>', out)
   end
 
   def test_does_not_have_extensions
     out = make_bin('table.md')
-    assert out.include?('| a')
-    refute out.include?('<p><del>hi</del>')
-    refute out.include?('<table> <tr> <th> a </th> <td> c </td>')
+    assert_includes out, '| a'
+    refute_includes out, '<p><del>hi</del>'
+    refute_includes out, '<table> <tr> <th> a </th> <td> c </td>'
   end
 
   def test_understands_extensions
     out = make_bin('table.md', '--extension=table')
-    refute out.include?('| a')
-    refute out.include?('<p><del>hi</del>')
-    %w[<table> <tr> <th> a </th> <td> c </td>].each { |html| assert out.include?(html) }
+    refute_includes out, '| a'
+    refute_includes out, '<p><del>hi</del>'
+    %w[<table> <tr> <th> a </th> <td> c </td>].each { |html| assert_includes out, html }
   end
 
   def test_understands_multiple_extensions
     out = make_bin('table.md', '--extension=table,strikethrough')
-    refute out.include?('| a')
-    assert out.include?('<p><del>hi</del>')
-    %w[<table> <tr> <th> a </th> <td> c </td>].each { |html| assert out.include?(html) }
+    refute_includes out, '| a'
+    assert_includes out, '<p><del>hi</del>'
+    %w[<table> <tr> <th> a </th> <td> c </td>].each { |html| assert_includes out, html }
+  end
+
+  def test_understands_html_format_with_renderer_and_extensions
+    out = make_bin('table.md', '--to=html --extension=table,strikethrough --html-renderer')
+    refute_includes out, '| a'
+    assert_includes out, '<p><del>hi</del>'
+    %w[<table> <tr> <th> a </th> <td> c </td>].each { |html| assert_includes out, html }
+  end
+
+  def test_understands_xml_format
+    out = make_bin('strong.md', '--to=xml')
+    assert_includes out, '<?xml version="1.0" encoding="UTF-8"?>'
+    assert_includes out, '<text xml:space="preserve">strong</text>'
+  end
+
+  def test_understands_commonmark_format
+    out = make_bin('strong.md', '--to=commonmark')
+    assert_equal('I am **strong**', out)
+  end
+
+  def test_understands_plaintext_format
+    out = make_bin('strong.md', '--to=plaintext')
+    assert_equal('I am strong', out)
+  end
+
+  def test_aborts_invalid_format
+    _out, err = capture_subprocess_io do
+      make_bin('strong.md', '--to=unknown')
+    end
+
+    assert_match "format 'unknown' not found", err
+  end
+
+  def test_aborts_format_and_html_renderer_combinations
+    (CommonMarker::Config::OPTS[:format] - [:html]).each do |format|
+      _out, err = capture_subprocess_io do
+        make_bin('strong.md', "--to=#{format} --html-renderer")
+      end
+
+      assert_match "format '#{format}' does not support using the HtmlRenderer renderer", err
+    end
   end
 end

data/test/test_commonmark.rb

@@ -30,7 +30,7 @@ class TestCommonmark < Minitest::Test
     compare = render_doc(@markdown).to_commonmark
 
     assert_equal \
-      render_doc(@markdown).to_html.gsub(/ +/, ' ').gsub(HTML_COMMENT, ''),
-      render_doc(compare).to_html.gsub(/ +/, ' ').gsub(HTML_COMMENT, '')
+      render_doc(@markdown).to_html.squeeze(' ').gsub(HTML_COMMENT, ''),
+      render_doc(compare).to_html.squeeze(' ').gsub(HTML_COMMENT, '')
   end
 end

data/test/test_doc.rb

@@ -17,114 +17,114 @@ class TestDocNode < Minitest::Test
   end
 
   def test_get_type
-    assert_equal @doc.type, :document
+    assert_equal(:document, @doc.type)
   end
 
   def test_get_type_string
-    assert_equal @doc.type_string, 'document'
+    assert_equal('document', @doc.type_string)
   end
 
   def test_get_first_child
-    assert_equal @first_child.type, :paragraph
+    assert_equal(:paragraph, @first_child.type)
   end
 
   def test_get_next
-    assert_equal @first_child.first_child.next.type, :emph
+    assert_equal(:emph, @first_child.first_child.next.type)
   end
 
   def test_insert_before
     paragraph = Node.new(:paragraph)
-    assert_equal @first_child.insert_before(paragraph), true
+    assert(@first_child.insert_before(paragraph))
     assert_match "<p></p>\n<p>Hi <em>there</em>.", @doc.to_html
   end
 
   def test_insert_after
     paragraph = Node.new(:paragraph)
-    assert_equal @first_child.insert_after(paragraph), true
+    assert(@first_child.insert_after(paragraph))
     assert_match "<strong>many nodes</strong>!</p>\n<p></p>\n", @doc.to_html
   end
 
   def test_prepend_child
     code = Node.new(:code)
-    assert_equal @first_child.prepend_child(code), true
+    assert(@first_child.prepend_child(code))
     assert_match '<p><code></code>Hi <em>there</em>.', @doc.to_html
   end
 
   def test_append_child
     strong = Node.new(:strong)
-    assert_equal @first_child.append_child(strong), true
+    assert(@first_child.append_child(strong))
     assert_match "!<strong></strong></p>\n", @doc.to_html
   end
 
   def test_get_last_child
-    assert_equal @last_child.type, :paragraph
+    assert_equal(:paragraph, @last_child.type)
   end
 
   def test_get_parent
-    assert_equal @first_child.first_child.next.parent.type, :paragraph
+    assert_equal(:paragraph, @first_child.first_child.next.parent.type)
   end
 
   def test_get_previous
-    assert_equal @first_child.first_child.next.previous.type, :text
+    assert_equal(:text, @first_child.first_child.next.previous.type)
   end
 
   def test_get_url
-    assert_equal @link.url, 'https://www.github.com'
+    assert_equal('https://www.github.com', @link.url)
   end
 
   def test_set_url
-    assert_equal @link.url = 'https://www.mozilla.org', 'https://www.mozilla.org'
+    assert_equal('https://www.mozilla.org', @link.url = 'https://www.mozilla.org')
   end
 
   def test_get_title
-    assert_equal @image.title, 'Favicon'
+    assert_equal('Favicon', @image.title)
   end
 
   def test_set_title
-    assert_equal @image.title = 'Octocat', 'Octocat'
+    assert_equal('Octocat', @image.title = 'Octocat')
   end
 
   def test_get_header_level
-    assert_equal @header.header_level, 3
+    assert_equal(3, @header.header_level)
   end
 
   def test_set_header_level
-    assert_equal @header.header_level = 6, 6
+    assert_equal(6, @header.header_level = 6)
   end
 
   def test_get_list_type
-    assert_equal @ul_list.list_type, :bullet_list
-    assert_equal @ol_list.list_type, :ordered_list
+    assert_equal(:bullet_list, @ul_list.list_type)
+    assert_equal(:ordered_list, @ol_list.list_type)
   end
 
   def test_set_list_type
-    assert_equal @ul_list.list_type = :ordered_list, :ordered_list
-    assert_equal @ol_list.list_type = :bullet_list, :bullet_list
+    assert_equal(:ordered_list, @ul_list.list_type = :ordered_list)
+    assert_equal(:bullet_list, @ol_list.list_type = :bullet_list)
   end
 
   def test_get_list_start
-    assert_equal @ol_list.list_start, 1
+    assert_equal(1, @ol_list.list_start)
   end
 
   def test_set_list_start
-    assert_equal @ol_list.list_start = 8, 8
+    assert_equal(8, @ol_list.list_start = 8)
   end
 
   def test_get_list_tight
-    assert_equal @ul_list.list_tight, true
-    assert_equal @ol_list.list_tight, true
+    assert(@ul_list.list_tight)
+    assert(@ol_list.list_tight)
   end
 
   def test_set_list_tight
-    assert_equal @ul_list.list_tight = false, false
-    assert_equal @ol_list.list_tight = false, false
+    refute(@ul_list.list_tight = false)
+    refute(@ol_list.list_tight = false)
   end
 
   def test_get_fence_info
-    assert_equal @fence.fence_info, 'ruby'
+    assert_equal('ruby', @fence.fence_info)
   end
 
   def test_set_fence_info
-    assert_equal @fence.fence_info = 'javascript', 'javascript'
+    assert_equal('javascript', @fence.fence_info = 'javascript')
   end
 end

data/test/test_encoding.rb

@@ -8,13 +8,16 @@ class TestEncoding < Minitest::Test
     contents = fixtures_file('curly.md')
     doc = CommonMarker.render_doc(contents, :SMART)
     render = doc.to_html
-    assert_equal render.rstrip, '<p>This curly quote “makes commonmarker throw an exception”.</p>'
+    assert_equal('<p>This curly quote “makes commonmarker throw an exception”.</p>', render.rstrip)
+
+    render = doc.to_xml
+    assert_includes(render, '<text xml:space="preserve">This curly quote “makes commonmarker throw an exception”.</text>')
   end
 
   def test_string_content_is_utf8
     doc = CommonMarker.render_doc('Hi *there*')
     text = doc.first_child.last_child.first_child
-    assert_equal text.string_content, 'there'
-    assert_equal text.string_content.encoding.name, 'UTF-8'
+    assert_equal('there', text.string_content)
+    assert_equal('UTF-8', text.string_content.encoding.name)
   end
 end

data/test/test_extensions.rb

@@ -9,30 +9,30 @@ class TestExtensions < Minitest::Test
 
   def test_uses_specified_extensions
     CommonMarker.render_html(@markdown, :DEFAULT, %i[]).tap do |out|
-      assert out.include?('| a')
-      assert out.include?('| <strong>x</strong>')
-      assert out.include?('~~hi~~')
+      assert_includes out, '| a'
+      assert_includes out, '| <strong>x</strong>'
+      assert_includes out, '~~hi~~'
     end
 
     CommonMarker.render_html(@markdown, :DEFAULT, %i[table]).tap do |out|
-      refute out.include?('| a')
-      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert out.include?(html) }
-      assert out.include?('~~hi~~')
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
     end
 
     CommonMarker.render_html(@markdown, :DEFAULT, %i[strikethrough]).tap do |out|
-      assert out.include?('| a')
-      refute out.include?('~~hi~~')
-      assert out.include?('<del>hi</del>')
+      assert_includes out, '| a'
+      refute_includes out, '~~hi~~'
+      assert_includes out, '<del>hi</del>'
     end
 
     doc = CommonMarker.render_doc('~a~ ~~b~~ ~~~c~~~', :STRIKETHROUGH_DOUBLE_TILDE, [:strikethrough])
-    assert_equal doc.to_html, "<p>~a~ <del>b</del> ~~~c~~~</p>\n"
+    assert_equal("<p>~a~ <del>b</del> ~~~c~~~</p>\n", doc.to_html)
 
     CommonMarker.render_html(@markdown, :DEFAULT, %i[table strikethrough]).tap do |out|
-      refute out.include?('| a')
-      refute out.include?('| <strong>x</strong>')
-      refute out.include?('~~hi~~')
+      refute_includes out, '| a'
+      refute_includes out, '| <strong>x</strong>'
+      refute_includes out, '~~hi~~'
     end
   end
 
@@ -40,19 +40,19 @@ class TestExtensions < Minitest::Test
     doc = CommonMarker.render_doc(@markdown, :DEFAULT, %i[table])
 
     doc.to_html.tap do |out|
-      refute out.include?('| a')
-      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert out.include?(html) }
-      assert out.include?('~~hi~~')
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
     end
 
     HtmlRenderer.new.render(doc).tap do |out|
-      refute out.include?('| a')
-      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert out.include?(html) }
-      assert out.include?('~~hi~~')
+      refute_includes out, '| a'
+      %w[<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>].each { |html| assert_includes out, html }
+      assert_includes out, '~~hi~~'
     end
 
     doc = CommonMarker.render_doc('~a~ ~~b~~ ~~~c~~~', :STRIKETHROUGH_DOUBLE_TILDE, [:strikethrough])
-    assert_equal HtmlRenderer.new.render(doc), "<p>~a~ <del>b</del> ~~~c~~~</p>\n"
+    assert_equal("<p>~a~ <del>b</del> ~~~c~~~</p>\n", HtmlRenderer.new.render(doc))
   end
 
   def test_bad_extension_specifications

data/test/test_footnotes.rb

@@ -24,4 +24,25 @@ class TestFootnotes < Minitest::Test
   def test_html_renderer
     assert_equal @expected, CommonMarker::HtmlRenderer.new.render(@doc)
   end
+
+  def test_render_html
+    md = <<~MARKDOWN
+      # footnotes
+      Let's render some footnotes[^1]
+
+      [^1]: This is a footnote
+    MARKDOWN
+    expected = <<~HTML
+      <h1>footnotes</h1>
+      <p>Let's render some footnotes<sup class="footnote-ref"><a href="#fn1" id="fnref1">1</a></sup></p>
+      <section class="footnotes">
+      <ol>
+      <li id="fn1">
+      <p>This is a footnote <a href="#fnref1" class="footnote-backref">↩</a></p>
+      </li>
+      </ol>
+      </section>
+    HTML
+    assert_equal expected, CommonMarker.render_html(md, :FOOTNOTES)
+  end
 end

data/test/test_helper.rb

@@ -44,8 +44,8 @@ def open_spec_file(filename)
       example_number += 1
       end_line = line_number
       tests << {
-        markdown: markdown_lines.join('').tr('→', "\t"),
-        html: html_lines.join('').tr('→', "\t").rstrip,
+        markdown: markdown_lines.join.tr('→', "\t"),
+        html: html_lines.join.tr('→', "\t").rstrip,
         example: example_number,
         start_line: start_line,
         end_line: end_line,

data/test/test_maliciousness.rb

@@ -70,7 +70,7 @@ module CommonMarker
       err = assert_raises TypeError do
         CommonMarker.render_html("foo \n baz", [:SMART])
       end
-      assert_equal err.message, 'option \':SMART\' does not exist for CommonMarker::Config::Render'
+      assert_equal('option \':SMART\' does not exist for CommonMarker::Config::OPTS[:render]', err.message)
 
       assert_raises TypeError do
         CommonMarker.render_doc("foo \n baz", 123)
@@ -79,7 +79,7 @@ module CommonMarker
       err = assert_raises TypeError do
         CommonMarker.render_doc("foo \n baz", :safe)
       end
-      assert_equal err.message, 'option \':safe\' does not exist for CommonMarker::Config::Parse'
+      assert_equal('option \':safe\' does not exist for CommonMarker::Config::OPTS[:parse]', err.message)
 
       assert_raises TypeError do
         CommonMarker.render_doc("foo \n baz", :totes_fake)

data/test/test_pathological_inputs.rb

@@ -10,7 +10,7 @@ end
 # list of pairs consisting of input and a regex that must match the output.
 pathological = {
   'nested strong emph' =>
-              [('*a **a ' * 65_000) + 'b' + (' a** a*' * 65_000),
+              ["#{'*a **a ' * 65_000}b#{' a** a*' * 65_000}",
                Regexp.compile('(<em>a <strong>a ){65_000}b( a</strong> a</em>){65_000}')],
   'many emph closers with no openers' =>
                [('a_ ' * 65_000),
@@ -34,10 +34,10 @@ pathological = {
                ['**x [a*b**c*](d)',
                 Regexp.compile('\\*\\*x <a href=\'d\'>a<em>b</em><em>c</em></a>')],
   'nested brackets' =>
-               [('[' * 50_000) + 'a' + (']' * 50_000),
+               ["#{'[' * 50_000}a#{']' * 50_000}",
                 Regexp.compile('\[{50000}a\]{50000}')],
   'nested block quotes' =>
-               [(('> ' * 50_000) + 'a'),
+               ["#{'> ' * 50_000}a",
                 Regexp.compile('(<blockquote>\n){50000}')],
   'U+0000 in input' =>
                ['abc\u0000de\u0000',
@@ -53,41 +53,41 @@ end
 
 if ENV['BENCH']
   class PathologicalInputsPerformanceTest < Minitest::Benchmark
-    def bench_pathological_1
+    def test_bench_pathological_one
       assert_performance_linear 0.99 do |n|
         star = '*' * (n * 10)
         markdown("#{star}#{star}hi#{star}#{star}")
       end
     end
 
-    def bench_pathological_2
+    def test_bench_pathological_two
       assert_performance_linear 0.99 do |n|
         c = '`t`t`t`t`t`t' * (n * 10)
         markdown(c)
       end
     end
 
-    def bench_pathological_3
+    def test_bench_pathological_three
       assert_performance_linear 0.99 do |n|
         markdown(" [a]: #{'A' * n}\n\n#{'[a][]' * n}\n")
       end
     end
 
-    def bench_pathological_4
+    def test_bench_pathological_four
       assert_performance_linear 0.5 do |n|
         markdown("#{'[' * n}a#{']' * n}")
       end
     end
 
-    def bench_pathological_5
+    def test_bench_pathological_five
       assert_performance_linear 0.99 do |n|
         markdown("#{'**a *a ' * n}#{'a* a**' * n}")
       end
     end
 
-    def bench_unbound_recursion
+    def test_bench_unbound_recursion
       assert_performance_linear 0.99 do |n|
-        markdown(('[' * n) + 'foo' + ('](bar)' * n))
+        markdown("#{'[' * n}foo#{'](bar)' * n}")
       end
     end
   end

data/test/test_renderer.rb

@@ -27,4 +27,21 @@ class TestRenderer < Minitest::Test
     results = CommonMarker::HtmlRenderer.new.render(doc)
     assert_equal 2, results.scan(/<tbody>/).size
   end
+
+  def test_escape_html_encoding
+    my_renderer = Class.new(HtmlRenderer) do
+      attr_reader :input_encoding, :output_encoding
+
+      def text(node)
+        @input_encoding = node.string_content.encoding
+        escape_html(node.string_content).tap do |escaped|
+          @output_encoding = escaped.encoding
+        end
+      end
+    end
+
+    renderer = my_renderer.new
+    assert_equal Encoding::UTF_8, renderer.render(@doc).encoding
+    assert_equal renderer.input_encoding, renderer.output_encoding
+  end
 end

data/test/test_xml.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestXml < Minitest::Test
+  def setup
+    @markdown = <<~MD
+      Hi *there*!
+
+      1. I am a numeric list.
+      2. I continue the list.
+      * Suddenly, an unordered list!
+      * What fun!
+
+      Okay, _enough_.
+
+      | a   | b   |
+      | --- | --- |
+      | c   | d   |
+    MD
+  end
+
+  def render_doc(doc)
+    CommonMarker.render_doc(doc, :DEFAULT, [:table])
+  end
+
+  def test_to_xml
+    compare = render_doc(@markdown).to_xml(:SOURCEPOS)
+
+    assert_equal <<~XML, compare
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE document SYSTEM "CommonMark.dtd">
+      <document sourcepos="1:1-12:13" xmlns="http://commonmark.org/xml/1.0">
+        <paragraph sourcepos="1:1-1:11">
+          <text sourcepos="1:1-1:3" xml:space="preserve">Hi </text>
+          <emph sourcepos="1:4-1:10">
+            <text sourcepos="1:5-1:9" xml:space="preserve">there</text>
+          </emph>
+          <text sourcepos="1:11-1:11" xml:space="preserve">!</text>
+        </paragraph>
+        <list sourcepos="3:1-4:23" type="ordered" start="1" delim="period" tight="true">
+          <item sourcepos="3:1-3:23">
+            <paragraph sourcepos="3:4-3:23">
+              <text sourcepos="3:4-3:23" xml:space="preserve">I am a numeric list.</text>
+            </paragraph>
+          </item>
+          <item sourcepos="4:1-4:23">
+            <paragraph sourcepos="4:4-4:23">
+              <text sourcepos="4:4-4:23" xml:space="preserve">I continue the list.</text>
+            </paragraph>
+          </item>
+        </list>
+        <list sourcepos="5:1-7:0" type="bullet" tight="true">
+          <item sourcepos="5:1-5:30">
+            <paragraph sourcepos="5:3-5:30">
+              <text sourcepos="5:3-5:30" xml:space="preserve">Suddenly, an unordered list!</text>
+            </paragraph>
+          </item>
+          <item sourcepos="6:1-7:0">
+            <paragraph sourcepos="6:3-6:11">
+              <text sourcepos="6:3-6:11" xml:space="preserve">What fun!</text>
+            </paragraph>
+          </item>
+        </list>
+        <paragraph sourcepos="8:1-8:15">
+          <text sourcepos="8:1-8:6" xml:space="preserve">Okay, </text>
+          <emph sourcepos="8:7-8:14">
+            <text sourcepos="8:8-8:13" xml:space="preserve">enough</text>
+          </emph>
+          <text sourcepos="8:15-8:15" xml:space="preserve">.</text>
+        </paragraph>
+        <table sourcepos="10:1-12:13">
+          <table_header sourcepos="10:1-10:13">
+            <table_cell sourcepos="10:2-10:6">
+              <text sourcepos="10:3-10:3" xml:space="preserve">a</text>
+            </table_cell>
+            <table_cell sourcepos="10:8-10:12">
+              <text sourcepos="10:9-10:9" xml:space="preserve">b</text>
+            </table_cell>
+          </table_header>
+          <table_row sourcepos="12:1-12:13">
+            <table_cell sourcepos="12:2-12:6">
+              <text sourcepos="12:3-12:3" xml:space="preserve">c</text>
+            </table_cell>
+            <table_cell sourcepos="12:8-12:12">
+              <text sourcepos="12:9-12:9" xml:space="preserve">d</text>
+            </table_cell>
+          </table_row>
+        </table>
+      </document>
+    XML
+  end
+
+  def test_to_xml_with_quotes
+    compare = render_doc('"quotes" should be escaped').to_xml(:DEFAULT)
+
+    assert_equal <<~XML, compare
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE document SYSTEM "CommonMark.dtd">
+      <document xmlns="http://commonmark.org/xml/1.0">
+        <paragraph>
+          <text xml:space="preserve">&quot;quotes&quot; should be escaped</text>
+        </paragraph>
+      </document>
+    XML
+  end
+end

metadata

@@ -1,30 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: commonmarker
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Garen Torikian
 - Ashe Connor
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-23 00:00:00.000000000 Z
+date: 2021-08-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: ruby-enum
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -45,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -153,7 +139,7 @@ dependencies:
         version: '0'
 description: A fast, safe, extensible parser for CommonMark. This wraps the official
   libcmark library.
-email: 
+email:
 executables:
 - commonmarker
 extensions:
@@ -268,11 +254,12 @@ files:
 - test/test_smartpunct.rb
 - test/test_spec.rb
 - test/test_tasklists.rb
+- test/test_xml.rb
 homepage: https://github.com/gjtorikian/commonmarker
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "-x"
 - ext/commonmarker/cmark/.*
@@ -283,15 +270,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: CommonMark parser and renderer. Written in C, wrapped in Ruby.
 test_files:
@@ -317,6 +307,7 @@ test_files:
 - test/test_helper.rb
 - test/test_options.rb
 - test/benchmark.rb
+- test/test_xml.rb
 - test/test_basics.rb
 - test/test_renderer.rb
 - test/test_gc.rb