qiita_marker 0.23.2.0 → 0.23.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4222f9db082f683cdabb0d9d42a255ab4b689fe19cdb178efe4feccea10439d
-  data.tar.gz: 49e29b6cee35cb99e550f65ed830e6cd83448c7b058c09c3383c97722df86b5c
+  metadata.gz: '0579157ad4abb4038246ef4dc4752fd1de6cd281daa619b2ef42adec5b147982'
+  data.tar.gz: c671815ff61ab460fcf6c3a42a614018a250c62ceaa41ee0aa3e899f34c12b16
 SHA512:
-  metadata.gz: c74fe17ddee587a42758795f9a9ff9bd5982b7c284a247615af864e6fdad8dd1b6708b55eadbec2b9eaf893e3d9eeb5e03c72d62da78598322b90d01adc8cc84
-  data.tar.gz: f8180555767d3aa6134f7dae895d06fdda9f4b655d41d6872b6234dbe073787debd4fd0b6956da261f149b28d821d95c6e0b947e7049307a92267205e24a5a9c
+  metadata.gz: 32f16ce193b82d6a7214c851fdd81126d42d872fdd4508b798ccfc4faba4668793274f88f9ef25e61ae57545041d1062c65169b05cd756eec55df0aa042d0140
+  data.tar.gz: da050452749a3eee8d998db24aa45d6a8b1a282672283e427f8deca374405bfaebe572e954c7906ceb84bea2ff08ad737da05707b2ed5d378158d2738ac0e318

data/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2021 Increments Inc.
+Copyright 2021 Qiita Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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,27 @@ 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. |
+
+#### Render options
+
+| Name | Description |
+| --- | --- |
+| `:CODE_DATA_METADATA` | Use `<code data-metadata>` for fenced code blocks. |
+| `:MENTION_NO_EMPHASIS` | Prevent parsing mentions as emphasis. |
+
+### 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 +66,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/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, first_tag);
+        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,19 @@
+#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)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/qiita_marker/qfm_custom_block.c

@@ -0,0 +1,278 @@
+#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);
+
+  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
+    return
+        // Block
+        child_type == CMARK_NODE_LIST || child_type == CMARK_NODE_PARAGRAPH ||
+        // Inline
+        child_type == CMARK_NODE_TEXT || child_type == CMARK_NODE_CODE ||
+        child_type == CMARK_NODE_HTML_INLINE || child_type == CMARK_NODE_EMPH ||
+        child_type == CMARK_NODE_STRONG || child_type == CMARK_NODE_LINK ||
+        child_type == CMARK_NODE_IMAGE ||
+        child_type == CMARK_NODE_FOOTNOTE_REFERENCE ||
+        child_type == CMARK_NODE_STRIKETHROUGH;
+  }
+
+  return 0;
+}
+
+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

data/ext/qiita_marker/qfm_mention_no_emphasis.c

@@ -0,0 +1,37 @@
+#include "cmark_ctype.h"
+#include "cmark-gfm.h"
+#include "config.h"
+
+static bool is_wordchar(char c) {
+  return cmark_isalnum(c) || c == '_' || c == '-';
+}
+
+bool is_part_of_mention(unsigned char *data, bufsize_t offset) {
+  int i;
+  int lookbehind_limit = (int)-offset;
+  char character;
+
+  for (i = 0; i >= lookbehind_limit; i--) {
+    character = data[i];
+
+    if (is_wordchar(character)) {
+      // Continue lookbehind.
+    } else if (character == '@') {
+      if (i == offset) {
+        // The "@" is at beginning of the text. (e.g. "@foo")
+        return true;
+      } else {
+        // Check if the previous character of the "@" is alphanumeric or not.
+        //   " @foo" and "あ@foo" are mentions.
+        //   "a@foo" is not a mention.
+        char prev_character = data[i - 1];
+        return !cmark_isalnum(prev_character);
+      }
+    } else {
+      // Found non-mention character, so this is not a mention.
+      return false;
+    }
+  }
+
+  return false;
+}

data/ext/qiita_marker/qfm_mention_no_emphasis.h

