commonmarker 0.14.3 → 0.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c66dd273d46d41ebb56c7e6ca8d29eb0a447271d
-  data.tar.gz: 6d328f0fefa8996ef9842059032ddfd435d3eace
+  metadata.gz: 0e197672d34d9b8ce80830230f748a1a82dc41de
+  data.tar.gz: e43f9b677a242a8c928f0d446df6be992ce9aede
 SHA512:
-  metadata.gz: 8160c279776e983ada3e2d28d6d3317292a02fbaf3f64e24cbf24624f95641e5b38136404374190edaeebadd90222f07b9e29a5f794eee9e936a7c954dc3ce97
-  data.tar.gz: ecd7b6a1971a5bf5a6ab5d1953b26207143314610092cc884d85de5ae6a8dd3c5b07b637663a449167036af0e5e8746329922c87739ed061fd4e9c633220cdf4
+  metadata.gz: 3bf9e8dfac4bebdc8d4d15af724a93d15070730721bbba2637db42d0e12fbf0a5455cdb69c3e21043476ebe58ba7e615326af1e310c447626cc5d20bf3668684
+  data.tar.gz: cdad436d0936f904787febab5367a7633d101e2108856d2507b707a5bc475adecdb482bb7e728d4795715bf706b47e0d133364aec94ad3e1485cbc9669b5e24c

data/commonmarker.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
   s.executables = ['commonmarker']
   s.require_paths = %w(lib ext)
 
-  s.add_dependency 'ruby-enum', '~> 0.4'
+  s.add_dependency 'ruby-enum', '= 0.5.0'
 
   s.add_development_dependency 'minitest', '~> 5.6'
   s.add_development_dependency 'rake-compiler', '~> 0.9'

data/ext/commonmarker/cmark/Makefile

@@ -148,9 +148,9 @@ test: $(SPEC) cmake_build
 $(ALLTESTS): $(SPEC) $(EXTENSIONS_SPEC)
 	( \
 	  python3 test/spec_tests.py --spec $(SPEC) --dump-tests | \
-	    python3 -c 'import json; import sys; tests = json.loads(sys.stdin.read()); print("\n".join([test["markdown"] for test in tests]))'; \
+	    python3 -c 'import json; import sys; tests = json.loads(sys.stdin.read()); u8s = open(1, "w", encoding="utf-8", closefd=False); print("\n".join([test["markdown"] for test in tests]), file=u8s)'; \
 	  python3 test/spec_tests.py --spec $(EXTENSIONS_SPEC) --dump-tests | \
-	    python3 -c 'import json; import sys; tests = json.loads(sys.stdin.read()); print("\n".join([test["markdown"] for test in tests]))'; \
+	    python3 -c 'import json; import sys; tests = json.loads(sys.stdin.read()); u8s = open(1, "w", encoding="utf-8", closefd=False); print("\n".join([test["markdown"] for test in tests]), file=u8s)'; \
 	) > $@
 
 leakcheck: $(ALLTESTS)

data/ext/commonmarker/cmark/extensions/CMakeLists.txt

@@ -1,4 +1,5 @@
 cmake_minimum_required(VERSION 2.8)
+set(LIBRARY "libcmarkextensions")
 set(STATICLIBRARY "libcmarkextensions_static")
 set(LIBRARY_SOURCES
     core-extensions.c
@@ -16,6 +17,8 @@ include_directories(
   ${PROJECT_BINARY_DIR}/src
 )
 
+include (GenerateExportHeader)
+
 # We make LIB_INSTALL_DIR configurable rather than
 # hard-coding lib, because on some OSes different locations
 # are used for different architectures (e.g. /usr/lib64 on
@@ -29,22 +32,45 @@ include_directories(. ${CMAKE_CURRENT_BINARY_DIR})
 
 set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE} -pg")
 set(CMAKE_LINKER_PROFILE "${CMAKE_LINKER_FLAGS_RELEASE} -pg")
+add_compiler_export_flags()
 
-add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES})
+if (CMARK_SHARED)
+  add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES})
 
-set_target_properties(${STATICLIBRARY} PROPERTIES
-  COMPILE_FLAGS -DCMARK_STATIC_DEFINE
-  POSITION_INDEPENDENT_CODE ON)
+  set_target_properties(${LIBRARY} PROPERTIES
+  OUTPUT_NAME "cmarkextensions"
+  SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
+  VERSION ${PROJECT_VERSION})
+
+  set_property(TARGET ${LIBRARY}
+    APPEND PROPERTY MACOSX_RPATH true)
+
+  # Avoid name clash between PROGRAM and LIBRARY pdb files.
+  set_target_properties(${LIBRARY} PROPERTIES PDB_NAME cmarkextensions_dll)
+
+  list(APPEND CMARK_INSTALL ${LIBRARY})
+  target_link_libraries(${LIBRARY} libcmark)
+
+  generate_export_header(${LIBRARY} BASE_NAME cmarkextensions)
+endif()
+
+if (CMARK_STATIC)
+  add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES})
 
