qiita_marker 0.23.2.0 → 0.23.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4222f9db082f683cdabb0d9d42a255ab4b689fe19cdb178efe4feccea10439d
-  data.tar.gz: 49e29b6cee35cb99e550f65ed830e6cd83448c7b058c09c3383c97722df86b5c
+  metadata.gz: ad4193d920fb95f2c24307d15220150746187c0d74a3d470690e318b2d99d0d6
+  data.tar.gz: b5d1fb774bfafe83550bc0beba25fdc9d8cf67612bb3f4818e3d8e83be58cce8
 SHA512:
-  metadata.gz: c74fe17ddee587a42758795f9a9ff9bd5982b7c284a247615af864e6fdad8dd1b6708b55eadbec2b9eaf893e3d9eeb5e03c72d62da78598322b90d01adc8cc84
-  data.tar.gz: f8180555767d3aa6134f7dae895d06fdda9f4b655d41d6872b6234dbe073787debd4fd0b6956da261f149b28d821d95c6e0b947e7049307a92267205e24a5a9c
+  metadata.gz: 690f8870c83b4bf02a799dfd6206ef1c893f22acb22c91110b5523dbe0c35c8f5b3f2276926828697f3cc90497ac9a0302fe09c5fd2b33aca21213c586e94c42
+  data.tar.gz: 674aa47fc8e97954c20a98648307cd0c96dfda31e29f975333c3fdd4d8baf2ad059c759f4db7e7bc3dbe652d2085c224b5baa6359065524d64c5092c4c38f00d

data/LICENSE.txt

@@ -1,21 +1,23 @@
-MIT License
+Copyright (c) 2015 Garen J. Torikian
+Copyright (c) 2021 Qiita Inc.
 
-Copyright 2021 Increments Inc.
+MIT License
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,6 +1,6 @@
 # Qiita Marker
 