@@ -0,0 +1,8 @@
+#ifndef QFM_MENTION_NO_EMPHASIS
+#define QFM_MENTION_NO_EMPHASIS
+
+#include "cmark-gfm.h"
+
+bool is_part_of_mention(unsigned char *data, bufsize_t offset);
+
+#endif

data/ext/qiita_marker/qfm_scanners.c

@@ -0,0 +1,291 @@
+/* Generated by re2c 1.3 */
+
+#include "qfm_scanners.h"
+#include <stdlib.h>
+
+bufsize_t _qfm_scan_at(bufsize_t (*scanner)(const unsigned char *),
+                       unsigned char *ptr, int len, bufsize_t offset) {
+  bufsize_t res;
+
+  if (ptr == NULL || offset >= len) {
+    return 0;
+  } else {
+    unsigned char lim = ptr[len];
+
+    ptr[len] = '\0';
+    res = scanner(ptr + offset);
+    ptr[len] = lim;
+  }
+
+  return res;
+}
+
+// Scan an opening qfm_custom_block fence.
+bufsize_t _scan_open_qfm_custom_block_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0,   128, 128, 128, 128, 128, 128, 128, 128, 128, 0,   128, 128, 0,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 64,  128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+        0,   0,   0,   0,
+    };
+    yych = *p;
+    if (yych == ':')
+      goto yy4;
+    ++p;
+  yy3 : { return 0; }
+  yy4:
+    yych = *(marker = ++p);
+    if (yych != ':')
+      goto yy3;
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy7;
+    }
+  yy6:
+    p = marker;
+    goto yy3;
+  yy7:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy7;
+    }
+    if (yych <= 0xDF) {
+      if (yych <= '\f') {
+        if (yych <= 0x00)
+          goto yy6;
+        if (yych == '\n') {
+          marker = p;
+          goto yy11;
+        }
+        marker = p;
+      } else {
+        if (yych <= '\r') {
+          marker = p;
+          goto yy11;
+        }
+        if (yych <= 0x7F) {
+          marker = p;
+          goto yy9;
+        }
+        if (yych <= 0xC1)
+          goto yy6;
+        marker = p;
+        goto yy13;
+      }
+    } else {
+      if (yych <= 0xEF) {
+        if (yych <= 0xE0) {
+          marker = p;
+          goto yy14;
+        }
+        if (yych == 0xED) {
+          marker = p;
+          goto yy16;
+        }
+        marker = p;
+        goto yy15;
+      } else {
+        if (yych <= 0xF0) {
+          marker = p;
+          goto yy17;
+        }
+        if (yych <= 0xF3) {
+          marker = p;
+          goto yy18;
+        }
+        if (yych <= 0xF4) {
+          marker = p;
+          goto yy19;
+        }
+        goto yy6;
+      }
+    }
+  yy9:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy9;
+    }
+    if (yych <= 0xEC) {
+      if (yych <= 0xC1) {
+        if (yych <= 0x00)
+          goto yy6;
+        if (yych >= 0x0E)
+          goto yy6;
+      } else {
+        if (yych <= 0xDF)
+          goto yy13;
+        if (yych <= 0xE0)
+          goto yy14;
+        goto yy15;
+      }
+    } else {
+      if (yych <= 0xF0) {
+        if (yych <= 0xED)
+          goto yy16;
+        if (yych <= 0xEF)
+          goto yy15;
+        goto yy17;
+      } else {
+        if (yych <= 0xF3)
+          goto yy18;
+        if (yych <= 0xF4)
+          goto yy19;
+        goto yy6;
+      }
+    }
+  yy11:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  yy13:
+    yych = *++p;
+    if (yych <= 0x7F)
+      goto yy6;
+    if (yych <= 0xBF)
+      goto yy9;
+    goto yy6;
+  yy14:
+    yych = *++p;
+    if (yych <= 0x9F)
+      goto yy6;
+    if (yych <= 0xBF)
+      goto yy13;
+    goto yy6;
+  yy15:
+    yych = *++p;
+    if (yych <= 0x7F)
+      goto yy6;
+    if (yych <= 0xBF)
+      goto yy13;
+    goto yy6;
+  yy16:
+    yych = *++p;
+    if (yych <= 0x7F)
+      goto yy6;
+    if (yych <= 0x9F)
+      goto yy13;
+    goto yy6;
+  yy17:
+    yych = *++p;
+    if (yych <= 0x8F)
+      goto yy6;
+    if (yych <= 0xBF)
+      goto yy15;
+    goto yy6;
+  yy18:
+    yych = *++p;
+    if (yych <= 0x7F)
+      goto yy6;
+    if (yych <= 0xBF)
+      goto yy15;
+    goto yy6;
+  yy19:
+    yych = *++p;
+    if (yych <= 0x7F)
+      goto yy6;
+    if (yych <= 0x8F)
+      goto yy15;
+    goto yy6;
+  }
+}
+
+// Scan a closing qfm_custom_block fence with length at least len.
+bufsize_t _scan_close_qfm_custom_block_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+
+  {
+    unsigned char yych;
+    static const unsigned char yybm[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   128, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0,
+    };
+    yych = *p;
+    if (yych == ':')
+      goto yy24;
+    ++p;
+  yy23 : { return 0; }
+  yy24:
+    yych = *(marker = ++p);
+    if (yych != ':')
+      goto yy23;
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy27;
+    }
+  yy26:
+    p = marker;
+    goto yy23;
+  yy27:
+    yych = *++p;
+    if (yybm[0 + yych] & 64) {
+      goto yy27;
+    }
+    if (yych <= '\f') {
+      if (yych <= 0x08)
+        goto yy26;
+      if (yych <= '\t') {
+        marker = p;
+        goto yy29;
+      }
+      if (yych <= '\n') {
+        marker = p;
+        goto yy31;
+      }
+      goto yy26;
+    } else {
+      if (yych <= '\r') {
+        marker = p;
+        goto yy31;
+      }
+      if (yych != ' ')
+        goto yy26;
+      marker = p;
+    }
+  yy29:
+    yych = *++p;
+    if (yybm[0 + yych] & 128) {
+      goto yy29;
+    }
+    if (yych <= 0x08)
+      goto yy26;
+    if (yych <= '\n')
+      goto yy31;
+    if (yych != '\r')
+      goto yy26;
+  yy31:
+    ++p;
+    p = marker;
+    { return (bufsize_t)(p - start); }
+  }
+}

