commonmarker 0.17.13 → 0.23.4

data/ext/commonmarker/commonmarker.c

@@ -7,8 +7,8 @@
 #include "syntax_extension.h"
 #include "cmark-gfm-core-extensions.h"
 
-static VALUE rb_mNodeError;
-static VALUE rb_mNode;
+static VALUE rb_eNodeError;
+static VALUE rb_cNode;
 
 static VALUE sym_document;
 static VALUE sym_blockquote;
@@ -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;
@@ -94,7 +101,7 @@ static VALUE rb_node_to_value(cmark_node *node) {
 
   /* Only free tree roots. */
   free_func = cmark_node_parent(node) ? NULL : rb_free_c_struct;
-  val = Data_Wrap_Struct(rb_mNode, rb_mark_c_struct, free_func, node);
+  val = Data_Wrap_Struct(rb_cNode, rb_mark_c_struct, free_func, node);
   cmark_node_set_user_data(node, (void *)val);
 
   return val;
@@ -108,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));
     }
 
@@ -135,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)));
     }
 
@@ -150,33 +154,57 @@ 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());
+  parser = prepare_parser(rb_options, rb_extensions);
+
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
+  doc = cmark_parser_finish(parser);
+
+  if (doc == NULL) {
+    cmark_parser_free(parser);
+    rb_raise(rb_eNodeError, "error parsing document");
+  }
+
+  html = cmark_render_html(doc, parser->options, parser->syntax_extensions);
+
+  cmark_parser_free(parser);
+  cmark_node_free(doc);
+
+  return rb_utf8_str_new_cstr(html);
+}
 