-if (MSVC)
-  set_target_properties(${STATICLIBRARY} PROPERTIES
-    OUTPUT_NAME "cmarkextensions_static"
-    VERSION ${PROJECT_VERSION})
-else()
   set_target_properties(${STATICLIBRARY} PROPERTIES
-    OUTPUT_NAME "cmarkextensions"
-    VERSION ${PROJECT_VERSION})
-endif(MSVC)
+    COMPILE_FLAGS -DCMARKEXTENSIONS_STATIC_DEFINE
+    POSITION_INDEPENDENT_CODE ON)
+
+  if (MSVC)
+    set_target_properties(${STATICLIBRARY} PROPERTIES
+      OUTPUT_NAME "cmarkextensions_static"
+      VERSION ${PROJECT_VERSION})
+  else()
+    set_target_properties(${STATICLIBRARY} PROPERTIES
+      OUTPUT_NAME "cmarkextensions"
+      VERSION ${PROJECT_VERSION})
+  endif(MSVC)
+endif()
 
 # Feature tests
 include(CheckIncludeFile)

data/ext/commonmarker/cmark/extensions/autolink.c

@@ -9,9 +9,8 @@
 #endif
 
 static int sd_autolink_issafe(const uint8_t *link, size_t link_len) {
-  static const size_t valid_uris_count = 5;
-  static const char *valid_uris[] = {"/", "http://", "https://", "ftp://",
-                                     "mailto:"};
+  static const size_t valid_uris_count = 3;
+  static const char *valid_uris[] = {"http://", "https://", "ftp://"};
 
   size_t i;
 
@@ -40,21 +39,9 @@ static size_t autolink_delim(uint8_t *data, size_t link_end) {
     cclose = data[link_end - 1];
 
     switch (cclose) {
-    case '"':
-      copen = '"';
-      break;
-    case '\'':
-      copen = '\'';
-      break;
     case ')':
       copen = '(';
       break;
-    case ']':
-      copen = '[';
-      break;
-    case '}':
-      copen = '{';
-      break;
     default:
       copen = 0;
     }
@@ -77,24 +64,24 @@ static size_t autolink_delim(uint8_t *data, size_t link_end) {
       size_t opening = 0;
       i = 0;
 
-      /* Try to close the final punctuation sign in this same line;
-       * if we managed to close it outside of the URL, that means that it's
-       * not part of the URL. If it closes inside the URL, that means it
-       * is part of the URL.
+      /* Allow any number of matching brackets (as recognised in copen/cclose)
+       * at the end of the URL.  If there is a greater number of closing
+       * brackets than opening ones, we remove one character from the end of
+       * the link.
        *
-       * Examples:
+       * Examples (input text => output linked portion):
        *
-       *	foo http://www.pokemon.com/Pikachu_(Electric) bar
+       *	http://www.pokemon.com/Pikachu_(Electric)
        *		=> http://www.pokemon.com/Pikachu_(Electric)
        *
-       *	foo (http://www.pokemon.com/Pikachu_(Electric)) bar
-       *		=> http://www.pokemon.com/Pikachu_(Electric)
+       *	http://www.pokemon.com/Pikachu_((Electric)
+       *		=> http://www.pokemon.com/Pikachu_((Electric)
        *
-       *	foo http://www.pokemon.com/Pikachu_(Electric)) bar
+       *	http://www.pokemon.com/Pikachu_(Electric))
        *		=> http://www.pokemon.com/Pikachu_(Electric)
        *
-       *	(foo http://www.pokemon.com/Pikachu_(Electric)) bar
-       *		=> foo http://www.pokemon.com/Pikachu_(Electric)
+       *	http://www.pokemon.com/Pikachu_((Electric))
+       *		=> http://www.pokemon.com/Pikachu_((Electric))
        */
 
       while (i < link_end) {
@@ -106,7 +93,7 @@ static size_t autolink_delim(uint8_t *data, size_t link_end) {
         i++;
       }
 
-      if (closing == opening)
+      if (closing <= opening)
         break;
 
       link_end--;
@@ -194,77 +181,6 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
   return node;
 }
 
-static cmark_node *email_match(cmark_parser *parser, cmark_node *parent,
-                               cmark_inline_parser *inline_parser) {
-  size_t link_end;
-  int rewind;
-  int nb = 0, np = 0, ns = 0;
-
-  cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
-  int max_rewind = cmark_inline_parser_get_offset(inline_parser);
-  uint8_t *data = chunk->data + max_rewind;
-  size_t size = chunk->len - max_rewind;
-
-  for (rewind = 0; rewind < max_rewind; ++rewind) {
-    uint8_t c = data[-rewind - 1];
-
-    if (cmark_isalnum(c))
-      continue;
-
-    if (strchr(".+-_", c) != NULL)
-      continue;
-
-    if (c == '/')
-      ns++;
-
-    break;
-  }
-
-  if (rewind == 0 || ns > 0)
-    return 0;
-
-  for (link_end = 0; link_end < size; ++link_end) {
-    uint8_t c = data[link_end];
-
-    if (cmark_isalnum(c))
-      continue;
-
-    if (c == '@')
-      nb++;
-    else if (c == '.' && link_end < size - 1)
-      np++;
-    else if (c != '-' && c != '_')
-      break;
-  }
-
-  if (link_end < 2 || nb != 1 || np == 0 ||
-      (!cmark_isalpha(data[link_end - 1]) && data[link_end - 1] != '.'))
-    return 0;
-
-  link_end = autolink_delim(data, link_end);
-
-  if (link_end == 0)
-    return NULL;
-
-  cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
-  cmark_node_unput(parent, rewind);
-
-  cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
-
-  cmark_strbuf buf;
-  cmark_strbuf_init(parser->mem, &buf, 10);
-  cmark_strbuf_puts(&buf, "mailto:");
-  cmark_strbuf_put(&buf, data - rewind, (bufsize_t)(link_end + rewind));
-  node->as.link.url = cmark_chunk_buf_detach(&buf);
-
-  cmark_node *text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
-  text->as.literal = cmark_chunk_dup(chunk, max_rewind - rewind,
-                                     (bufsize_t)(link_end + rewind));
-  cmark_node_append_child(node, text);
-
-  return node;
-}
-
 static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
                              cmark_inline_parser *inline_parser) {
   size_t link_end, domain_len;
@@ -326,9 +242,6 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
   if (c == ':')
     return url_match(parser, parent, inline_parser);
 
-  if (c == '@')
-    return email_match(parser, parent, inline_parser);
-
   if (c == 'w')
     return www_match(parser, parent, inline_parser);
 
@@ -339,15 +252,151 @@ 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) {
+  size_t link_end;
+  uint8_t *data = text->as.literal.data,
+    *at;
+  size_t size = text->as.literal.len;
+  int rewind, max_rewind,
+      nb = 0, np = 0, ns = 0;
+
+  if (offset < 0 || (size_t)offset >= size)
+    return;
+
+  data += offset;
+  size -= offset;
+
+  at = (uint8_t *)memchr(data, '@', size);
+  if (!at)
+    return;
+
+  max_rewind = (int)(at - data);
+  data += max_rewind;
+  size -= max_rewind;
+
+  for (rewind = 0; rewind < max_rewind; ++rewind) {
+    uint8_t c = data[-rewind - 1];
+
+    if (cmark_isalnum(c))
+      continue;
+
+    if (strchr(".+-_", c) != NULL)
+      continue;
+
+    if (c == '/')
+      ns++;
+
+    break;
+  }
+
+  if (rewind == 0 || ns > 0) {
+    postprocess_text(parser, text, max_rewind + 1 + offset);
+    return;
+  }
+
+  for (link_end = 0; link_end < size; ++link_end) {
+    uint8_t c = data[link_end];
+
+    if (cmark_isalnum(c))
+      continue;
+
+    if (c == '@')
+      nb++;
+    else if (c == '.' && link_end < size - 1)
+      np++;
+    else if (c != '-' && c != '_')
+      break;
+  }
+
+  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);
+    return;
+  }
+
+  link_end = autolink_delim(data, link_end);
+
+  if (link_end == 0) {
+    postprocess_text(parser, text, max_rewind + 1 + offset);
+    return;
+  }
+
+  cmark_chunk_to_cstr(parser->mem, &text->as.literal);
+
+  cmark_node *link_node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  cmark_strbuf buf;
+  cmark_strbuf_init(parser->mem, &buf, 10);
+  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);
+
+  cmark_node *link_text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
+  cmark_chunk email = cmark_chunk_dup(
+      &text->as.literal,
+      offset + max_rewind - rewind,
+      (bufsize_t)(link_end + rewind));
+  cmark_chunk_to_cstr(parser->mem, &email);
+  link_text->as.literal = email;
+  cmark_node_append_child(link_node, link_text);
+
+  cmark_node_insert_after(text, link_node);
+
+  cmark_node *post = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
+  post->as.literal = cmark_chunk_dup(&text->as.literal,
+    (bufsize_t)(offset + max_rewind + link_end),
+    (bufsize_t)(size - link_end));
+  cmark_chunk_to_cstr(parser->mem, &post->as.literal);
+
+  cmark_node_insert_after(link_node, post);
+
+  text->as.literal.len = offset + max_rewind - rewind;
+  text->as.literal.data[text->as.literal.len] = 0;
+
+  postprocess_text(parser, post, 0);
+}
+
+static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser, cmark_node *root) {
+  cmark_iter *iter;
+  cmark_event_type ev;
+  cmark_node *node;
+  bool in_link = false;
+
+  cmark_consolidate_text_nodes(root);
+  iter = cmark_iter_new(root);
+
+  while ((ev = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    node = cmark_iter_get_node(iter);
+    if (in_link) {
+      if (ev == CMARK_EVENT_EXIT && node->type == CMARK_NODE_LINK) {
+        in_link = false;
+      }
+      continue;
+    }
+
+    if (ev == CMARK_EVENT_ENTER && node->type == CMARK_NODE_LINK) {
+      in_link = true;
+      continue;
+    }
+
+    if (ev == CMARK_EVENT_ENTER && node->type == CMARK_NODE_TEXT) {
+      postprocess_text(parser, node, 0);
+    }
+  }
+
+  cmark_iter_free(iter);
+
+  return root;
+}
+
 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_mem *mem = cmark_get_default_mem_allocator();
   special_chars = cmark_llist_append(mem, special_chars, (void *)':');
-  special_chars = cmark_llist_append(mem, special_chars, (void *)'@');
   special_chars = cmark_llist_append(mem, special_chars, (void *)'w');
   cmark_syntax_extension_set_special_inline_chars(ext, special_chars);
 

data/ext/commonmarker/cmark/extensions/core-extensions.h

@@ -6,7 +6,9 @@ extern "C" {
 #endif
 
 #include <cmark_extension_api.h>
+#include "cmarkextensions_export.h"
 
+CMARKEXTENSIONS_EXPORT
 int core_extensions_registration(cmark_plugin *plugin);
 
 #ifdef __cplusplus

data/ext/commonmarker/cmark/extensions/strikethrough.c

@@ -7,17 +7,22 @@ static cmark_node *match(cmark_syntax_extension *self, cmark_parser *parser,
                          cmark_node *parent, unsigned char character,
                          cmark_inline_parser *inline_parser) {
   cmark_node *res = NULL;
-  int left_flanking, right_flanking, punct_before, punct_after;
+  int left_flanking, right_flanking, punct_before, punct_after, delims;
+  char buffer[101];
 
   if (character != '~')
     return NULL;
 
-  cmark_inline_parser_scan_delimiters(inline_parser, 100, '~', &left_flanking,
-                                      &right_flanking, &punct_before,
-                                      &punct_after);
+  delims = cmark_inline_parser_scan_delimiters(
+      inline_parser, sizeof(buffer) - 1, '~',
+      &left_flanking,
+      &right_flanking, &punct_before, &punct_after);
+
+  memset(buffer, '~', delims);
+  buffer[delims] = 0;
 
   res = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
-  cmark_node_set_literal(res, "~");
+  cmark_node_set_literal(res, buffer);
 
   if (left_flanking || right_flanking) {
     cmark_inline_parser_push_delimiter(inline_parser, character, left_flanking,
@@ -84,7 +89,7 @@ static int can_contain(cmark_syntax_extension *extension, cmark_node *node,
 static void commonmark_render(cmark_syntax_extension *extension,
                               cmark_renderer *renderer, cmark_node *node,
                               cmark_event_type ev_type, int options) {
-  renderer->out(renderer, cmark_node_get_string_content(node), false, LITERAL);
+  renderer->out(renderer, node, cmark_node_get_string_content(node), false, LITERAL);
 }
 
 static void latex_render(cmark_syntax_extension *extension,
@@ -93,9 +98,9 @@ static void latex_render(cmark_syntax_extension *extension,
   // requires \usepackage{ulem}
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   if (entering) {
-    renderer->out(renderer, "\\sout{", false, LITERAL);
+    renderer->out(renderer, node, "\\sout{", false, LITERAL);
   } else {
-    renderer->out(renderer, "}", false, LITERAL);
+    renderer->out(renderer, node, "}", false, LITERAL);
   }
 }
 
@@ -105,9 +110,9 @@ static void man_render(cmark_syntax_extension *extension,
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   if (entering) {
     renderer->cr(renderer);
-    renderer->out(renderer, ".ST \"", false, LITERAL);
+    renderer->out(renderer, node, ".ST \"", false, LITERAL);
   } else {
-    renderer->out(renderer, "\"", false, LITERAL);
+    renderer->out(renderer, node, "\"", false, LITERAL);
     renderer->cr(renderer);
   }
 }