data/ext/qiita_marker/qfm_scanners.h

@@ -0,0 +1,20 @@
+#include "chunk.h"
+#include "cmark-gfm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bufsize_t _qfm_scan_at(bufsize_t (*scanner)(const unsigned char *),
+                       unsigned char *ptr, int len, bufsize_t offset);
+bufsize_t _scan_open_qfm_custom_block_fence(const unsigned char *p);
+bufsize_t _scan_close_qfm_custom_block_fence(const unsigned char *p);
+
+#define scan_open_qfm_custom_block_fence(c, l, n)                              \
+  _qfm_scan_at(&_scan_open_qfm_custom_block_fence, c, l, n)
+#define scan_close_qfm_custom_block_fence(c, l, n)                             \
+  _qfm_scan_at(&_scan_close_qfm_custom_block_fence, c, l, n)
+
+#ifdef __cplusplus
+}
+#endif

data/ext/qiita_marker/qfm_scanners.re

@@ -0,0 +1,50 @@
+/*!re2c re2c:flags:no-debug-info = 1; */
+/*!re2c re2c:indent:string = '  '; */
+
+#include "qfm_scanners.h"
+#include <stdlib.h>
+
+bufsize_t _qfm_scan_at(bufsize_t (*scanner)(const unsigned char *),
+                       unsigned char *ptr, int len, bufsize_t offset) {
+  bufsize_t res;
+
+  if (ptr == NULL || offset >= len) {
+    return 0;
+  } else {
+    unsigned char lim = ptr[len];
+
+    ptr[len] = '\0';
+    res = scanner(ptr + offset);
+    ptr[len] = lim;
+  }
+
+  return res;
+}
+
+/*!re2c
+  re2c:define:YYCTYPE  = "unsigned char";
+  re2c:define:YYCURSOR = p;
+  re2c:define:YYMARKER = marker;
+  re2c:define:YYCTXMARKER = marker;
+  re2c:yyfill:enable = 0;
+*/
+
+// Scan an opening qfm_custom_block fence.
+bufsize_t _scan_open_qfm_custom_block_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+  /*!re2c
+    [:]{3,} / [^:\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); }
+    * { return 0; }
+  */
+}
+
+// Scan a closing qfm_custom_block fence with length at least len.
+bufsize_t _scan_close_qfm_custom_block_fence(const unsigned char *p) {
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+  /*!re2c
+    [:]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); }
+    * { return 0; }
+  */
+}

