qiita_marker 0.23.5.0 → 0.23.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15bfc4813af77558d6c0b4ffbb931229e00d558d0c417048b636ce7c27ac31a7
-  data.tar.gz: af9febe461508838d294f9d2d20dfe896c30c467b82b50b36924040c7287c070
+  metadata.gz: b0e45d2000570d0cdf3f3c74e8b3f49936438c4183b31ce632eedbedc8bd920d
+  data.tar.gz: 3c732d6f5f94c5c575816a6866d61d1ca44e1557d320dda0215440a626064603
 SHA512:
-  metadata.gz: 2fc608ddea2a044b4c64b9f32e8dbc44cf838213f6c67e9457f36fa303b7223a20c932a261e3f21fac256ceab34d018b9c6d9757ce86eecf250a3aefa585407b
-  data.tar.gz: 66b65a1652e9a0904423490cb8999de85d21928f169f72965ca2b90bc32cfadda46193662ebdae70dea6bcb5819a349256a24911f53c65d168bd9285db107968
+  metadata.gz: 150f04fca8e8a325b3d981b67ec12a95fd489aa3eb8b08c0b50e9ac2b21c8a9797ca5b6e6b8bd26f51fc215cc3f9121ce8167c2bc78d4d93ee7020cf72db3e00
+  data.tar.gz: 439012adb32af3319165a4eeec5b19d796410b4aaddd84a0256684da172a1fc2dddf00d5175239cbbf3f9ac7d6020e8ef800afd32bdd8445b296750b0a14ffd7

data/ext/qiita_marker/autolink.c

@@ -286,6 +286,22 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
   // inline was finished in inlines.c.
 }
 
+static bool validate_protocol(char protocol[], uint8_t *data, int rewind) {
+  size_t len = strlen(protocol);
+
+  // Check that the protocol matches
+  for (int i = 1; i <= len; i++) {
+    if (data[-rewind - i] != protocol[len - i]) {
+      return false;
+    }
+  }
+
+  char prev_char = data[-rewind - len - 1];
+
+  // Make sure the character before the protocol is non-alphanumeric
+  return !cmark_isalnum(prev_char);
+}
+
 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
@@ -296,6 +312,8 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   uint8_t *data = text->as.literal.data,
     *at;
   size_t size = text->as.literal.len;
+  bool auto_mailto = true;
+  bool is_xmpp = false;
   int rewind, max_rewind,
       nb = 0, np = 0, ns = 0;
 
@@ -322,8 +340,18 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
     if (strchr(".+-_", c) != NULL)
       continue;
 
-    if (c == '/')
-      ns++;
+    if (strchr(":", c) != NULL) {
+      if (validate_protocol("mailto:", data, rewind)) {
+        auto_mailto = false;
+        continue;
+      }
+
+      if (validate_protocol("xmpp:", data, rewind)) {
+        auto_mailto = false;
+        is_xmpp = true;
+        continue;
+      }
+    }
 
     break;
   }
@@ -343,6 +371,8 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
       nb++;
     else if (c == '.' && link_end < size - 1 && cmark_isalnum(data[link_end + 1]))
       np++;
+    else if (c == '/' && is_xmpp)
+      continue;
     else if (c != '-' && c != '_')
       break;
   }
@@ -368,7 +398,8 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   }
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
-  cmark_strbuf_puts(&buf, "mailto:");
+  if (auto_mailto)
+    cmark_strbuf_puts(&buf, "mailto:");
   cmark_strbuf_put(&buf, data - rewind, (bufsize_t)(link_end + rewind));
   link_node->as.link.url = cmark_chunk_buf_detach(&buf);
 

data/ext/qiita_marker/blocks.c

@@ -22,6 +22,7 @@
 #include "houdini.h"
 #include "buffer.h"
 #include "footnotes.h"
+#include "qfm_custom_block.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -289,7 +290,9 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
     b->end_column = parser->last_line_length;
   } else if (S_type(b) == CMARK_NODE_DOCUMENT ||
              (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||
-             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) {
+             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext) ||
+             /* For make the sourcepos of the `qfm_custom_block` accurate */
+             (cmark_node_get_type(b) == CMARK_NODE_QFM_CUSTOM_BLOCK)) {
     b->end_line = parser->line_number;
     b->end_column = parser->curline.size;
     if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n')

data/ext/qiita_marker/cmark-gfm_version.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_GFM_VERSION_H
 #define CMARK_GFM_VERSION_H
 
-#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 4)
-#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.4"
+#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 6)
+#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.6"
 
 #endif

data/ext/qiita_marker/inlines.c

@@ -43,6 +43,8 @@ typedef struct bracket {
   bool image;
   bool active;
   bool bracket_after;
+  bool in_bracket_image0;
+  bool in_bracket_image1;
 } bracket;
 
 typedef struct subject{
@@ -526,6 +528,8 @@ static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
   bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket));
   if (subj->last_bracket != NULL) {
     subj->last_bracket->bracket_after = true;
+    b->in_bracket_image0 = subj->last_bracket->in_bracket_image0;
+    b->in_bracket_image1 = subj->last_bracket->in_bracket_image1;
   }
   b->image = image;
   b->active = true;
