commonmarker 0.2.1 → 0.3.0

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

@@ -2,12 +2,13 @@
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
-
+#include "cmark_ctype.h"
 #include "config.h"
 #include "cmark.h"
 #include "node.h"
 #include "buffer.h"
 #include "houdini.h"
+#include "scanners.h"
 
 // Functions to convert cmark_nodes to HTML strings.
 
@@ -156,7 +157,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 		} else {
 			bufsize_t first_tag = 0;
 			while (first_tag < node->as.code.info.len &&
-			       node->as.code.info.data[first_tag] != ' ') {
+			       !cmark_isspace(node->as.code.info.data[first_tag])) {
 				first_tag += 1;
 			}
 
@@ -174,7 +175,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 
 	case CMARK_NODE_HTML:
 		cr(html);
-		cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+		if (options & CMARK_OPT_SAFE) {
+			cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+		} else {
+			cmark_strbuf_put(html, node->as.literal.data,
+			                 node->as.literal.len);
+		}
+		cr(html);
 		break;
 
 	case CMARK_NODE_HRULE:
@@ -228,7 +235,12 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 		break;
 
 	case CMARK_NODE_INLINE_HTML:
-		cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+		if (options & CMARK_OPT_SAFE) {
+			cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+		} else {
+			cmark_strbuf_put(html, node->as.literal.data,
+			                 node->as.literal.len);
+		}
 		break;
 
 	case CMARK_NODE_STRONG:
@@ -250,15 +262,19 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 	case CMARK_NODE_LINK:
 		if (entering) {
 			cmark_strbuf_puts(html, "<a href=\"");
-			houdini_escape_href(html, node->as.link.url.data,
-			                    node->as.link.url.len);
+			if (!((options & CMARK_OPT_SAFE) &&
+			      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,
+				escape_html(html,
+				            node->as.link.title.data,
 				            node->as.link.title.len);
 			}
-
 			cmark_strbuf_puts(html, "\">");
 		} else {
 			cmark_strbuf_puts(html, "</a>");
@@ -268,9 +284,13 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 	case CMARK_NODE_IMAGE:
 		if (entering) {
 			cmark_strbuf_puts(html, "<img src=\"");
-			houdini_escape_href(html, node->as.link.url.data,
-			                    node->as.link.url.len);
+			if (!((options & CMARK_OPT_SAFE) &&
+			      scan_dangerous_url(&node->as.link.url, 0))) {
+				houdini_escape_href(html,
+				                    node->as.link.url.data,
+				                    node->as.link.url.len);
 
+			}
 			cmark_strbuf_puts(html, "\" alt=\"");
 			state->plain = node;
 		} else {

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

@@ -65,46 +65,6 @@ static void subject_from_buf(subject *e, cmark_strbuf *buffer,
                              cmark_reference_map *refmap);
 static bufsize_t subject_find_special_char(subject *subj, int options);
 
-static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email)
-{
-	cmark_strbuf buf = GH_BUF_INIT;
-
-	cmark_chunk_trim(url);
-
-	if (url->len == 0) {
-		cmark_chunk result = CMARK_CHUNK_EMPTY;
-		return result;
-	}
-
-	if (is_email)
-		cmark_strbuf_puts(&buf, "mailto:");
-
-	houdini_unescape_html_f(&buf, url->data, url->len);
-	return cmark_chunk_buf_detach(&buf);
-}
-
-static inline cmark_node *make_link(cmark_node *label, cmark_chunk *url, cmark_chunk *title)
-{
-	cmark_node* e = (cmark_node *)calloc(1, sizeof(*e));
-	if(e != NULL) {
-		e->type = CMARK_NODE_LINK;
-		e->first_child   = label;
-		e->last_child    = label;
-		e->as.link.url   = *url;
-		e->as.link.title = *title;
-		e->next = NULL;
-		label->parent = e;
-	}
-	return e;
-}
-
-static inline cmark_node* make_autolink(cmark_node* label, cmark_chunk url, int is_email)
-{
-	cmark_chunk clean_url = cmark_clean_autolink(&url, is_email);
-	cmark_chunk title = CMARK_CHUNK_EMPTY;
-	return make_link(label, &clean_url, &title);
-}
-
 // Create an inline with a literal string value.
 static inline cmark_node* make_literal(cmark_node_type t, cmark_chunk s)
 {
@@ -144,6 +104,18 @@ static inline cmark_node* make_simple(cmark_node_type t)
 	return e;
 }
 
+// Like make_str, but parses entities.
+static cmark_node *make_str_with_entities(cmark_chunk *content)
+{
+	cmark_strbuf unescaped = GH_BUF_INIT;
+
+	if (houdini_unescape_html(&unescaped, content->data, content->len)) {
+		return make_str(cmark_chunk_buf_detach(&unescaped));
+	} else {
+		return make_str(*content);
+	}
+}
+
 // Duplicate a chunk by creating a copy of the buffer not by reusing the
 // buffer like cmark_chunk_dup does.
 static cmark_chunk chunk_clone(cmark_chunk *src)
@@ -160,6 +132,33 @@ static cmark_chunk chunk_clone(cmark_chunk *src)
 	return c;
 }
 
+static cmark_chunk cmark_clean_autolink(cmark_chunk *url, int is_email)
+{
+	cmark_strbuf buf = GH_BUF_INIT;
+
+	cmark_chunk_trim(url);
+
+	if (url->len == 0) {
+		cmark_chunk result = CMARK_CHUNK_EMPTY;
+		return result;
+	}
+
+	if (is_email)
+		cmark_strbuf_puts(&buf, "mailto:");
+
+	houdini_unescape_html_f(&buf, url->data, url->len);
+	return cmark_chunk_buf_detach(&buf);
+}
+
+static inline cmark_node* make_autolink(cmark_chunk url, int is_email)
+{
+	cmark_node *link = make_simple(CMARK_NODE_LINK);
+	link->as.link.url   = cmark_clean_autolink(&url, is_email);
+	link->as.link.title = cmark_chunk_literal("");
+	cmark_node_append_child(link, make_str_with_entities(&url));
+	return link;
+}
+
 static void subject_from_buf(subject *e, cmark_strbuf *buffer,
                              cmark_reference_map *refmap)
 {
@@ -437,18 +436,45 @@ static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart)
 // Assumes we have a hyphen at the current position.
 static cmark_node* handle_hyphen(subject* subj, bool smart)
 {
+	int startpos = subj->pos;
+
 	advance(subj);
-	if (smart && peek_char(subj) == '-') {
-		advance(subj);
-		if (peek_char(subj) == '-') {
-			advance(subj);
-			return make_str(cmark_chunk_literal(EMDASH));
-		} else {
-			return make_str(cmark_chunk_literal(ENDASH));
-		}
-	} else {
+
+	if (!smart || peek_char(subj) != '-') {
 		return make_str(cmark_chunk_literal("-"));
 	}
+
+	while (smart && peek_char(subj) == '-') {
+		advance(subj);
+	}
+
+	int numhyphens = subj->pos - startpos;
+	int en_count = 0;
+	int em_count = 0;
+	int i;
+	cmark_strbuf buf = GH_BUF_INIT;
+
+	if (numhyphens % 3 == 0) { // if divisible by 3, use all em dashes
+		em_count = numhyphens / 3;
+	} else if (numhyphens % 2 == 0) { // if divisible by 2, use all en dashes
+		en_count = numhyphens / 2;
+	} else if (numhyphens % 3 == 2) { // use one en dash at end
+		en_count = 1;
+		em_count = (numhyphens - 2) / 3;
+	} else { // use two en dashes at the end
+		en_count = 2;
+		em_count = (numhyphens - 4) / 3;
+	}
+
+	for (i = em_count; i > 0; i--) {
+		cmark_strbuf_puts(&buf, EMDASH);
+	}
+
+	for (i = en_count; i > 0; i--) {
+		cmark_strbuf_puts(&buf, ENDASH);
+	}
+
+	return make_str(cmark_chunk_buf_detach(&buf));
 }
 
 // Assumes we have a period at the current position.
@@ -593,7 +619,8 @@ S_insert_emph(subject *subj, delimiter *opener, delimiter *closer)
 		// replace empty opener inline with emph
 		cmark_chunk_free(&(opener_inl->as.literal));
 		emph = opener_inl;
-		emph->type = use_delims == 1 ? NODE_EMPH : NODE_STRONG;
+		emph->type = use_delims == 1 ?
+			CMARK_NODE_EMPH : CMARK_NODE_STRONG;
 		// remove opener from list
 		remove_delimiter(subj, opener);
 	} else {
@@ -667,19 +694,6 @@ static cmark_node* handle_entity(subject* subj)
 	return make_str(cmark_chunk_buf_detach(&ent));
 }
 
-// Like make_str, but parses entities.
-// Returns an inline sequence consisting of str and entity elements.
-static cmark_node *make_str_with_entities(cmark_chunk *content)
-{
-	cmark_strbuf unescaped = GH_BUF_INIT;
-
-	if (houdini_unescape_html(&unescaped, content->data, content->len)) {
-		return make_str(cmark_chunk_buf_detach(&unescaped));
-	} else {
-		return make_str(*content);
-	}
-}
-
 // Clean a URL: remove surrounding whitespace and surrounding <>,
 // and remove \ that escape punctuation.
 cmark_chunk cmark_clean_url(cmark_chunk *url)
@@ -744,10 +758,7 @@ static cmark_node* handle_pointy_brace(subject* subj)
 		contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
 		subj->pos += matchlen;
 
-		return make_autolink(
-		           make_str_with_entities(&contents),
-		           contents, 0
-		       );
+		return make_autolink(contents, 0);
 	}
 
 	// next try to match an email autolink
@@ -756,10 +767,7 @@ static cmark_node* handle_pointy_brace(subject* subj)
 		contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1);
 		subj->pos += matchlen;
 