data/lib/qiita_marker/config.rb

@@ -13,7 +13,8 @@ module QiitaMarker
         SMART: (1 << 10),
         LIBERAL_HTML_TAG: (1 << 12),
         FOOTNOTES: (1 << 13),
-        STRIKETHROUGH_DOUBLE_TILDE: (1 << 14)
+        STRIKETHROUGH_DOUBLE_TILDE: (1 << 14),
+        MENTION_NO_EMPHASIS: (1 << 26)
       }.freeze,
       render: {
         DEFAULT: 0,
@@ -28,7 +29,9 @@ module QiitaMarker
         FOOTNOTES: (1 << 13),
         STRIKETHROUGH_DOUBLE_TILDE: (1 << 14),
         TABLE_PREFER_STYLE_ATTRIBUTES: (1 << 15),
-        FULL_INFO_STRING: (1 << 16)
+        FULL_INFO_STRING: (1 << 16),
+        CODE_DATA_METADATA: (1 << 25),
+        MENTION_NO_EMPHASIS: (1 << 26)
       }.freeze,
       format: %i[html xml commonmark plaintext].freeze
     }.freeze

data/lib/qiita_marker/renderer/html_renderer.rb

@@ -94,6 +94,10 @@ module QiitaMarker
           out("<pre#{sourcepos(node)}")
           out(' lang="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
           out('><code>')
+        elsif option_enabled?(:CODE_DATA_METADATA)
+          out("<pre#{sourcepos(node)}><code")
+          out(' data-metadata="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
+          out('>')
         else
           out("<pre#{sourcepos(node)}><code")
           if node.fence_info && !node.fence_info.empty?

data/lib/qiita_marker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QiitaMarker
-  VERSION = '0.23.2.0'
+  VERSION = '0.23.2.1'
 end

data/qiita_marker.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.version = QiitaMarker::VERSION
   s.summary = 'Qiita Marker is a Ruby library for Markdown processing, based on CommonMarker.'
   s.description = 'A Ruby library that is the core module of the Qiita-specified markdown processor.'
-  s.authors = ['Increments Inc.']
+  s.authors = ['Qiita Inc.']
   s.homepage = 'https://github.com/increments/qiita_marker'
   s.license = 'MIT'
 

data/test/test_qfm_code_data_metadata.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require('test_helper')
+
+class TestQfmCodeDataMetadata < Minitest::Test
+  def setup
+    text = <<~MD
+      ```ruby:example.rb
+      puts :foo
+      ```
+    MD
+    @doc = QiitaMarker.render_doc(text, :DEFAULT, [])
+    @expected = <<~HTML
+      <pre><code data-metadata="ruby:example.rb">puts :foo
+      </code></pre>
+    HTML
+  end
+
+  def test_to_html
+    assert_equal(@expected, @doc.to_html(:CODE_DATA_METADATA))
+  end
+
+  def test_html_renderer
+    assert_equal(@expected, QiitaMarker::HtmlRenderer.new(options: :CODE_DATA_METADATA).render(@doc))
+  end
+end

data/test/test_qfm_custom_block.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require('test_helper')
+
+class TestQfmCustomBlock < Minitest::Test
+  def setup
+    text = <<~MD
+      :::foo bar
+      message
+      :::
+    MD
+    @doc = QiitaMarker.render_doc(text, :DEFAULT, %i[custom_block])
+    @expected = <<~HTML
+      <div data-type="customblock" data-metadata="foo bar">
+      <p>message</p>
+      </div>
+    HTML
+  end
+
+  def test_to_html
+    assert_equal(@expected, @doc.to_html(:DEFAULT, %i[custom_block]))
+  end
+end

data/test/test_qfm_mention_no_emphasis.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TestQfmMentionNoEmphasis < Minitest::Test
+  describe 'with mention_no_emphasis option' do
+    [
+      ['@_username_',         false],
+      ['@__username__',       false],
+      ['@___username___',     false],
+      ['@user__name__',       false],
+      ['@some__user__name__', false],
+      [' @_username_',        false],
+      ['あ@_username_', false],
+      ['A@_username_',        true],
+      ['@*username*',         true],
+      ['_foo_',               true],
+      ['_',                   false],
+      ['_foo @username_',     false],
+      ['__foo @username__',   false],
+      ['___foo @username___', false]
+    ].each do |text, emphasize|
+      describe "with text #{text.inspect}" do
+        if emphasize
+          it 'emphasizes the text' do
+            QiitaMarker.render_html(text, :MENTION_NO_EMPHASIS).tap do |out|
+              assert_match(/(<em>|<strong>)/, out.chomp)
+            end
+          end
+        else
+          it 'does not emphasize the text' do
+            QiitaMarker.render_html(text, :MENTION_NO_EMPHASIS).tap do |out|
+              assert_match "<p>#{text.strip}</p>", out.chomp
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'without mention_no_emphasis option' do
+    describe 'with text "@_username_"' do
+      text = '@_username_'
+      it 'emphasizes the text' do
+        QiitaMarker.render_html(text, :DEFAULT, %i[]).tap do |out|
+          assert_match(/<em>/, out.chomp)
+        end
+      end
+    end
+
+    describe 'with text "_foo @username_"' do
+      text = '_foo @username_'
+      it 'emphasizes the text' do
+        QiitaMarker.render_html(text, :DEFAULT, %i[]).tap do |out|
+          assert_match(/<em>/, out.chomp)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita_marker
 version: !ruby/object:Gem::Version
-  version: 0.23.2.0
+  version: 0.23.2.1
 platform: ruby
 authors:
-- Increments Inc.
+- Qiita Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-26 00:00:00.000000000 Z
+date: 2021-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -196,6 +196,14 @@ files:
 - ext/qiita_marker/plaintext.c
 - ext/qiita_marker/plugin.c
 - ext/qiita_marker/plugin.h
+- ext/qiita_marker/qfm.h
+- ext/qiita_marker/qfm_custom_block.c
+- ext/qiita_marker/qfm_custom_block.h
+- ext/qiita_marker/qfm_mention_no_emphasis.c
+- ext/qiita_marker/qfm_mention_no_emphasis.h
+- ext/qiita_marker/qfm_scanners.c
+- ext/qiita_marker/qfm_scanners.h
+- ext/qiita_marker/qfm_scanners.re
 - ext/qiita_marker/qiita_marker.c
 - ext/qiita_marker/qiita_marker.h
 - ext/qiita_marker/references.c
@@ -249,6 +257,9 @@ files:
 - test/test_options.rb
 - test/test_pathological_inputs.rb
 - test/test_plaintext.rb
+- test/test_qfm_code_data_metadata.rb
+- test/test_qfm_custom_block.rb
+- test/test_qfm_mention_no_emphasis.rb
 - test/test_renderer.rb
 - test/test_smartpunct.rb
 - test/test_spec.rb
@@ -306,6 +317,9 @@ test_files:
 - test/test_options.rb
 - test/test_pathological_inputs.rb
 - test/test_plaintext.rb
+- test/test_qfm_code_data_metadata.rb
+- test/test_qfm_custom_block.rb
+- test/test_qfm_mention_no_emphasis.rb
 - test/test_renderer.rb
 - test/test_smartpunct.rb
 - test/test_spec.rb