@@ -534,6 +538,11 @@ static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
   b->previous_delimiter = subj->last_delim;
   b->position = subj->pos;
   b->bracket_after = false;
+  if (image) {
+    b->in_bracket_image1 = true;
+  } else {
+    b->in_bracket_image0 = true;
+  }
   subj->last_bracket = b;
 }
 
@@ -1265,6 +1274,17 @@ match:
       }
       opener = opener->previous;
     }
+    bool in_bracket_image1 = false;
+    if (opener) {
+      in_bracket_image1 = opener->in_bracket_image1;
+    }
+    bracket *opener2 = subj->last_bracket;
+    while (opener2 != opener) {
+      if (opener2->image) {
+        opener2->in_bracket_image1 = in_bracket_image1;
+      }
+      opener2 = opener2->previous;
+    }
   }
 
   return NULL;
@@ -1674,10 +1694,15 @@ cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser) {
 }
 
 int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int image) {
-  for (bracket *b = parser->last_bracket; b; b = b->previous)
-    if (b->active && b->image == (image != 0))
-      return 1;
-  return 0;
+  bracket *b = parser->last_bracket;
+  if (!b) {
+    return 0;
+  }
+  if (image != 0) {
+    return b->in_bracket_image1;
+  } else {
+    return b->in_bracket_image0;
+  }
 }
 
 void cmark_node_unput(cmark_node *node, int n) {

data/ext/qiita_marker/qfm_custom_block.c

@@ -6,14 +6,13 @@
 #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 {
+  /* info: Text following the opening custom block fence (optional). This is
+   * trimmed of leading and trailing whitespace. */
   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,
@@ -21,33 +20,6 @@ static void escape_html(cmark_strbuf *dest, const unsigned char *source,
   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;
@@ -81,26 +53,21 @@ 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);
 }
 
+/* Now, a custom block can contain another custom block, but this behavior is
+ * not a specification. */
 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));
+  int res = 1;
+  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;
-    }
+  if (matched > 0) {
+    cmark_parser_advance_offset(parser, (char *)input, matched, 0);
+    res = 0;
   }
 
   return res;
@@ -120,21 +87,34 @@ static cmark_node *try_opening_qfm_custom_block_block(
 
     cmark_node *custom_block_node = cmark_parser_add_child(
         parser, parent_container, CMARK_NODE_QFM_CUSTOM_BLOCK,
-        parser->first_nonspace_column);
+        parser->first_nonspace + 1);
     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);
+    bufsize_t info_startpos = cmark_parser_get_first_nonspace(parser) + matched;
+
+    /* Length from after opening custom block fence to before newline character.
+     */
+    bufsize_t info_len = len - info_startpos;
+    if (info_len > 0 && input[len - 1] == '\n') {
+      info_len -= 1;
+    }
+    if (info_len > 0 && input[len - 1] == '\r') {
+      info_len -= 1;
+    }
 
-    set_qfm_custom_block_opening(custom_block_node, true);
+    cmark_strbuf_init(parser->mem, info, info_len);
+    cmark_strbuf_put(info, input + info_startpos, info_len);
+    cmark_strbuf_trim(info);
     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);
+                                cmark_parser_get_first_nonspace(parser) +
+                                    matched + info_len -
+                                    cmark_parser_get_offset(parser),
+                                0);
 
     return custom_block_node;
   }
@@ -155,12 +135,14 @@ static const char *get_type_string(cmark_syntax_extension *self,
 
 static int can_contain(cmark_syntax_extension *self, cmark_node *node,
                        cmark_node_type child_type) {
+  /* Can contain all block nodes */
   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) {
+  /* Can contain all inline nodes */
   cmark_node_type node_type = cmark_node_get_type(node);
 
   return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
@@ -210,9 +192,8 @@ static const char *xml_attr(cmark_syntax_extension *self, cmark_node *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 `"`.
@@ -220,7 +201,7 @@ static const char *xml_attr(cmark_syntax_extension *self, cmark_node *node) {
     cmark_strbuf_puts(xml_attr_buff, (char *)info->data);
     cmark_strbuf_putc(xml_attr_buff, '"');
 
-    return (char *)xml_attr_buff->ptr;
+    return (char *)cmark_strbuf_detach(xml_attr_buff);
   }
 
   return NULL;

data/lib/qiita_marker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QiitaMarker
-  VERSION = "0.23.5.0"
+  VERSION = "0.23.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qiita_marker
 version: !ruby/object:Gem::Version
-  version: 0.23.5.0
+  version: 0.23.6.0
 platform: ruby
 authors:
 - Qiita Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print