commonmarker 0.17.7.1 → 0.18.0

data/ext/commonmarker/scanners.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_SCANNERS_H
 #define CMARK_SCANNERS_H
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "chunk.h"
 
 #ifdef __cplusplus

data/ext/commonmarker/strikethrough.c

@@ -27,7 +27,8 @@ static cmark_node *match(cmark_syntax_extension *self, cmark_parser *parser,
   res->start_line = res->end_line = cmark_inline_parser_get_line(inline_parser);
   res->start_column = cmark_inline_parser_get_column(inline_parser) - delims;
 
-  if (left_flanking || right_flanking) {
+  if ((left_flanking || right_flanking) &&
+      (delims == 2 || (!(parser->options & CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE) && delims == 1))) {
     cmark_inline_parser_push_delimiter(inline_parser, character, left_flanking,
                                        right_flanking, res);
   }
@@ -45,12 +46,14 @@ static delimiter *insert(cmark_syntax_extension *self, cmark_parser *parser,
 
   strikethrough = opener->inl_text;
 
+  if (opener->inl_text->as.literal.len != closer->inl_text->as.literal.len)
+    goto done;
+
   if (!cmark_node_set_type(strikethrough, CMARK_NODE_STRIKETHROUGH))
     goto done;
 
   cmark_node_set_syntax_extension(strikethrough, self);
 
-  cmark_node_set_string_content(strikethrough, "~");
   tmp = cmark_node_next(opener->inl_text);
 
   while (tmp) {
@@ -93,7 +96,7 @@ static int can_contain(cmark_syntax_extension *extension, cmark_node *node,
 static void commonmark_render(cmark_syntax_extension *extension,
                               cmark_renderer *renderer, cmark_node *node,
                               cmark_event_type ev_type, int options) {
-  renderer->out(renderer, node, cmark_node_get_string_content(node), false, LITERAL);
+  renderer->out(renderer, node, "~~", false, LITERAL);
 }
 
 static void latex_render(cmark_syntax_extension *extension,
@@ -132,6 +135,12 @@ static void html_render(cmark_syntax_extension *extension,
   }
 }
 
+static void plaintext_render(cmark_syntax_extension *extension,
+                             cmark_renderer *renderer, cmark_node *node,
+                             cmark_event_type ev_type, int options) {
+  renderer->out(renderer, node, "~", false, LITERAL);
+}
+
 cmark_syntax_extension *create_strikethrough_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("strikethrough");
   cmark_llist *special_chars = NULL;
@@ -142,6 +151,7 @@ cmark_syntax_extension *create_strikethrough_extension(void) {
   cmark_syntax_extension_set_latex_render_func(ext, latex_render);
   cmark_syntax_extension_set_man_render_func(ext, man_render);
   cmark_syntax_extension_set_html_render_func(ext, html_render);
+  cmark_syntax_extension_set_plaintext_render_func(ext, plaintext_render);
   CMARK_NODE_STRIKETHROUGH = cmark_syntax_extension_add_node(1);
 
   cmark_syntax_extension_set_match_inline_func(ext, match);

data/ext/commonmarker/strikethrough.h

@@ -1,7 +1,7 @@
-#ifndef STRIKETHROUGH_H
-#define STRIKETHROUGH_H
+#ifndef CMARK_GFM_STRIKETHROUGH_H
+#define CMARK_GFM_STRIKETHROUGH_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 extern cmark_node_type CMARK_NODE_STRIKETHROUGH;
 cmark_syntax_extension *create_strikethrough_extension(void);

data/ext/commonmarker/syntax_extension.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include <assert.h>
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "syntax_extension.h"
 #include "buffer.h"
 
@@ -97,6 +97,11 @@ void cmark_syntax_extension_set_latex_render_func(cmark_syntax_extension *extens
   extension->latex_render_func = func;
 }
 
+void cmark_syntax_extension_set_xml_attr_func(cmark_syntax_extension *extension,
+                                              cmark_xml_attr_func func) {
+  extension->xml_attr_func = func;
+}
+
 void cmark_syntax_extension_set_man_render_func(cmark_syntax_extension *extension,
                                                 cmark_common_render_func func) {
   extension->man_render_func = func;
@@ -128,6 +133,11 @@ void *cmark_syntax_extension_get_private(cmark_syntax_extension *extension) {
     return extension->priv;
 }
 
+void cmark_syntax_extension_set_opaque_alloc_func(cmark_syntax_extension *extension,
+                                                  cmark_opaque_alloc_func func) {
+  extension->opaque_alloc_func = func;
+}
+
 void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
                                                  cmark_opaque_free_func func) {
   extension->opaque_free_func = func;

data/ext/commonmarker/syntax_extension.h

@@ -1,8 +1,8 @@
 #ifndef CMARK_SYNTAX_EXTENSION_H
 #define CMARK_SYNTAX_EXTENSION_H
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 #include "config.h"
 
 struct cmark_syntax_extension {
@@ -21,10 +21,12 @@ struct cmark_syntax_extension {
   cmark_common_render_func        commonmark_render_func;
   cmark_common_render_func        plaintext_render_func;
   cmark_common_render_func        latex_render_func;
+  cmark_xml_attr_func             xml_attr_func;
   cmark_common_render_func        man_render_func;
   cmark_html_render_func          html_render_func;
   cmark_html_filter_func          html_filter_func;
   cmark_postprocess_func          postprocess_func;
+  cmark_opaque_alloc_func         opaque_alloc_func;
   cmark_opaque_free_func          opaque_free_func;
   cmark_commonmark_escape_func    commonmark_escape_func;
 };

data/ext/commonmarker/table.c

@@ -1,4 +1,4 @@
-#include <cmark_extension_api.h>
+#include <cmark-gfm-extension_api.h>
 #include <html.h>
 #include <inlines.h>
 #include <parser.h>
@@ -9,6 +9,7 @@
 #include "ext_scanners.h"
 #include "strikethrough.h"
 #include "table.h"
+#include "cmark-gfm-core-extensions.h"
 
 cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
     CMARK_NODE_TABLE_CELL;
@@ -380,7 +381,8 @@ static int can_contain(cmark_syntax_extension *extension, cmark_node *node,
            child_type == CMARK_NODE_EMPH || child_type == CMARK_NODE_STRONG ||
            child_type == CMARK_NODE_LINK || child_type == CMARK_NODE_IMAGE ||
            child_type == CMARK_NODE_STRIKETHROUGH ||
-           child_type == CMARK_NODE_HTML_INLINE;
+           child_type == CMARK_NODE_HTML_INLINE ||
+           child_type == CMARK_NODE_FOOTNOTE_REFERENCE;
   }
   return false;
 }
@@ -487,6 +489,27 @@ static void latex_render(cmark_syntax_extension *extension,
   }
 }
 
+static const char *xml_attr(cmark_syntax_extension *extension,
+                            cmark_node *node) {
+  if (node->type == CMARK_NODE_TABLE_CELL) {
+    if (cmark_gfm_extensions_get_table_row_is_header(node->parent)) {
+      uint8_t *alignments = get_table_alignments(node->parent->parent);
+      int i = 0;
+      cmark_node *n;
+      for (n = node->parent->first_child; n; n = n->next, ++i)
+        if (n == node)
+          break;
+      switch (alignments[i]) {
+      case 'l': return " align=\"left\"";
+      case 'c': return " align=\"center\"";
+      case 'r': return " align=\"right\"";
+      }
+    }
+  }
+
+  return NULL;
+}
+
 static void man_render(cmark_syntax_extension *extension,
                        cmark_renderer *renderer, cmark_node *node,
                        cmark_event_type ev_type, int options) {
@@ -542,6 +565,18 @@ static void man_render(cmark_syntax_extension *extension,
   }
 }
 
+static void html_table_add_align(cmark_strbuf* html, const char* align, int options) {
+  if (options & CMARK_OPT_TABLE_PREFER_STYLE_ATTRIBUTES) {
+    cmark_strbuf_puts(html, " style=\"text-align: ");
+    cmark_strbuf_puts(html, align);
+    cmark_strbuf_puts(html, "\"");
+  } else {
+    cmark_strbuf_puts(html, " align=\"");
+    cmark_strbuf_puts(html, align);
+    cmark_strbuf_puts(html, "\"");
+  }
+}
+
 struct html_table_state {
   unsigned need_closing_table_body : 1;
   unsigned in_table_header : 1;
@@ -566,10 +601,15 @@ static void html_render(cmark_syntax_extension *extension,
       cmark_strbuf_putc(html, '>');
       table_state->need_closing_table_body = false;
     } else {
-      if (table_state->need_closing_table_body)
+      if (table_state->need_closing_table_body) {
+        cmark_html_render_cr(html);
         cmark_strbuf_puts(html, "</tbody>");
+        cmark_html_render_cr(html);
+      }
       table_state->need_closing_table_body = false;
-      cmark_strbuf_puts(html, "</table>\n");
+      cmark_html_render_cr(html);
+      cmark_strbuf_puts(html, "</table>");
+      cmark_html_render_cr(html);
     }
   } else if (node->type == CMARK_NODE_TABLE_ROW) {
     if (entering) {
@@ -611,9 +651,9 @@ static void html_render(cmark_syntax_extension *extension,
           break;
 
       switch (alignments[i]) {
-      case 'l': cmark_strbuf_puts(html, " align=\"left\""); break;
-      case 'c': cmark_strbuf_puts(html, " align=\"center\""); break;
-      case 'r': cmark_strbuf_puts(html, " align=\"right\""); break;
+      case 'l': html_table_add_align(html, "left", options); break;
+      case 'c': html_table_add_align(html, "center", options); break;
+      case 'r': html_table_add_align(html, "right", options); break;
       }
 
       cmark_html_render_sourcepos(node, html, options);
@@ -630,6 +670,16 @@ static void html_render(cmark_syntax_extension *extension,
   }
 }
 
+static void opaque_alloc(cmark_syntax_extension *self, cmark_mem *mem, cmark_node *node) {
+  if (node->type == CMARK_NODE_TABLE) {
+    node->as.opaque = mem->calloc(1, sizeof(node_table));
+  } else if (node->type == CMARK_NODE_TABLE_ROW) {
+    node->as.opaque = mem->calloc(1, sizeof(node_table_row));
+  } else if (node->type == CMARK_NODE_TABLE_CELL) {
+    node->as.opaque = mem->calloc(1, sizeof(node_cell));
+  }
+}
+
 static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem, cmark_node *node) {
   if (node->type == CMARK_NODE_TABLE) {
     free_node_table(mem, node->as.opaque);
@@ -657,8 +707,10 @@ cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension_set_commonmark_render_func(self, commonmark_render);
   cmark_syntax_extension_set_plaintext_render_func(self, commonmark_render);
   cmark_syntax_extension_set_latex_render_func(self, latex_render);
+  cmark_syntax_extension_set_xml_attr_func(self, xml_attr);
   cmark_syntax_extension_set_man_render_func(self, man_render);
   cmark_syntax_extension_set_html_render_func(self, html_render);
+  cmark_syntax_extension_set_opaque_alloc_func(self, opaque_alloc);
   cmark_syntax_extension_set_opaque_free_func(self, opaque_free);
   cmark_syntax_extension_set_commonmark_escape_func(self, escape);
   CMARK_NODE_TABLE = cmark_syntax_extension_add_node(0);
@@ -668,16 +720,43 @@ cmark_syntax_extension *create_table_extension(void) {
   return self;
 }
 
-uint16_t cmarkextensions_get_table_columns(cmark_node *node) {
+uint16_t cmark_gfm_extensions_get_table_columns(cmark_node *node) {
   if (node->type != CMARK_NODE_TABLE)
     return 0;
 
   return ((node_table *)node->as.opaque)->n_columns;
 }
 
-uint8_t *cmarkextensions_get_table_alignments(cmark_node *node) {
+uint8_t *cmark_gfm_extensions_get_table_alignments(cmark_node *node) {
   if (node->type != CMARK_NODE_TABLE)
     return 0;
 
   return ((node_table *)node->as.opaque)->alignments;
 }
+
+int cmark_gfm_extensions_set_table_columns(cmark_node *node, uint16_t n_columns) {
+  return set_n_table_columns(node, n_columns);
+}
+
+int cmark_gfm_extensions_set_table_alignments(cmark_node *node, uint16_t ncols, uint8_t *alignments) {
+  uint8_t *a = (uint8_t *)cmark_node_mem(node)->calloc(1, ncols);
+  memcpy(a, alignments, ncols);
+  return set_table_alignments(node, a);
+}
+
+int cmark_gfm_extensions_get_table_row_is_header(cmark_node *node)
+{
+  if (!node || node->type != CMARK_NODE_TABLE_ROW)
+    return 0;
+
+  return ((node_table_row *)node->as.opaque)->is_header;
+}
+
+int cmark_gfm_extensions_set_table_row_is_header(cmark_node *node, int is_header)
+{
+  if (!node || node->type != CMARK_NODE_TABLE_ROW)
+    return 0;
+
+  ((node_table_row *)node->as.opaque)->is_header = (is_header != 0);
+  return 1;
+}

data/ext/commonmarker/table.h

@@ -1,7 +1,11 @@
-#ifndef TABLE_H
-#define TABLE_H
+#ifndef CMARK_GFM_TABLE_H
+#define CMARK_GFM_TABLE_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
+
+
+extern cmark_node_type CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW,
+    CMARK_NODE_TABLE_CELL;
 
 cmark_syntax_extension *create_table_extension(void);
 

data/ext/commonmarker/tagfilter.h

@@ -1,7 +1,7 @@
-#ifndef TAGFILTER_H
-#define TAGFILTER_H
+#ifndef CMARK_GFM_TAGFILTER_H
+#define CMARK_GFM_TAGFILTER_H
 
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 cmark_syntax_extension *create_tagfilter_extension(void);
 

data/ext/commonmarker/utf8.h

@@ -8,24 +8,24 @@
 extern "C" {
 #endif
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
                               bufsize_t len);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line,
                           bufsize_t size);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_is_space(int32_t uc);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_utf8proc_is_punctuation(int32_t uc);
 
 #ifdef __cplusplus

data/ext/commonmarker/xml.c

@@ -4,10 +4,11 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "houdini.h"
+#include "syntax_extension.h"
 
 #define BUFFER_SIZE 100
 
@@ -50,6 +51,12 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
       cmark_strbuf_puts(xml, buffer);
     }
 
+    if (node->extension && node->extension->xml_attr_func) {
+      const char* r = node->extension->xml_attr_func(node->extension, node);
+      if (r != NULL)
+        cmark_strbuf_puts(xml, r);
+    }
+
     literal = false;
 
     switch (node->type) {
@@ -60,7 +67,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_BLOCK:
     case CMARK_NODE_HTML_INLINE:
-      cmark_strbuf_puts(xml, ">");
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
       escape_xml(xml, node->as.literal.data, node->as.literal.len);
       cmark_strbuf_puts(xml, "</");
       cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
@@ -100,7 +107,7 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
         escape_xml(xml, node->as.code.info.data, node->as.code.info.len);
         cmark_strbuf_putc(xml, '"');
       }
-      cmark_strbuf_puts(xml, ">");
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
       escape_xml(xml, node->as.code.literal.data, node->as.code.literal.len);
       cmark_strbuf_puts(xml, "</");
       cmark_strbuf_puts(xml, cmark_node_get_type_string(node));

data/lib/commonmarker/config.rb

@@ -10,6 +10,7 @@ module CommonMarker
       define :SMART, (1 << 10)
       define :LIBERAL_HTML_TAG, (1 << 12)
       define :FOOTNOTES, (1 << 13)
+      define :STRIKETHROUGH_DOUBLE_TILDE, (1 << 14)
     end
 
     class Render
@@ -18,9 +19,11 @@ module CommonMarker
       define :DEFAULT, 0
       define :SOURCEPOS, (1 << 1)
       define :HARDBREAKS, (1 << 2)
-      define :SAFE, (1 << 3)
+      define :UNSAFE, (1 << 17)
       define :NOBREAKS, (1 << 4)
       define :GITHUB_PRE_LANG, (1 << 11)
+      define :TABLE_PREFER_STYLE_ATTRIBUTES, (1 << 15)
+      define :FULL_INFO_STRING, (1 << 16)
     end
 
     def self.process_options(option, type)

data/lib/commonmarker/node.rb

@@ -31,21 +31,23 @@ module CommonMarker
     # Public: Convert the node to a CommonMark string.
     #
     # options - A {Symbol} or {Array of Symbol}s indicating the render options
+    # width - Column to wrap the output at
     #
     # Returns a {String}.
-    def to_commonmark(options = :DEFAULT)
+    def to_commonmark(options = :DEFAULT, width = 120)
       opts = Config.process_options(options, :render)
-      _render_commonmark(opts).force_encoding('utf-8')
+      _render_commonmark(opts, width).force_encoding('utf-8')
     end
 
     # Public: Convert the node to a plain text string.
     #
     # options - A {Symbol} or {Array of Symbol}s indicating the render options
+    # width - Column to wrap the output at
     #
     # Returns a {String}.
-    def to_plaintext(options = :DEFAULT)
+    def to_plaintext(options = :DEFAULT, width = 120)
       opts = Config.process_options(options, :render)
-      _render_plaintext(opts).force_encoding('utf-8')
+      _render_plaintext(opts, width).force_encoding('utf-8')
     end
 
     # Public: Iterate over the children (if any) of the current pointer.

data/lib/commonmarker/renderer/html_renderer.rb

@@ -103,19 +103,19 @@ module CommonMarker
 
     def html(node)
       block do
-        if option_enabled?(:SAFE)
-          out('<!-- raw HTML omitted -->')
-        else
+        if option_enabled?(:UNSAFE)
           out(tagfilter(node.string_content))
+        else
+          out('<!-- raw HTML omitted -->')
         end
       end
     end
 
     def inline_html(node)
-      if option_enabled?(:SAFE)
-        out('<!-- raw HTML omitted -->')
-      else
+      if option_enabled?(:UNSAFE)
         out(tagfilter(node.string_content))
+      else
+        out('<!-- raw HTML omitted -->')
       end
     end
 
@@ -174,7 +174,7 @@ module CommonMarker
       @alignments = node.table_alignments
       @needs_close_tbody = false
       out("<table#{sourcepos(node)}>\n", :children)
-      out("</tbody>") if @needs_close_tbody
+      out("</tbody>\n") if @needs_close_tbody
       out("</table>\n")
     end
 
@@ -182,7 +182,7 @@ module CommonMarker
       @column_index = 0
 
       @in_header = true
-      out("<thead>\n<tr#{sourcepos(node)}>", :children, "\n</tr>\n</thead>")
+      out("<thead>\n<tr#{sourcepos(node)}>\n", :children, "</tr>\n</thead>\n")
       @in_header = false
     end
 
@@ -190,9 +190,9 @@ module CommonMarker
       @column_index = 0
       if !@in_header && !@needs_close_tbody
         @needs_close_tbody = true
-        out("\n<tbody>")
+        out("<tbody>\n")
       end
-      out("\n<tr#{sourcepos(node)}>", :children, "\n</tr>")
+      out("<tr#{sourcepos(node)}>\n", :children, "</tr>\n")
     end
 
     def table_cell(node)
@@ -202,7 +202,7 @@ module CommonMarker
               when :center; ' align="center"'
               else; ''
               end
-      out(@in_header ? "\n<th#{align}#{sourcepos(node)}>" : "\n<td#{align}#{sourcepos(node)}>", :children, @in_header ? "</th>" : "</td>")
+      out(@in_header ? "<th#{align}#{sourcepos(node)}>" : "<td#{align}#{sourcepos(node)}>", :children, @in_header ? "</th>\n" : "</td>\n")
       @column_index += 1
     end
 
@@ -211,7 +211,7 @@ module CommonMarker
     end
 
     def footnote_reference(node)
-      out("<sup class=\"footnote-ref\"><a href=\"#fn#{node.string_content}\" id=\"fnref#{node.string_content}\">[#{node.string_content}]</a></sup>")
+      out("<sup class=\"footnote-ref\"><a href=\"#fn#{node.string_content}\" id=\"fnref#{node.string_content}\">#{node.string_content}</a></sup>")
     end
 
     def footnote_definition(_)

data/lib/commonmarker/version.rb

@@ -1,3 +1,3 @@
 module CommonMarker
-  VERSION = '0.17.7.1'.freeze
+  VERSION = '0.18.0'.freeze
 end

data/test/test_extensions.rb

@@ -35,6 +35,9 @@ Another extension:
       assert out.include?("<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"
+
     CommonMarker.render_html(@markdown, :DEFAULT, %i[table strikethrough]).tap do |out|
       refute out.include?("| a")
       refute out.include?("| <strong>x</strong>")
@@ -57,6 +60,9 @@ Another extension:
       %w(<table> <tr> <th> a </th> <td> c </td> <strong>x</strong>).each {|html| assert out.include?(html) }
       assert out.include?("~~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"
   end
 
   def test_bad_extension_specifications
@@ -67,6 +73,51 @@ Another extension:
 
   def test_comments_are_kept_as_expected
     assert_equal "<!--hello--> <blah> &lt;xmp>\n",
-      CommonMarker.render_html("<!--hello--> <blah> <xmp>\n", :DEFAULT, %i[tagfilter])
+      CommonMarker.render_html("<!--hello--> <blah> <xmp>\n", :UNSAFE, %i[tagfilter])
+  end
+
+  def test_table_prefer_style_attributes
+      assert_equal(<<-HTML, CommonMarker.render_html(<<-MD, :TABLE_PREFER_STYLE_ATTRIBUTES, %i[table]))
+<table>
+<thead>
+<tr>
+<th style="text-align: left">aaa</th>
+<th>bbb</th>
+<th style="text-align: center">ccc</th>
+<th>ddd</th>
+<th style="text-align: right">eee</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td style="text-align: left">fff</td>
+<td>ggg</td>
+<td style="text-align: center">hhh</td>
+<td>iii</td>
+<td style="text-align: right">jjj</td>
+</tr>
+</tbody>
+</table>
+      HTML
+aaa | bbb | ccc | ddd | eee
+:-- | --- | :-: | --- | --:
+fff | ggg | hhh | iii | jjj
+      MD
+  end
+
+  def test_plaintext
+    assert_equal(<<-HTML, CommonMarker.render_doc(<<-MD, :DEFAULT, %i[table strikethrough]).to_plaintext)
+Hello ~there~.
+
+| a |
+| --- |
+| b |
+    HTML
+Hello ~~there~~.
+
+| a |
+| - |
+| b |
+    MD
   end
 end

data/test/test_footnotes.rb

@@ -4,7 +4,7 @@ class TestFootnotes < Minitest::Test
   def setup
     @doc = CommonMarker.render_doc("Hello[^hi].\n\n[^hi]: Hey!\n", :FOOTNOTES)
     @expected = <<-HTML
-<p>Hello<sup class="footnote-ref"><a href="#fn1" id="fnref1">[1]</a></sup>.</p>
+<p>Hello<sup class="footnote-ref"><a href="#fn1" id="fnref1">1</a></sup>.</p>
 <section class="footnotes">
 <ol>
 <li id="fn1">

data/test/test_options.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class TestExtensions < Minitest::Test
+  def test_full_info_string
+    md = <<-MD
+```ruby
+module Foo
+```
+    MD
+
+    CommonMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, %q(<pre><code class="language-ruby">)
+    end
+
+    md = <<-MD
+```ruby my info string
+module Foo
+```
+    MD
+
+    CommonMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, %q(<pre><code class="language-ruby" data-meta="my info string">)
+    end
+
+    md = <<-MD
+```ruby my \x00 string
+module Foo
+```
+    MD
+
+    CommonMarker.render_html(md, :FULL_INFO_STRING).tap do |out|
+      assert_includes out, %Q(<pre><code class="language-ruby" data-meta="my � string">)
+    end
+  end
+end