commonmarker 0.15.0 → 0.16.0

data/ext/commonmarker/cmark/build/testdir/cmake_install.cmake

@@ -0,0 +1,29 @@
+# Install script for directory: /Users/kivikakk/Code/gjtorikian/commonmarker/ext/commonmarker/cmark/test
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+

data/ext/commonmarker/cmark/changelog.txt

@@ -1,3 +1,10 @@
+[0.27.1.gfm.0]
+
+  * Add extensions: tagfilter, strikethrough, table, autolink.
+  * Add arena memory implementation.
+  * Add CMARK_OPT_GITHUB_PRE_LANG for fenced code blocks.
+  * Skip UTF-8 BOM on input.
+
 [0.27.1]
 
   * Set policy for CMP0063 to avoid a warning (#162).

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

@@ -39,7 +39,7 @@ if (CMARK_SHARED)
 
   set_target_properties(${LIBRARY} PROPERTIES
   OUTPUT_NAME "cmark-gfmextensions"
-  SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
+  SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.gfm.${PROJECT_VERSION_GFM}
   VERSION ${PROJECT_VERSION})
 
   set_property(TARGET ${LIBRARY}

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

@@ -632,6 +632,7 @@ cmark_syntax_extension *create_table_extension(void) {
   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, commonmark_render);
+  cmark_syntax_extension_set_plaintext_render_func(self, commonmark_render);
   cmark_syntax_extension_set_latex_render_func(self, latex_render);
   cmark_syntax_extension_set_man_render_func(self, man_render);
   cmark_syntax_extension_set_html_render_func(self, html_render);

data/ext/commonmarker/cmark/man/man3/cmark-gfm.3

@@ -1,4 +1,4 @@
-.TH cmark-gfm 3 "April 03, 2017" "LOCAL" "Library Functions Manual"
+.TH cmark-gfm 3 "May 05, 2017" "LOCAL" "Library Functions Manual"
 .SH
 NAME
 .PP
@@ -862,18 +862,6 @@ Render \f[C]softbreak\f[] elements as spaces.
 .SS
 Options affecting parsing
 
-.PP
-.nf
-\fC
-.RS 0n
-#define CMARK_OPT_NORMALIZE (1 << 8)
-.RE
-\f[]
-.fi
-
-.PP
-Normalize tree by consolidating adjacent text nodes.
-
 .PP
 .nf
 \fC

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

@@ -39,6 +39,7 @@ set(LIBRARY_SOURCES
   xml.c
   html.c
   commonmark.c
+  plaintext.c
   latex.c
   houdini_href_e.c
   houdini_html_e.c
@@ -100,7 +101,7 @@ if (CMARK_SHARED)
   # Include minor version and patch level in soname for now.
   set_target_properties(${LIBRARY} PROPERTIES
   OUTPUT_NAME "cmark-gfm"
-  SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
+  SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.gfm.${PROJECT_VERSION_GFM}
   VERSION ${PROJECT_VERSION})
 
   set_property(TARGET ${LIBRARY}

data/ext/commonmarker/cmark/src/blocks.c

@@ -1310,9 +1310,7 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
 
   finalize_document(parser);
 
-  if (parser->options & CMARK_OPT_NORMALIZE) {
-    cmark_consolidate_text_nodes(parser->root);
-  }
+  cmark_consolidate_text_nodes(parser->root);
 
   cmark_strbuf_free(&parser->curline);
   cmark_strbuf_free(&parser->linebuf);

data/ext/commonmarker/cmark/src/cmark.h

@@ -630,6 +630,18 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width);
 CMARK_EXPORT
 char *cmark_render_commonmark_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
 
+/** Render a 'node' tree as a plain text document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_plaintext(cmark_node *root, int options, int width);
+
+/** As for 'cmark_render_plaintext', but specifying the allocator to use for
+ * the resulting string.
+ */
+CMARK_EXPORT
+char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem);
+
 /** Render a 'node' tree as a LaTeX document.
  * It is the caller's responsibility to free the returned buffer.
  */
@@ -678,10 +690,6 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  * ### Options affecting parsing
  */
 
-/** Normalize tree by consolidating adjacent text nodes.
- */
-#define CMARK_OPT_NORMALIZE (1 << 8)
-
 /** Validate UTF-8 in the input before parsing, replacing illegal
  * sequences with the replacement character U+FFFD.
  */
@@ -696,6 +704,10 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  */
 #define CMARK_OPT_GITHUB_PRE_LANG (1 << 11)
 
+/** Be liberal in interpreting inline HTML tags.
+ */
+#define CMARK_OPT_LIBERAL_HTML_TAG (1 << 12)
+
 /**
  * ## Version information
  */

data/ext/commonmarker/cmark/src/cmark_extension_api.h

@@ -323,6 +323,12 @@ CMARK_EXPORT
 void cmark_syntax_extension_set_commonmark_render_func(cmark_syntax_extension *extension,
                                                        cmark_common_render_func func);
 
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_EXPORT
+void cmark_syntax_extension_set_plaintext_render_func(cmark_syntax_extension *extension,
+                                                      cmark_common_render_func func);
+
 /** See the documentation for 'cmark_syntax_extension'
  */
 CMARK_EXPORT

data/ext/commonmarker/cmark/src/cmark_version.h.in

@@ -1,7 +1,7 @@
 #ifndef CMARK_VERSION_H
 #define CMARK_VERSION_H
 
-#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8)  | @PROJECT_VERSION_PATCH@)
-#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
+#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 24) | (@PROJECT_VERSION_MINOR@ << 16) | (@PROJECT_VERSION_PATCH@ << 8) | @PROJECT_VERSION_GFM@)
+#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@.gfm.@PROJECT_VERSION_GFM@"
 
 #endif

data/ext/commonmarker/cmark/src/inlines.c

@@ -754,7 +754,7 @@ cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) {
 
 // Parse an autolink or HTML tag.
 // Assumes the subject has a '<' character at the current position.
-static cmark_node *handle_pointy_brace(subject *subj) {
+static cmark_node *handle_pointy_brace(subject *subj, bool liberal_html_tag) {
   bufsize_t matchlen = 0;
   cmark_chunk contents;
 
@@ -786,6 +786,15 @@ static cmark_node *handle_pointy_brace(subject *subj) {
     return make_raw_html(subj->mem, contents);
   }
 
+  if (liberal_html_tag) {
+    matchlen = scan_liberal_html_tag(&subj->input, subj->pos);
+    if (matchlen > 0) {
+      contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1);
+      subj->pos += matchlen;
+      return make_raw_html(subj->mem, contents);
+    }
+  }
+
   // if nothing matches, just return the opening <:
   return make_str(subj->mem, cmark_chunk_literal("<"));
 }
@@ -1139,7 +1148,7 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
     new_inl = handle_entity(subj);
     break;
   case '<':
-    new_inl = handle_pointy_brace(subj);
+    new_inl = handle_pointy_brace(subj, (options & CMARK_OPT_LIBERAL_HTML_TAG) != 0);
     break;
   case '*':
   case '_':

data/ext/commonmarker/cmark/src/main.c

@@ -24,6 +24,7 @@ typedef enum {
   FORMAT_XML,
   FORMAT_MAN,
   FORMAT_COMMONMARK,
+  FORMAT_PLAINTEXT,
   FORMAT_LATEX
 } writer_format;
 
@@ -31,7 +32,7 @@ void print_usage() {
   printf("Usage:   cmark-gfm [FILE*]\n");
   printf("Options:\n");
   printf("  --to, -t FORMAT   Specify output format (html, xml, man, "
-         "commonmark, latex)\n");
+         "commonmark, plaintext, latex)\n");
   printf("  --width WIDTH     Specify wrap width (default 0 = nowrap)\n");
   printf("  --sourcepos       Include source position attribute\n");
   printf("  --hardbreaks      Treat newlines as hard line breaks\n");
@@ -39,7 +40,6 @@ void print_usage() {
   printf("  --safe            Suppress raw HTML and dangerous URLs\n");
   printf("  --smart           Use smart punctuation\n");
   printf("  --github-pre-lang Use GitHub-style <pre lang> for code blocks\n");
-  printf("  --normalize       Consolidate adjacent text nodes\n");
   printf("  --extension, -e EXTENSION_NAME Specify an extension name to use\n");
   printf("  --list-extensions              List available extensions and quit\n");
   printf("  --help, -h        Print usage information\n");
@@ -65,6 +65,9 @@ static bool print_document(cmark_node *document, writer_format writer,
   case FORMAT_COMMONMARK:
     result = cmark_render_commonmark_with_mem(document, options, width, mem);
     break;
+  case FORMAT_PLAINTEXT:
+    result = cmark_render_plaintext_with_mem(document, options, width, mem);
+    break;
   case FORMAT_LATEX:
     result = cmark_render_latex_with_mem(document, options, width, mem);
     break;
@@ -136,10 +139,10 @@ int main(int argc, char *argv[]) {
       options |= CMARK_OPT_GITHUB_PRE_LANG;
     } else if (strcmp(argv[i], "--safe") == 0) {
       options |= CMARK_OPT_SAFE;
-    } else if (strcmp(argv[i], "--normalize") == 0) {
-      options |= CMARK_OPT_NORMALIZE;
     } else if (strcmp(argv[i], "--validate-utf8") == 0) {
       options |= CMARK_OPT_VALIDATE_UTF8;
+    } else if (strcmp(argv[i], "--liberal-html-tag") == 0) {
+      options |= CMARK_OPT_LIBERAL_HTML_TAG;
     } else if ((strcmp(argv[i], "--help") == 0) ||
                (strcmp(argv[i], "-h") == 0)) {
       print_usage();
@@ -168,6 +171,8 @@ int main(int argc, char *argv[]) {
           writer = FORMAT_XML;
         } else if (strcmp(argv[i], "commonmark") == 0) {
           writer = FORMAT_COMMONMARK;
+        } else if (strcmp(argv[i], "plaintext") == 0) {
+          writer = FORMAT_PLAINTEXT;
         } else if (strcmp(argv[i], "latex") == 0) {
           writer = FORMAT_LATEX;
         } else {

data/ext/commonmarker/cmark/src/plaintext.c

@@ -0,0 +1,212 @@
+#include "node.h"
+#include "syntax_extension.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LISTMARKER_SIZE 20
+
+// Functions to convert cmark_nodes to plain text strings.
+
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node, 
+                              cmark_escaping escape,
+                              int32_t c, unsigned char nextc) {
+  cmark_render_code_point(renderer, c);
+}
+
+// if node is a block node, returns node.
+// otherwise returns first block-level node that is an ancestor of node.
+// if there is no block-level ancestor, returns NULL.
+static cmark_node *get_containing_block(cmark_node *node) {
+  while (node) {
+    if (CMARK_NODE_BLOCK_P(node)) {
+      return node;
+    } else {
+      node = node->parent;
+    }
+  }
+  return NULL;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  cmark_delim_type list_delim;
+  int i;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  char listmarker[LISTMARKER_SIZE];
+  bool first_in_list_item;
+  bufsize_t marker_width;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) &&
+                    !(CMARK_OPT_HARDBREAKS & options);
+
+  // Don't adjust tight list status til we've started the list.
+  // Otherwise we loose the blank line between a paragraph and
+  // a following list.
+  if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL && entering)) {
+    tmp = get_containing_block(node);
+    renderer->in_tight_list_item =
+        tmp && // tmp might be NULL if there is no containing block
+        ((tmp->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent)) ||
+         (tmp && tmp->parent && tmp->parent->type == CMARK_NODE_ITEM &&
+          cmark_node_get_list_tight(tmp->parent->parent)));
+  }
+
+  if (node->extension && node->extension->plaintext_render_func) {
+    node->extension->plaintext_render_func(node->extension, renderer, node, ev_type, options);
+    return 1;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    break;
+
+  case CMARK_NODE_LIST:
+    if (!entering && node->next && (node->next->type == CMARK_NODE_CODE_BLOCK ||
+                                    node->next->type == CMARK_NODE_LIST)) {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+      marker_width = 4;
+    } else {
+      list_number = cmark_node_get_list_start(node->parent);
+      list_delim = cmark_node_get_list_delim(node->parent);
+      tmp = node;
+      while (tmp->prev) {
+        tmp = tmp->prev;
+        list_number += 1;
+      }
+      // we ensure a width of at least 4 so
+      // we get nice transition from single digits
+      // to double
+      snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
+               list_delim == CMARK_PAREN_DELIM ? ")" : ".",
+               list_number < 10 ? "  " : " ");
+      marker_width = (bufsize_t)strlen(listmarker);
+    }
+    if (entering) {
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("  - ");
+        renderer->begin_content = true;
+      } else {
+        LIT(listmarker);
+        renderer->begin_content = true;
+      }
+      for (i = marker_width; i--;) {
+        cmark_strbuf_putc(renderer->prefix, ' ');
+      }
+    } else {
+      cmark_strbuf_truncate(renderer->prefix,
+                            renderer->prefix->size - marker_width);
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      renderer->begin_content = true;
+      renderer->no_linebreaks = true;
+    } else {
+      renderer->no_linebreaks = false;
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    first_in_list_item = node->prev == NULL && node->parent &&
+                         node->parent->type == CMARK_NODE_ITEM;
+
+    if (!first_in_list_item) {
+      BLANKLINE();
+    }
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (CMARK_OPT_HARDBREAKS & options) {
+      CR();
+    } else if (!renderer->no_linebreaks && renderer->width == 0 &&
+               !(CMARK_OPT_HARDBREAKS & options) &&
+               !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    break;
+
+  case CMARK_NODE_STRONG:
+    break;
+
+  case CMARK_NODE_EMPH:
+    break;
+
+  case CMARK_NODE_LINK:
+    break;
+
+  case CMARK_NODE_IMAGE:
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_plaintext(cmark_node *root, int options, int width) {
+  return cmark_render_plaintext_with_mem(root, options, width, cmark_node_mem(root));
+}
+
+char *cmark_render_plaintext_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) {
+  if (options & CMARK_OPT_HARDBREAKS) {
+    // disable breaking on width, since it has
+    // a different meaning with OPT_HARDBREAKS
+    width = 0;
+  }
+  return cmark_render(mem, root, options, width, outc, S_render_node);
+}