-  str = (char *)RSTRING_PTR(rb_text);
-  len = RSTRING_LEN(rb_text);
+/*
+ * 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 *xml;
+  cmark_parser *parser;
+  cmark_node *doc;
+
+  Check_Type(rb_text, T_STRING);
 
-  cmark_parser_feed(parser, str, len);
+  parser = prepare_parser(rb_options, rb_extensions);
+
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
   doc = cmark_parser_finish(parser);
+
   if (doc == NULL) {
-    cmark_arena_reset();
-    rb_raise(rb_mNodeError, "error parsing document");
+    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();
+  xml = cmark_render_xml(doc, parser->options);
 
-  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(xml);
 }
 
 /*
@@ -250,11 +278,11 @@ static VALUE rb_node_new(VALUE self, VALUE type) {
   else if (type == sym_footnote_definition)
     node_type = CMARK_NODE_FOOTNOTE_DEFINITION;
   else
-    rb_raise(rb_mNodeError, "invalid node of type %d", node_type);
+    rb_raise(rb_eNodeError, "invalid node of type %d", node_type);
 
   node = cmark_node_new(node_type);
   if (node == NULL) {
-    rb_raise(rb_mNodeError, "could not create node of type %d", node_type);
+    rb_raise(rb_eNodeError, "could not create node of type %d", node_type);
   }
 
   return rb_node_to_value(node);
@@ -267,23 +295,22 @@ 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);
   if (doc == NULL) {
-    rb_raise(rb_mNodeError, "error parsing document");
+    rb_raise(rb_eNodeError, "error parsing document");
   }
   cmark_parser_free(parser);
 
@@ -302,7 +329,7 @@ static VALUE rb_node_get_string_content(VALUE self) {
 
   text = cmark_node_get_literal(node);
   if (text == NULL) {
-    rb_raise(rb_mNodeError, "could not get string content");
+    rb_raise(rb_eNodeError, "could not get string content");
   }
 
   return encode_utf8_string(text);
@@ -324,7 +351,7 @@ static VALUE rb_node_set_string_content(VALUE self, VALUE s) {
   text = StringValueCStr(s);
 
   if (!cmark_node_set_literal(node, text)) {
-    rb_raise(rb_mNodeError, "could not set string content");
+    rb_raise(rb_eNodeError, "could not set string content");
   }
 
   return Qnil;
@@ -412,7 +439,7 @@ static VALUE rb_node_get_type(VALUE self) {
       s = node->extension->get_type_string_func(node->extension, node);
       return ID2SYM(rb_intern(s));
     }
-    rb_raise(rb_mNodeError, "invalid node type %d", node_type);
+    rb_raise(rb_eNodeError, "invalid node type %d", node_type);
   }
 
   return symbol;
@@ -512,7 +539,7 @@ static VALUE rb_node_insert_before(VALUE self, VALUE sibling) {
   Data_Get_Struct(sibling, cmark_node, node2);
 
   if (!cmark_node_insert_before(node1, node2)) {
-    rb_raise(rb_mNodeError, "could not insert before");
+    rb_raise(rb_eNodeError, "could not insert before");
   }
 
   rb_parent_added(sibling);
@@ -567,6 +594,27 @@ 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;
+  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}.
@@ -638,7 +686,7 @@ static VALUE rb_node_insert_after(VALUE self, VALUE sibling) {
   Data_Get_Struct(sibling, cmark_node, node2);
 
   if (!cmark_node_insert_after(node1, node2)) {
-    rb_raise(rb_mNodeError, "could not insert after");
+    rb_raise(rb_eNodeError, "could not insert after");
   }
 
   rb_parent_added(sibling);
@@ -661,7 +709,7 @@ static VALUE rb_node_prepend_child(VALUE self, VALUE child) {
   Data_Get_Struct(child, cmark_node, node2);
 
   if (!cmark_node_prepend_child(node1, node2)) {
-    rb_raise(rb_mNodeError, "could not prepend child");
+    rb_raise(rb_eNodeError, "could not prepend child");
   }
 
   rb_parent_added(child);
@@ -684,7 +732,7 @@ static VALUE rb_node_append_child(VALUE self, VALUE child) {
   Data_Get_Struct(child, cmark_node, node2);
 
   if (!cmark_node_append_child(node1, node2)) {
-    rb_raise(rb_mNodeError, "could not append child");
+    rb_raise(rb_eNodeError, "could not append child");
   }
 
   rb_parent_added(child);
@@ -744,7 +792,7 @@ static VALUE rb_node_get_url(VALUE self) {
 
   text = cmark_node_get_url(node);
   if (text == NULL) {
-    rb_raise(rb_mNodeError, "could not get url");
+    rb_raise(rb_eNodeError, "could not get url");
   }
 
   return rb_str_new2(text);
@@ -766,7 +814,7 @@ static VALUE rb_node_set_url(VALUE self, VALUE url) {
   text = StringValueCStr(url);
 
   if (!cmark_node_set_url(node, text)) {
-    rb_raise(rb_mNodeError, "could not set url");
+    rb_raise(rb_eNodeError, "could not set url");
   }
 
   return Qnil;
@@ -785,7 +833,7 @@ static VALUE rb_node_get_title(VALUE self) {
 
   text = cmark_node_get_title(node);
   if (text == NULL) {
-    rb_raise(rb_mNodeError, "could not get title");
+    rb_raise(rb_eNodeError, "could not get title");
   }
 
   return rb_str_new2(text);
@@ -807,7 +855,7 @@ static VALUE rb_node_set_title(VALUE self, VALUE title) {
   text = StringValueCStr(title);
 
   if (!cmark_node_set_title(node, text)) {
-    rb_raise(rb_mNodeError, "could not set title");
+    rb_raise(rb_eNodeError, "could not set title");
   }
 
   return Qnil;
@@ -827,7 +875,7 @@ static VALUE rb_node_get_header_level(VALUE self) {
   header_level = cmark_node_get_header_level(node);
 
   if (header_level == 0) {
-    rb_raise(rb_mNodeError, "could not get header_level");
+    rb_raise(rb_eNodeError, "could not get header_level");
   }
 
   return INT2NUM(header_level);
@@ -849,7 +897,7 @@ static VALUE rb_node_set_header_level(VALUE self, VALUE level) {
   l = FIX2INT(level);
 
   if (!cmark_node_set_header_level(node, l)) {
-    rb_raise(rb_mNodeError, "could not set header_level");
+    rb_raise(rb_eNodeError, "could not set header_level");
   }
 
   return Qnil;
@@ -874,7 +922,7 @@ static VALUE rb_node_get_list_type(VALUE self) {
   } else if (list_type == CMARK_ORDERED_LIST) {
     symbol = sym_ordered_list;
   } else {
-    rb_raise(rb_mNodeError, "could not get list_type");
+    rb_raise(rb_eNodeError, "could not get list_type");
   }
 
   return symbol;
@@ -899,11 +947,11 @@ static VALUE rb_node_set_list_type(VALUE self, VALUE list_type) {
   } else if (list_type == sym_ordered_list) {
     type = CMARK_ORDERED_LIST;
   } else {
-    rb_raise(rb_mNodeError, "invalid list_type");
+    rb_raise(rb_eNodeError, "invalid list_type");
   }
 
   if (!cmark_node_set_list_type(node, type)) {
-    rb_raise(rb_mNodeError, "could not set list_type");
+    rb_raise(rb_eNodeError, "could not set list_type");
   }
 
   return Qnil;
@@ -922,7 +970,7 @@ static VALUE rb_node_get_list_start(VALUE self) {
 
   if (cmark_node_get_type(node) != CMARK_NODE_LIST ||
       cmark_node_get_list_type(node) != CMARK_ORDERED_LIST) {
-    rb_raise(rb_mNodeError, "can't get list_start for non-ordered list %d",
+    rb_raise(rb_eNodeError, "can't get list_start for non-ordered list %d",
              cmark_node_get_list_type(node));
   }
 
@@ -946,7 +994,7 @@ static VALUE rb_node_set_list_start(VALUE self, VALUE start) {
   s = FIX2INT(start);
 
   if (!cmark_node_set_list_start(node, s)) {
-    rb_raise(rb_mNodeError, "could not set list_start");
+    rb_raise(rb_eNodeError, "could not set list_start");
   }
 
   return Qnil;
@@ -964,7 +1012,7 @@ static VALUE rb_node_get_list_tight(VALUE self) {
   Data_Get_Struct(self, cmark_node, node);
 
   if (cmark_node_get_type(node) != CMARK_NODE_LIST) {
-    rb_raise(rb_mNodeError, "can't get list_tight for non-list");
+    rb_raise(rb_eNodeError, "can't get list_tight for non-list");
   }
 
   flag = cmark_node_get_list_tight(node);
@@ -986,7 +1034,7 @@ static VALUE rb_node_set_list_tight(VALUE self, VALUE tight) {
   t = RTEST(tight);
 
   if (!cmark_node_set_list_tight(node, t)) {
-    rb_raise(rb_mNodeError, "could not set list_tight");
+    rb_raise(rb_eNodeError, "could not set list_tight");
   }
 
   return Qnil;
@@ -1006,7 +1054,7 @@ static VALUE rb_node_get_fence_info(VALUE self) {
   fence_info = cmark_node_get_fence_info(node);
 
   if (fence_info == NULL) {
-    rb_raise(rb_mNodeError, "could not get fence_info");
+    rb_raise(rb_eNodeError, "could not get fence_info");
   }
 
   return rb_str_new2(fence_info);
@@ -1028,12 +1076,66 @@ static VALUE rb_node_set_fence_info(VALUE self, VALUE info) {
   text = StringValueCStr(info);
 
   if (!cmark_node_set_fence_info(node, text)) {
-    rb_raise(rb_mNodeError, "could not set fence_info");
+    rb_raise(rb_eNodeError, "could not set fence_info");
   }
 
   return Qnil;
 }
 
+static VALUE rb_node_get_tasklist_item_checked(VALUE self) {
+  int tasklist_state;
+  cmark_node *node;
+  Data_Get_Struct(self, cmark_node, node);
+
+  tasklist_state = cmark_gfm_extensions_get_tasklist_item_checked(node);
+
+  if (tasklist_state == 1) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+/*
+ * Public: Sets the checkbox state of the current node (must be a `:tasklist`).
+ *
+ * item_checked - A {Boolean} representing the new checkbox state
+ *
+ * Returns a {Boolean} representing the new checkbox state.
+ * Raises a NodeError if the checkbox state can't be set.
+ */
+static VALUE rb_node_set_tasklist_item_checked(VALUE self, VALUE item_checked) {
+  int tasklist_state;
+  cmark_node *node;
+  Data_Get_Struct(self, cmark_node, node);
+  tasklist_state = RTEST(item_checked);
+
+  if (!cmark_gfm_extensions_set_tasklist_item_checked(node, tasklist_state)) {
+    rb_raise(rb_eNodeError, "could not set tasklist_item_checked");
+  };
+
+  if (tasklist_state) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+// TODO: remove this, superseded by the above method
+static VALUE rb_node_get_tasklist_state(VALUE self) {
+  int tasklist_state;
+  cmark_node *node;
+  Data_Get_Struct(self, cmark_node, node);
+
+  tasklist_state = cmark_gfm_extensions_get_tasklist_item_checked(node);
+
+  if (tasklist_state == 1) {
+    return rb_str_new2("checked");
+  } else {
+    return rb_str_new2("unchecked");
+  }
+}
+
 static VALUE rb_node_get_table_alignments(VALUE self) {
   uint16_t column_count, i;
   uint8_t *alignments;
@@ -1045,7 +1147,7 @@ static VALUE rb_node_get_table_alignments(VALUE self) {
   alignments = cmark_gfm_extensions_get_table_alignments(node);
 
   if (!column_count || !alignments) {
-    rb_raise(rb_mNodeError, "could not get column_count or alignments");
+    rb_raise(rb_eNodeError, "could not get column_count or alignments");
   }
 
   ary = rb_ary_new();
@@ -1076,7 +1178,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;
@@ -1096,7 +1199,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;
@@ -1150,48 +1253,54 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
 
   module = rb_define_module("CommonMarker");
   rb_define_singleton_method(module, "extensions", rb_extensions, 0);
-  rb_mNodeError = rb_define_class_under(module, "NodeError", rb_eStandardError);
-  rb_mNode = rb_define_class_under(module, "Node", rb_cObject);
-  rb_define_singleton_method(rb_mNode, "markdown_to_html", rb_markdown_to_html,
+  rb_eNodeError = rb_define_class_under(module, "NodeError", rb_eStandardError);
+  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_mNode, "new", rb_node_new, 1);
-  rb_define_singleton_method(rb_mNode, "parse_document", rb_parse_document, 4);
-  rb_define_method(rb_mNode, "string_content", rb_node_get_string_content, 0);
-  rb_define_method(rb_mNode, "string_content=", rb_node_set_string_content, 1);
-  rb_define_method(rb_mNode, "type", rb_node_get_type, 0);
-  rb_define_method(rb_mNode, "type_string", rb_node_get_type_string, 0);
-  rb_define_method(rb_mNode, "sourcepos", rb_node_get_sourcepos, 0);
-  rb_define_method(rb_mNode, "delete", rb_node_unlink, 0);
-  rb_define_method(rb_mNode, "first_child", rb_node_first_child, 0);
-  rb_define_method(rb_mNode, "next", rb_node_next, 0);
-  rb_define_method(rb_mNode, "insert_before", rb_node_insert_before, 1);
-  rb_define_method(rb_mNode, "_render_html", rb_render_html, 2);
-  rb_define_method(rb_mNode, "_render_commonmark", rb_render_commonmark, -1);
-  rb_define_method(rb_mNode, "_render_plaintext", rb_render_plaintext, -1);
-  rb_define_method(rb_mNode, "insert_after", rb_node_insert_after, 1);
-  rb_define_method(rb_mNode, "prepend_child", rb_node_prepend_child, 1);
-  rb_define_method(rb_mNode, "append_child", rb_node_append_child, 1);
-  rb_define_method(rb_mNode, "last_child", rb_node_last_child, 0);
-  rb_define_method(rb_mNode, "parent", rb_node_parent, 0);
-  rb_define_method(rb_mNode, "previous", rb_node_previous, 0);
-  rb_define_method(rb_mNode, "url", rb_node_get_url, 0);
-  rb_define_method(rb_mNode, "url=", rb_node_set_url, 1);
-  rb_define_method(rb_mNode, "title", rb_node_get_title, 0);
-  rb_define_method(rb_mNode, "title=", rb_node_set_title, 1);
-  rb_define_method(rb_mNode, "header_level", rb_node_get_header_level, 0);
-  rb_define_method(rb_mNode, "header_level=", rb_node_set_header_level, 1);
-  rb_define_method(rb_mNode, "list_type", rb_node_get_list_type, 0);
-  rb_define_method(rb_mNode, "list_type=", rb_node_set_list_type, 1);
-  rb_define_method(rb_mNode, "list_start", rb_node_get_list_start, 0);
-  rb_define_method(rb_mNode, "list_start=", rb_node_set_list_start, 1);
-  rb_define_method(rb_mNode, "list_tight", rb_node_get_list_tight, 0);
-  rb_define_method(rb_mNode, "list_tight=", rb_node_set_list_tight, 1);
-  rb_define_method(rb_mNode, "fence_info", rb_node_get_fence_info, 0);
-  rb_define_method(rb_mNode, "fence_info=", rb_node_set_fence_info, 1);
-  rb_define_method(rb_mNode, "table_alignments", rb_node_get_table_alignments, 0);
-
-  rb_define_method(rb_mNode, "html_escape_href", rb_html_escape_href, 1);
-  rb_define_method(rb_mNode, "html_escape_html", rb_html_escape_html, 1);
+  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);
+  rb_define_method(rb_cNode, "string_content=", rb_node_set_string_content, 1);
+  rb_define_method(rb_cNode, "type", rb_node_get_type, 0);
+  rb_define_method(rb_cNode, "type_string", rb_node_get_type_string, 0);
+  rb_define_method(rb_cNode, "sourcepos", rb_node_get_sourcepos, 0);
+  rb_define_method(rb_cNode, "delete", rb_node_unlink, 0);
+  rb_define_method(rb_cNode, "first_child", rb_node_first_child, 0);
+  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);
+  rb_define_method(rb_cNode, "prepend_child", rb_node_prepend_child, 1);
+  rb_define_method(rb_cNode, "append_child", rb_node_append_child, 1);
+  rb_define_method(rb_cNode, "last_child", rb_node_last_child, 0);
+  rb_define_method(rb_cNode, "parent", rb_node_parent, 0);
+  rb_define_method(rb_cNode, "previous", rb_node_previous, 0);
+  rb_define_method(rb_cNode, "url", rb_node_get_url, 0);
+  rb_define_method(rb_cNode, "url=", rb_node_set_url, 1);
+  rb_define_method(rb_cNode, "title", rb_node_get_title, 0);
+  rb_define_method(rb_cNode, "title=", rb_node_set_title, 1);
+  rb_define_method(rb_cNode, "header_level", rb_node_get_header_level, 0);
+  rb_define_method(rb_cNode, "header_level=", rb_node_set_header_level, 1);
+  rb_define_method(rb_cNode, "list_type", rb_node_get_list_type, 0);
+  rb_define_method(rb_cNode, "list_type=", rb_node_set_list_type, 1);
+  rb_define_method(rb_cNode, "list_start", rb_node_get_list_start, 0);
+  rb_define_method(rb_cNode, "list_start=", rb_node_set_list_start, 1);
+  rb_define_method(rb_cNode, "list_tight", rb_node_get_list_tight, 0);
+  rb_define_method(rb_cNode, "list_tight=", rb_node_set_list_tight, 1);
+  rb_define_method(rb_cNode, "fence_info", rb_node_get_fence_info, 0);
+  rb_define_method(rb_cNode, "fence_info=", rb_node_set_fence_info, 1);
+  rb_define_method(rb_cNode, "table_alignments", rb_node_get_table_alignments, 0);
+  rb_define_method(rb_cNode, "tasklist_state", rb_node_get_tasklist_state, 0);
+  rb_define_method(rb_cNode, "tasklist_item_checked?", rb_node_get_tasklist_item_checked, 0);
+  rb_define_method(rb_cNode, "tasklist_item_checked=", rb_node_set_tasklist_item_checked, 1);
+
+  rb_define_method(rb_cNode, "html_escape_href", rb_html_escape_href, 1);
+  rb_define_method(rb_cNode, "html_escape_html", rb_html_escape_html, 1);
 
   cmark_gfm_core_extensions_ensure_registered();
 }

data/ext/commonmarker/core-extensions.c

@@ -3,6 +3,7 @@
 #include "strikethrough.h"
 #include "table.h"
 #include "tagfilter.h"
+#include "tasklist.h"
 #include "registry.h"
 #include "plugin.h"
 
@@ -12,6 +13,7 @@ static int core_extensions_registration(cmark_plugin *plugin) {
                                          create_strikethrough_extension());
   cmark_plugin_register_syntax_extension(plugin, create_autolink_extension());
   cmark_plugin_register_syntax_extension(plugin, create_tagfilter_extension());
+  cmark_plugin_register_syntax_extension(plugin, create_tasklist_extension());
   return 1;
 }