-		return make_autolink(
-		           make_str_with_entities(&contents),
-		           contents, 1
-		       );
+		return make_autolink(contents, 1);
 	}
 
 	// finally, try to match an html tag
@@ -934,7 +942,7 @@ noMatch:
 
 match:
 	inl = opener->inl_text;
-	inl->type = is_image ? NODE_IMAGE : NODE_LINK;
+	inl->type = is_image ? CMARK_NODE_IMAGE : CMARK_NODE_LINK;
 	cmark_chunk_free(&inl->as.literal);
 	inl->first_child = link_text;
 	process_emphasis(subj, opener);

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

@@ -0,0 +1,430 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "render.h"
+
+#define safe_strlen(s) cmark_strbuf_safe_strlen(s)
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+
+static inline void outc(cmark_renderer *renderer,
+                        cmark_escaping escape,
+                        int32_t c,
+                        unsigned char nextc)
+{
+	if (escape == LITERAL) {
+		cmark_render_code_point(renderer, c);
+		return;
+	}
+
+	switch(c) {
+	case 123: // '{'
+	case 125: // '}'
+	case 35: // '#'
+	case 37: // '%'
+	case 38: // '&'
+		cmark_render_ascii(renderer, "\\");
+		cmark_render_code_point(renderer, c);
+		break;
+	case 36: // '$'
+	case 95: // '_'
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "\\");
+		}
+		cmark_render_code_point(renderer, c);
+		break;
+	case 45 : // '-'
+		if (nextc == 45) { // prevent ligature
+			cmark_render_ascii(renderer, "\\-");
+		} else {
+			cmark_render_ascii(renderer, "-");
+		}
+		break;
+	case 126: // '~'
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "\\textasciitilde{}");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 94: // '^'
+		cmark_render_ascii(renderer, "\\^{}");
+		break;
+	case 92: // '\\'
+		if (escape == URL) {
+			// / acts as path sep even on windows:
+			cmark_render_ascii(renderer, "/");
+		} else {
+			cmark_render_ascii(renderer, "\\textbackslash{}");
+		}
+		break;
+	case 124: // '|'
+		cmark_render_ascii(renderer, "\\textbar{}");
+		break;
+	case 60: // '<'
+		cmark_render_ascii(renderer, "\\textless{}");
+		break;
+	case 62: // '>'
+		cmark_render_ascii(renderer, "\\textgreater{}");
+		break;
+	case 91: // '['
+	case 93: // ']'
+		cmark_render_ascii(renderer, "{");
+		cmark_render_code_point(renderer, c);
+		cmark_render_ascii(renderer, "}");
+		break;
+	case 34: // '"'
+		cmark_render_ascii(renderer, "\\textquotedbl{}");
+		// requires \usepackage[T1]{fontenc}
+		break;
+	case 39: // '\''
+		cmark_render_ascii(renderer, "\\textquotesingle{}");
+		// requires \usepackage{textcomp}
+		break;
+	case 160: // nbsp
+		cmark_render_ascii(renderer, "~");
+		break;
+	case 8230: // hellip
+		cmark_render_ascii(renderer, "\\ldots{}");
+		break;
+	case 8216: // lsquo
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "`");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 8217: // rsquo
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "\'");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 8220: // ldquo
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "``");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 8221: // rdquo
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "''");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 8212: // emdash
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "---");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	case 8211: // endash
+		if (escape == NORMAL) {
+			cmark_render_ascii(renderer, "--");
+		} else {
+			cmark_render_code_point(renderer, c);
+		}
+		break;
+	default:
+		cmark_render_code_point(renderer, c);
+	}
+}
+
+typedef enum  {
+	NO_LINK,
+	URL_AUTOLINK,
+	EMAIL_AUTOLINK,
+	NORMAL_LINK
+} link_type;
+
+static link_type
+get_link_type(cmark_node *node)
+{
+	size_t title_len, url_len;
+	cmark_node *link_text;
+	char *realurl;
+	int realurllen;
+	bool isemail = false;
+
+	if (node->type != CMARK_NODE_LINK) {
+		return NO_LINK;
+	}
+
+	const char* url = cmark_node_get_url(node);
+	cmark_chunk url_chunk = cmark_chunk_literal(url);
+
+	url_len = safe_strlen(url);
+	if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
+		return NO_LINK;
+	}
+
+	const char* title = cmark_node_get_title(node);
+	title_len = safe_strlen(title);
+	// if it has a title, we can't treat it as an autolink:
+	if (title_len > 0) {
+		return NORMAL_LINK;
+	}
+
+	link_text = node->first_child;
+	cmark_consolidate_text_nodes(link_text);
+	realurl = (char*)url;
+	realurllen = url_len;
+	if (strncmp(realurl, "mailto:", 7) == 0) {
+		realurl += 7;
+		realurllen -= 7;
+		isemail = true;
+	}
+	if (realurllen == link_text->as.literal.len &&
+	    strncmp(realurl,
+	            (char*)link_text->as.literal.data,
+	            link_text->as.literal.len) == 0) {
+		if (isemail) {
+			return EMAIL_AUTOLINK;
+		} else {
+			return URL_AUTOLINK;
+		}
+	} else {
+		return NORMAL_LINK;
+	}
+}
+
+static int
+S_get_enumlevel(cmark_node *node)
+{
+	int enumlevel = 0;
+	cmark_node *tmp = node;
+	while (tmp) {
+		if (tmp->type == CMARK_NODE_LIST &&
+		    cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) {
+			enumlevel++;
+		}
+		tmp = tmp->parent;
+	}
+	return enumlevel;
+}
+
+static int
+S_render_node(cmark_renderer *renderer,
+              cmark_node *node,
+              cmark_event_type ev_type,
+              int options)
+{
+	int list_number;
+	char list_number_string[20];
+	bool entering = (ev_type == CMARK_EVENT_ENTER);
+	cmark_list_type list_type;
+	const char* roman_numerals[] = { "", "i", "ii", "iii", "iv", "v",
+	                                 "vi", "vii", "viii", "ix", "x"
+	                               };
+
+	// avoid warning about unused parameter:
+	(void)(options);
+
+	switch (node->type) {
+	case CMARK_NODE_DOCUMENT:
+		break;
+
+	case CMARK_NODE_BLOCK_QUOTE:
+		if (entering) {
+			LIT("\\begin{quote}");
+			CR();
+		} else {
+			LIT("\\end{quote}");
+			BLANKLINE();
+		}
+		break;
+
+	case CMARK_NODE_LIST:
+		list_type = cmark_node_get_list_type(node);
+		if (entering) {
+			LIT("\\begin{");
+			LIT(list_type == CMARK_ORDERED_LIST ?
+			    "enumerate" : "itemize");
+			LIT("}");
+			CR();
+			list_number = cmark_node_get_list_start(node);
+			if (list_number > 1) {
+				sprintf(list_number_string,
+				        "%d", list_number);
+				LIT("\\setcounter{enum");
+				LIT((char *)roman_numerals[S_get_enumlevel(node)]);
+				LIT("}{");
+				OUT(list_number_string, false, NORMAL);
+				LIT("}");
+				CR();
+			}
+		} else {
+			LIT("\\end{");
+			LIT(list_type == CMARK_ORDERED_LIST ?
+			    "enumerate" : "itemize");
+			LIT("}");
+			BLANKLINE();
+		}
+		break;
+
+	case CMARK_NODE_ITEM:
+		if (entering) {
+			LIT("\\item ");
+		} else {
+			CR();
+		}
+		break;
+
+	case CMARK_NODE_HEADER:
+		if (entering) {
+			switch (cmark_node_get_header_level(node)) {
+			case 1:
+				LIT("\\section");
+				break;
+			case 2:
+				LIT("\\subsection");
+				break;
+			case 3:
+				LIT("\\subsubsection");
+				break;
+			case 4:
+				LIT("\\paragraph");
+				break;
+			case 5:
+				LIT("\\subparagraph");
+				break;
+			}
+			LIT("{");
+		} else {
+			LIT("}");
+			BLANKLINE();
+		}
+		break;
+
+	case CMARK_NODE_CODE_BLOCK:
+		CR();
+		LIT("\\begin{verbatim}");
+		CR();
+		OUT(cmark_node_get_literal(node), false, LITERAL);
+		CR();
+		LIT("\\end{verbatim}");
+		BLANKLINE();
+		break;
+
+	case CMARK_NODE_HTML:
+		break;
+
+	case CMARK_NODE_HRULE:
+		BLANKLINE();
+		LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
+		BLANKLINE();
+		break;
+
+	case CMARK_NODE_PARAGRAPH:
+		if (!entering) {
+			BLANKLINE();
+		}
+		break;
+
+	case CMARK_NODE_TEXT:
+		OUT(cmark_node_get_literal(node), true, NORMAL);
+		break;
+
+	case CMARK_NODE_LINEBREAK:
+		LIT("\\\\");
+		CR();
+		break;
+
+	case CMARK_NODE_SOFTBREAK:
+		if (renderer->width == 0) {
+			CR();
+		} else {
+			OUT(" ", true, NORMAL);
+		}
+		break;
+
+	case CMARK_NODE_CODE:
+		LIT("\\texttt{");
+		OUT(cmark_node_get_literal(node), false, NORMAL);
+		LIT("}");
+		break;
+
+	case CMARK_NODE_INLINE_HTML:
+		break;
+
+	case CMARK_NODE_STRONG:
+		if (entering) {
+			LIT("\\textbf{");
+		} else {
+			LIT("}");
+		}
+		break;
+
+	case CMARK_NODE_EMPH:
+		if (entering) {
+			LIT("\\emph{");
+		} else {
+			LIT("}");
+		}
+		break;
+
+	case CMARK_NODE_LINK:
+		if (entering) {
+			const char* url = cmark_node_get_url(node);
+			// requires \usepackage{hyperref}
+			switch(get_link_type(node)) {
+			case URL_AUTOLINK:
+				LIT("\\url{");
+				OUT(url, false, URL);
+				break;
+			case EMAIL_AUTOLINK:
+				LIT("\\href{");
+				OUT(url, false, URL);
+				LIT("}\\nolinkurl{");
+				break;
+			case NORMAL_LINK:
+				LIT("\\href{");
+				OUT(url, false, URL);
+				LIT("}{");
+				break;
+			case NO_LINK:
+				LIT("{");  // error?
+			}
+		} else {
+			LIT("}");
+		}
+
+		break;
+
+	case CMARK_NODE_IMAGE:
+		if (entering) {
+			LIT("\\protect\\includegraphics{");
+			// requires \include{graphicx}
+			OUT(cmark_node_get_url(node), false, URL);
+			LIT("}");
+			return 0;
+		}
+		break;
+
+	default:
+		assert(false);
+		break;
+	}
+
+	return 1;
+}
+
+char *cmark_render_latex(cmark_node *root, int options, int width)
+{
+	return cmark_render(root, options, width, outc, S_render_node);
+}