-[![Build Status](https://github.com/increments/qiita-marker/actions/workflows/test.yml/badge.svg)](https://github.com/increments/qiita-marker/actions/workflows/test.yml)
+[![Build Status](https://github.com/increments/qiita-marker/actions/workflows/test.yml/badge.svg)](https://github.com/increments/qiita-marker/actions/workflows/test.yml) [![Gem Version](https://badge.fury.io/rb/qiita_marker.svg)](https://badge.fury.io/rb/qiita_marker)
 
 :warning: This library is still in the testing phase. As such, development may be halted.
 
@@ -11,6 +11,29 @@ It will be a core module of [Qiita Markdown](https://github.com/increments/qiita
 
 Please see [CommonMarker's Usage](https://github.com/gjtorikian/commonmarker#usage).
 
+In addition to CommonMarker's options and extensions, the following are available in Qiita Marker.
+
+### Original options
+
+#### Parse options
+
+| Name | Description |
+| --- | --- |
+| `:MENTION_NO_EMPHASIS` | Prevent parsing mentions as emphasis. |
+| `:AUTOLINK_CLASS_NAME` | Append `class="autolink"` to extension's autolinks. |
+
+#### Render options
+
+| Name | Description |
+| --- | --- |
+| `:CODE_DATA_METADATA` | Use `<code data-metadata>` for fenced code blocks. |
+| `:MENTION_NO_EMPHASIS` | Prevent parsing mentions as emphasis. |
+| `:AUTOLINK_CLASS_NAME` | Append `class="autolink"` to extension's autolinks. |
+
+### Original extensions
+
+- `:custom_block` - This provides support for customizable blocks.
+
 ## Contributing
 
 If you have suggestion or modification to this repository, please create an Issue or Pull Request.
@@ -45,6 +68,11 @@ $ docker compose run --rm app ./script/bootstrap
 $ docker compose run --rm rake test
 ```
 
+### Versioning policy
+
+Qiita Marker follows CommonMarker's updates by merging the upstream changes.
+The version format is `MAJOR.MINOR.PATCH.FORK`. `MAJOR.MINOR.PATCH` is the same as the version of CommonMarker that Qiita Marker is based on. `FORK` is incremented on each release of Qiita Marker itself and reset to zero when any of `MAJOR.MINOR.PATCH` is bumped.
+
 ## License
 
 Please see [LICENSE.txt](/LICENSE.txt).

data/ext/qiita_marker/autolink.c

@@ -1,5 +1,9 @@
 #include "autolink.h"
+#include "houdini.h"
+#include "qfm.h"
+#include "scanners.h"
 #include <parser.h>
+#include <render.h>
 #include <string.h>
 #include <utf8.h>
 
@@ -9,6 +13,11 @@
 #include <strings.h>
 #endif
 
+static void escape_html(cmark_strbuf *dest, const unsigned char *source,
+                        bufsize_t length) {
+  houdini_escape_html0(dest, source, length, 0);
+}
+
 static int is_valid_hostchar(const uint8_t *link, size_t link_len) {
   int32_t ch;
   int r = cmark_utf8proc_iterate(link, (bufsize_t)link_len, &ch);
@@ -144,7 +153,8 @@ static size_t check_domain(uint8_t *data, size_t size, int allow_short) {
 }
 
 static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
-                             cmark_inline_parser *inline_parser) {
+                             cmark_inline_parser *inline_parser,
+                             cmark_syntax_extension *ext) {
   cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
   size_t max_rewind = cmark_inline_parser_get_offset(inline_parser);
   uint8_t *data = chunk->data + max_rewind;
@@ -176,6 +186,9 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
   cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(node, ext);
+  }
 
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
@@ -199,7 +212,8 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
 }
 
 static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
-                             cmark_inline_parser *inline_parser) {
+                             cmark_inline_parser *inline_parser,
+                             cmark_syntax_extension *ext) {
   size_t link_end, domain_len;
   int rewind = 0;
 
@@ -237,6 +251,9 @@ static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
   cmark_node_unput(parent, rewind);
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(node, ext);
+  }
 
   cmark_chunk url = cmark_chunk_dup(chunk, max_rewind - rewind,
                                     (bufsize_t)(link_end + rewind));
@@ -257,10 +274,10 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
     return NULL;
 
   if (c == ':')
-    return url_match(parser, parent, inline_parser);
+    return url_match(parser, parent, inline_parser, ext);
 
   if (c == 'w')
-    return www_match(parser, parent, inline_parser);
+    return www_match(parser, parent, inline_parser, ext);
 
   return NULL;
 
@@ -269,7 +286,8 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
   // inline was finished in inlines.c.
 }
 
-static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset, int depth) {
+static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
+                             int depth, cmark_syntax_extension *ext) {
   // postprocess_text can recurse very deeply if there is a very long line of
   // '@' only.  Stop at a reasonable depth to ensure it cannot crash.
   if (depth > 1000) return;
@@ -311,7 +329,7 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   }
 
   if (rewind == 0 || ns > 0) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
@@ -331,20 +349,23 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
 
   if (link_end < 2 || nb != 1 || np == 0 ||
       (!cmark_isalpha(data[link_end - 1]) && data[link_end - 1] != '.')) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
   link_end = autolink_delim(data, link_end);
 
   if (link_end == 0) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
   cmark_chunk_to_cstr(parser->mem, &text->as.literal);
 
   cmark_node *link_node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(link_node, ext);
+  }
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
   cmark_strbuf_puts(&buf, "mailto:");
@@ -373,7 +394,7 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   text->as.literal.len = offset + max_rewind - rewind;
   text->as.literal.data[text->as.literal.len] = 0;
 
-  postprocess_text(parser, post, 0, depth + 1);
+  postprocess_text(parser, post, 0, depth + 1, ext);
 }
 
 static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser, cmark_node *root) {
@@ -400,7 +421,7 @@ static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser
     }
 
     if (ev == CMARK_EVENT_ENTER && node->type == CMARK_NODE_TEXT) {
-      postprocess_text(parser, node, 0, /*depth*/0);
+      postprocess_text(parser, node, 0, /*depth*/ 0, ext);
     }
   }
 
@@ -409,12 +430,38 @@ static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser
   return root;
 }
 
+static void html_render(cmark_syntax_extension *extension,
+                        cmark_html_renderer *renderer, cmark_node *node,
+                        cmark_event_type ev_type, int options) {
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  cmark_strbuf *html = renderer->html;
+
+  if (entering) {
+    cmark_strbuf_puts(html, "<a href=\"");
+    if ((options & CMARK_OPT_UNSAFE) ||
+        !(scan_dangerous_url(&node->as.link.url, 0))) {
+      houdini_escape_href(html, node->as.link.url.data, node->as.link.url.len);
+    }
+    if (node->as.link.title.len) {
+      cmark_strbuf_puts(html, "\" title=\"");
+      escape_html(html, node->as.link.title.data, node->as.link.title.len);
+    }
+    if (options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+      cmark_strbuf_puts(html, "\" class=\"autolink");
+    }
+    cmark_strbuf_puts(html, "\">");
+  } else {
+    cmark_strbuf_puts(html, "</a>");
+  }
+}
+
 cmark_syntax_extension *create_autolink_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("autolink");
   cmark_llist *special_chars = NULL;
 
   cmark_syntax_extension_set_match_inline_func(ext, match);
   cmark_syntax_extension_set_postprocess_func(ext, postprocess);
+  cmark_syntax_extension_set_html_render_func(ext, html_render);
 
   cmark_mem *mem = cmark_get_default_mem_allocator();
   special_chars = cmark_llist_append(mem, special_chars, (void *)':');

data/ext/qiita_marker/core-extensions.c

@@ -6,6 +6,7 @@
 #include "tasklist.h"
 #include "registry.h"
 #include "plugin.h"
+#include "qfm_custom_block.h"
 
 static int core_extensions_registration(cmark_plugin *plugin) {
   cmark_plugin_register_syntax_extension(plugin, create_table_extension());
@@ -14,6 +15,7 @@ static int core_extensions_registration(cmark_plugin *plugin) {
   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());
+  cmark_plugin_register_syntax_extension(plugin, create_qfm_custom_block_extension());
   return 1;
 }
 

data/ext/qiita_marker/html.c

@@ -10,6 +10,7 @@
 #include "syntax_extension.h"
 #include "html.h"
 #include "render.h"
+#include "qfm.h"
 
 // Functions to convert cmark_nodes to HTML strings.
 
@@ -222,6 +223,18 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
           escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
         }
         cmark_strbuf_puts(html, "\"><code>");
+      } else if (options & CMARK_OPT_CODE_DATA_METADATA) {
+        cmark_strbuf_puts(html, "<pre");
+        cmark_html_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, "><code data-metadata=\"");
+        escape_html(html, node->as.code.info.data, node->as.code.info.len);
+        if (first_tag < node->as.code.info.len &&
+            (options & CMARK_OPT_FULL_INFO_STRING)) {
+          cmark_strbuf_puts(html, "\" data-meta=\"");
+          escape_html(html, node->as.code.info.data + first_tag + 1,
+                      node->as.code.info.len - first_tag - 1);
+        }
+        cmark_strbuf_puts(html, "\">");
       } else {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);

data/ext/qiita_marker/inlines.c

@@ -13,6 +13,8 @@
 #include "scanners.h"
 #include "inlines.h"
 #include "syntax_extension.h"
+#include "qfm.h"
+#include "qfm_mention_no_emphasis.h"
 
 static const char *EMDASH = "\xE2\x80\x94";
 static const char *ENDASH = "\xE2\x80\x93";
@@ -381,11 +383,10 @@ static cmark_node *handle_backticks(subject *subj, int options) {
   }
 }
 
-
 // Scan ***, **, or * and return number scanned, or 0.
 // Advances position.
 static int scan_delims(subject *subj, unsigned char c, bool *can_open,
-                       bool *can_close) {
+                       bool *can_close, bool mention_no_emphasis) {
   int numdelims = 0;
   bufsize_t before_char_pos, after_char_pos;
   int32_t after_char = 0;
@@ -393,6 +394,15 @@ static int scan_delims(subject *subj, unsigned char c, bool *can_open,
   int len;
   bool left_flanking, right_flanking;
 
+  if (mention_no_emphasis &&
+      is_part_of_mention(subj->input.data + subj->pos, subj->pos)) {
+    numdelims++;
+    advance(subj);
+    *can_open = false;
+    *can_close = false;
+    return numdelims;
+  }
+
   if (subj->pos == 0) {
     before_char = 10;
   } else {
@@ -528,13 +538,14 @@ static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
 }
 
 // Assumes the subject has a c at the current position.
-static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) {
+static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart,
+                                bool mention_no_emphasis) {
   bufsize_t numdelims;
   cmark_node *inl_text;
   bool can_open, can_close;
   cmark_chunk contents;
 
-  numdelims = scan_delims(subj, c, &can_open, &can_close);
+  numdelims = scan_delims(subj, c, &can_open, &can_close, mention_no_emphasis);
 
   if (c == '\'' && smart) {
     contents = cmark_chunk_literal(RIGHTSINGLEQUOTE);
@@ -1387,7 +1398,8 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
   case '_':
   case '\'':
   case '"':
-    new_inl = handle_delim(subj, c, (options & CMARK_OPT_SMART) != 0);
+    new_inl = handle_delim(subj, c, (options & CMARK_OPT_SMART) != 0,
+                           (options & CMARK_OPT_MENTION_NO_EMPHASIS) != 0);
     break;
   case '-':
     new_inl = handle_hyphen(subj, (options & CMARK_OPT_SMART) != 0);

data/ext/qiita_marker/qfm.h

@@ -0,0 +1,22 @@
+#ifndef QFM_H
+#define QFM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Use <pre><code data-metadata="x"> tags for code blocks instead of <pre><code
+ * class="language-x">. **/
+#define CMARK_OPT_CODE_DATA_METADATA (1 << 25)
+
+/* Prevent parsing Qiita-style Mentions as emphasis. */
+#define CMARK_OPT_MENTION_NO_EMPHASIS (1 << 26)
+
+/* Render autolinks with class name  */
+#define CMARK_OPT_AUTOLINK_CLASS_NAME (1 << 27)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/qiita_marker/qfm_custom_block.c

@@ -0,0 +1,265 @@
+#include <html.h>
+#include <parser.h>
+#include <render.h>
+
+#include "cmark-gfm-core-extensions.h"
+#include "houdini.h"
+#include "qfm_custom_block.h"
+#include "qfm_scanners.h"
+#include "strikethrough.h"
+
+cmark_node_type CMARK_NODE_QFM_CUSTOM_BLOCK;
+
+typedef struct {
+  cmark_chunk info;
+  bool opening;
+  cmark_strbuf *xml_attr_buff;
+} node_qfm_custom_block;
+
+static void escape_html(cmark_strbuf *dest, const unsigned char *source,
+                        bufsize_t length) {
+  houdini_escape_html0(dest, source, length, 0);
+}
+
+static bool get_qfm_custom_block_opening(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+
+  cmark_node_type node_type = cmark_node_get_type(node);
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    return ((node_qfm_custom_block *)node->as.opaque)->opening;
+  } else {
+    return false;
+  }
+}
+
+static bool set_qfm_custom_block_opening(cmark_node *node, bool opening) {
+  if (node == NULL) {
+    return false;
+  }
+
+  cmark_node_type node_type = cmark_node_get_type(node);
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    ((node_qfm_custom_block *)node->as.opaque)->opening = opening;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static cmark_chunk *get_qfm_custom_block_info(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  cmark_node_type node_type = cmark_node_get_type(node);
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    return &((node_qfm_custom_block *)node->as.opaque)->info;
+  } else {
+    return NULL;
+  }
+}
+
+static bool set_qfm_custom_block_info(cmark_node *node, const char *info) {
+  if (node == NULL) {
+    return false;
+  }
+
+  cmark_node_type node_type = cmark_node_get_type(node);
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    cmark_chunk_set_cstr(cmark_node_mem(node),
+                         &((node_qfm_custom_block *)node->as.opaque)->info,
+                         info);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static void free_node_qfm_custom_block(cmark_mem *mem, void *ptr) {
+  node_qfm_custom_block *cb = (node_qfm_custom_block *)ptr;
+
+  cmark_chunk_free(mem, &cb->info);
+  cmark_strbuf_free(cb->xml_attr_buff);
+  mem->free(cb);
+}
+
+static int matches(cmark_syntax_extension *self, cmark_parser *parser,
+                   unsigned char *input, int len,
+                   cmark_node *parent_container) {
+  int res = 0;
+
+  if (get_qfm_custom_block_opening(parent_container)) {
+    bufsize_t matched = scan_close_qfm_custom_block_fence(
+        input, len, cmark_parser_get_first_nonspace(parser));
+
+    if (matched > 0) {
+      set_qfm_custom_block_opening(parent_container, false);
+      cmark_parser_advance_offset(parser, (char *)input,
+                                  len - cmark_parser_get_offset(parser), 0);
+    } else {
+      res = 1;
+    }
+  }
+
+  return res;
+}
+
+static cmark_node *try_opening_qfm_custom_block_block(
+    cmark_syntax_extension *self, int indented, cmark_parser *parser,
+    cmark_node *parent_container, unsigned char *input, int len) {
+  cmark_node_type parent_type = cmark_node_get_type(parent_container);
+
+  if (!indented && parent_type != CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    bufsize_t matched = scan_open_qfm_custom_block_fence(
+        input, len, cmark_parser_get_first_nonspace(parser));
+    if (!matched) {
+      return NULL;
+    }
+
+    cmark_node *custom_block_node = cmark_parser_add_child(
+        parser, parent_container, CMARK_NODE_QFM_CUSTOM_BLOCK,
+        parser->first_nonspace_column);
+    custom_block_node->as.opaque = (node_qfm_custom_block *)parser->mem->calloc(
+        1, sizeof(node_qfm_custom_block));
+
+    cmark_strbuf *info = parser->mem->calloc(1, sizeof(cmark_strbuf));
+    cmark_strbuf_init(parser->mem, info, len - matched);
+    cmark_strbuf_put(info, input + matched, len - matched);
+    cmark_strbuf_trim(info);
+
+    set_qfm_custom_block_opening(custom_block_node, true);
+    set_qfm_custom_block_info(custom_block_node, (char *)info->ptr);
+
+    cmark_node_set_syntax_extension(custom_block_node, self);
+    cmark_parser_advance_offset(parser, (char *)input,
+                                len - cmark_parser_get_offset(parser), 0);
+
+    return custom_block_node;
+  }
+
+  return NULL;
+}
+
+static const char *get_type_string(cmark_syntax_extension *self,
+                                   cmark_node *node) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    return "qfm_custom_block";
+  }
+
+  return "<unknown>";
+}
+
+static int can_contain(cmark_syntax_extension *self, cmark_node *node,
+                       cmark_node_type child_type) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
+}
+
+static int contains_inlines(cmark_syntax_extension *self, cmark_node *node) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
+}
+
+static void plaintext_render(cmark_syntax_extension *self,
+                             cmark_renderer *renderer, cmark_node *node,
+                             cmark_event_type ev_type, int options) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type != CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    assert(false);
+  }
+}
+
+static void html_render(cmark_syntax_extension *self,
+                        cmark_html_renderer *renderer, cmark_node *node,
+                        cmark_event_type ev_type, int options) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    bool entering = (ev_type == CMARK_EVENT_ENTER);
+    cmark_strbuf *html = renderer->html;
+
+    if (entering) {
+      cmark_html_render_cr(html);
+      cmark_strbuf_puts(html,
+                        "<div data-type=\"customblock\" data-metadata=\"");
+      cmark_chunk *info = get_qfm_custom_block_info(node);
+      escape_html(html, info->data, info->len);
+      cmark_strbuf_putc(html, '"');
+      cmark_html_render_sourcepos(node, html, options);
+      cmark_strbuf_putc(html, '>');
+    } else {
+      cmark_html_render_cr(html);
+      cmark_strbuf_puts(html, "</div>");
+      cmark_html_render_cr(html);
+    }
+  } else {
+    assert(false);
+  }
+}
+
+static const char *xml_attr(cmark_syntax_extension *self, cmark_node *node) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    cmark_chunk *info = get_qfm_custom_block_info(node);
+    cmark_mem *mem = node->content.mem;
+
+    cmark_strbuf *xml_attr_buff = mem->calloc(1, sizeof(cmark_strbuf));
+    ((node_qfm_custom_block *)node->as.opaque)->xml_attr_buff = xml_attr_buff;
+    cmark_strbuf_init(
+        mem, xml_attr_buff,
+        17 + info->len); // `17` is length of ` data-metadata="` and `"`.
+    cmark_strbuf_puts(xml_attr_buff, " data-metadata=\"");
+    cmark_strbuf_puts(xml_attr_buff, (char *)info->data);
+    cmark_strbuf_putc(xml_attr_buff, '"');
+
+    return (char *)xml_attr_buff->ptr;
+  }
+
+  return NULL;
+}
+
+static void opaque_alloc(cmark_syntax_extension *self, cmark_mem *mem,
+                         cmark_node *node) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    node->as.opaque = mem->calloc(1, sizeof(node_qfm_custom_block));
+  }
+}
+
+static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem,
+                        cmark_node *node) {
+  cmark_node_type node_type = cmark_node_get_type(node);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    free_node_qfm_custom_block(mem, node->as.opaque);
+  }
+}
+
+cmark_syntax_extension *create_qfm_custom_block_extension(void) {
+  cmark_syntax_extension *self = cmark_syntax_extension_new("custom_block");
+
+  cmark_syntax_extension_set_match_block_func(self, matches);
+  cmark_syntax_extension_set_open_block_func(
+      self, try_opening_qfm_custom_block_block);
+  cmark_syntax_extension_set_get_type_string_func(self, get_type_string);
+  cmark_syntax_extension_set_can_contain_func(self, can_contain);
+  cmark_syntax_extension_set_contains_inlines_func(self, contains_inlines);
+  cmark_syntax_extension_set_commonmark_render_func(self, plaintext_render);
+  cmark_syntax_extension_set_plaintext_render_func(self, plaintext_render);
+  cmark_syntax_extension_set_xml_attr_func(self, xml_attr);
+  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_NODE_QFM_CUSTOM_BLOCK = cmark_syntax_extension_add_node(0);
+
+  return self;
+}

data/ext/qiita_marker/qfm_custom_block.h

@@ -0,0 +1,10 @@
+#ifndef QFM_CUSTOM_BLOCK_H
+#define QFM_CUSTOM_BLOCK_H
+
+#include "cmark-gfm-core-extensions.h"
+
+extern cmark_node_type CMARK_NODE_QFM_CUSTOM_BLOCK;
+
+cmark_syntax_extension *create_qfm_custom_block_extension(void);
+
+#endif