github-markdown 0.1.3

data/ext/markdown/buffer.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2008, Natacha Porté
+ * Copyright (c) 2011, Vicent Martí
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef BUFFER_H__
+#define BUFFER_H__
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+#if defined(_MSC_VER)
+#define __attribute__(x)
+#define inline
+#endif
+
+typedef enum {
+	BUF_OK = 0,
+	BUF_ENOMEM = -1,
+} buferror_t;
+
+/* struct buf: character array buffer */
+struct buf {
+	uint8_t *data;		/* actual character data */
+	size_t size;	/* size of the string */
+	size_t asize;	/* allocated size (0 = volatile buffer) */
+	size_t unit;	/* reallocation unit size (0 = read-only buffer) */
+};
+
+/* CONST_BUF: global buffer from a string litteral */
+#define BUF_STATIC(string) \
+	{ (uint8_t *)string, sizeof string -1, sizeof string, 0, 0 }
+
+/* VOLATILE_BUF: macro for creating a volatile buffer on the stack */
+#define BUF_VOLATILE(strname) \
+	{ (uint8_t *)strname, strlen(strname), 0, 0, 0 }
+
+/* BUFPUTSL: optimized bufputs of a string litteral */
+#define BUFPUTSL(output, literal) \
+	bufput(output, literal, sizeof literal - 1)
+
+/* bufgrow: increasing the allocated size to the given value */
+int bufgrow(struct buf *, size_t);
+
+/* bufnew: allocation of a new buffer */
+struct buf *bufnew(size_t) __attribute__ ((malloc));
+
+/* bufnullterm: NUL-termination of the string array (making a C-string) */
+const char *bufcstr(struct buf *);
+
+/* bufprefix: compare the beginning of a buffer with a string */
+int bufprefix(const struct buf *buf, const char *prefix);
+
+/* bufput: appends raw data to a buffer */
+void bufput(struct buf *, const void *, size_t);
+
+/* bufputs: appends a NUL-terminated string to a buffer */
+void bufputs(struct buf *, const char *);
+
+/* bufputc: appends a single char to a buffer */
+void bufputc(struct buf *, int);
+
+/* bufrelease: decrease the reference count and free the buffer if needed */
+void bufrelease(struct buf *);
+
+/* bufreset: frees internal data of the buffer */
+void bufreset(struct buf *);
+
+/* bufslurp: removes a given number of bytes from the head of the array */
+void bufslurp(struct buf *, size_t);
+
+/* bufprintf: formatted printing to a buffer */
+void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
+
+#endif

data/ext/markdown/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('github/markdown')
+create_makefile('github/markdown')

data/ext/markdown/gh-markdown.c

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2012, GitHub, Inc
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#	include <ruby/encoding.h>
+#	define geefem_str_new(str, len) rb_enc_str_new(str, len, rb_utf8_encoding())
+#else
+#	define geefem_str_new(str, len) rb_str_new(str, len)
+#endif
+
+#include "markdown.h"
+#include "html.h"
+
+static struct {
+	struct sd_markdown *md;
+	struct html_renderopt render_opts; 
+} g_markdown, g_GFM;
+
+static void
+rndr_blockcode_github(
+	struct buf *ob,
+	const struct buf *text,
+	const struct buf *lang,
+	void *opaque)
+{
+	if (ob->size)
+		bufputc(ob, '\n');
+
+	if (!text || !text->size) {
+		BUFPUTSL(ob, "<pre><code></code></pre>");
+		return;
+	}
+
+	if (lang && lang->size) {
+		size_t i = 0, lang_size;
+		const char *lang_name = NULL;
+
+		while (i < lang->size && !isspace(lang->data[i]))
+			i++;
+
+		if (lang->data[0] == '.') {
+			lang_name = lang->data + 1;
+			lang_size = i - 1;
+		} else {
+			lang_name = lang->data;
+			lang_size = i;
+		}
+
+		if (rb_block_given_p()) {
+			VALUE hilight;
+
+			hilight = rb_yield_values(2,
+				geefem_str_new(text->data, text->size),
+				geefem_str_new(lang_name, lang_size));
+
+			if (!NIL_P(hilight)) {
+				Check_Type(hilight, T_STRING);
+				bufput(ob, RSTRING_PTR(hilight), RSTRING_LEN(hilight));
+				return;
+			}
+		}
+
+		BUFPUTSL(ob, "<pre lang=\"");
+		houdini_escape_html0(ob, lang_name, lang_size, 0);
+		BUFPUTSL(ob, "\"><code>");
+
+	} else {
+		BUFPUTSL(ob, "<pre><code>");
+	}
+
+	houdini_escape_html0(ob, text->data, text->size, 0);
+	BUFPUTSL(ob, "</code></pre>\n");
+}
+
+static VALUE rb_ghmd_to_html(VALUE self, VALUE rb_text, VALUE rb_mode)
+{
+	struct buf *output_buf;
+	struct sd_markdown *md = NULL;
+	ID mode;
+
+	if (NIL_P(rb_text))
+		return Qnil;
+
+	Check_Type(rb_mode, T_SYMBOL);
+	mode = SYM2ID(rb_mode);
+
+	/* check for rendering mode */
+	if (mode == rb_intern("markdown")) {
+		md = g_markdown.md;
+	} else if (mode == rb_intern("gfm")) {
+		md = g_GFM.md;
+	} else {
+		rb_raise(rb_eTypeError, "Invalid render mode");
+	}
+
+	Check_Type(rb_text, T_STRING);
+
+	/* initialize buffers */
+	output_buf = bufnew(128);
+
+	/* render the magic */
+	sd_markdown_render(output_buf, RSTRING_PTR(rb_text), RSTRING_LEN(rb_text), md);
+
+	/* build the Ruby string */
+	rb_text = geefem_str_new(output_buf->data, output_buf->size);
+
+	bufrelease(output_buf);
+	return rb_text;
+}
+
+
+/* Max recursion nesting when parsing Markdown documents */
+static const int GITHUB_MD_NESTING = 16;
+
+/* Default flags for all Markdown pipelines:
+ *
+ *	- NO_INTRA_EMPHASIS: disallow emphasis inside of words
+ *	- LAX_HTML_BLOCKS: do not require an empty line after
+ *		a HTML block, unlike Markdown.pl does
+ *	- STRIKETHROUGH: strike out words with `~~`, same semantics
+ *		as emphasis
+ *	- TABLES: the tables extension from PHP-Markdown extra
+ *	- FENCED_CODE: the fenced code blocks extension from
+ *		PHP-Markdown extra, but working with ``` besides ~~~.
+ */
+static const int GITHUB_MD_FLAGS =
+	MKDEXT_NO_INTRA_EMPHASIS |
+	MKDEXT_LAX_HTML_BLOCKS |
+	MKDEXT_STRIKETHROUGH |
+	MKDEXT_TABLES |
+	MKDEXT_FENCED_CODE;
+
+/* Init the default pipeline */
+static void rb_ghmd__init_md(void)
+{
+	struct sd_callbacks callbacks;
+
+	/* No extra flags to the Markdown renderer */
+	sdhtml_renderer(&callbacks, &g_markdown.render_opts, 0);
+	callbacks.blockcode = &rndr_blockcode_github;
+
+	g_markdown.md = sd_markdown_new(
+		GITHUB_MD_FLAGS,
+		GITHUB_MD_NESTING,
+		&callbacks,
+		&g_markdown.render_opts
+	);
+}
+
+/* Init the GFM pipeline */
+static void rb_ghmd__init_gfm(void)
+{
+	struct sd_callbacks callbacks;
+
+	/*
+	 * The following extensions to the HTML output are enabled:
+	 *
+	 *	- HARD_WRAP: line breaks are replaced with <br>
+	 *		entities 
+	 */
+	sdhtml_renderer(&callbacks, &g_GFM.render_opts, HTML_HARD_WRAP);
+	callbacks.blockcode = &rndr_blockcode_github;
+
+	/* The following extensions to the parser are enabled, on top
+	 * of the common ones:
+	 *
+	 *	- SPACE_HEADERS: require a space between the `#` and the
+	 *		name of a header (prevents collisions with the Issues
+	 *		filter)
+	 */
+	g_GFM.md = sd_markdown_new(
+		GITHUB_MD_FLAGS | MKDEXT_SPACE_HEADERS,
+		GITHUB_MD_NESTING,
+		&callbacks,
+		&g_GFM.render_opts
+	);
+}
+
+void Init_markdown()
+{
+	VALUE rb_mGitHub = rb_const_get(rb_cObject, rb_intern("GitHub"));
+	VALUE rb_cMarkdown = rb_define_class_under(rb_mGitHub, "Markdown", rb_cObject);
+
+    rb_define_singleton_method(rb_cMarkdown, "to_html", rb_ghmd_to_html, 2);
+
+	rb_ghmd__init_md();
+	rb_ghmd__init_gfm();
+}
+

data/ext/markdown/houdini.h

@@ -0,0 +1,29 @@
+#ifndef HOUDINI_H__
+#define HOUDINI_H__
+
+#include "buffer.h"
+
+#ifdef HOUDINI_USE_LOCALE
+#	define _isxdigit(c) isxdigit(c)
+#	define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#	define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#	define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+extern void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure);
+extern void houdini_unescape_html(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_xml(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_uri(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_url(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_unescape_uri(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_unescape_url(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_escape_js(struct buf *ob, const uint8_t *src, size_t size);
+extern void houdini_unescape_js(struct buf *ob, const uint8_t *src, size_t size);
+
+#endif

data/ext/markdown/houdini_href_e.c

@@ -0,0 +1,108 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+#define ESCAPE_GROW_FACTOR(x) (((x) * 12) / 10)
+
+/*
+ * The following characters will not be escaped:
+ *
+ *		-_.+!*'(),%#@?=;:/,+&$ alphanum
+ *
+ * Note that this character set is the addition of:
+ *
+ *	- The characters which are safe to be in an URL
+ *	- The characters which are *not* safe to be in
+ *	an URL because they are RESERVED characters.
+ *
+ * We asume (lazily) that any RESERVED char that
+ * appears inside an URL is actually meant to
+ * have its native function (i.e. as an URL 
+ * component/separator) and hence needs no escaping.
+ *
+ * There are two exceptions: the chacters & (amp)
+ * and ' (single quote) do not appear in the table.
+ * They are meant to appear in the URL as components,
+ * yet they require special HTML-entity escaping
+ * to generate valid HTML markup.
+ *
+ * All other characters will be escaped to %XX.
+ *
+ */
+static const char HREF_SAFE[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+void
+houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size)
+{
+	static const char hex_chars[] = "0123456789ABCDEF";
+	size_t  i = 0, org;
+	char hex_str[3];
+
+	bufgrow(ob, ESCAPE_GROW_FACTOR(size));
+	hex_str[0] = '%';
+
+	while (i < size) {
+		org = i;
+		while (i < size && HREF_SAFE[src[i]] != 0)
+			i++;
+
+		if (i > org)
+			bufput(ob, src + org, i - org);
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		switch (src[i]) {
+		/* amp appears all the time in URLs, but needs
+		 * HTML-entity escaping to be inside an href */
+		case '&': 
+			BUFPUTSL(ob, "&amp;");
+			break;
+
+		/* the single quote is a valid URL character
+		 * according to the standard; it needs HTML
+		 * entity escaping too */
+		case '\'':
+			BUFPUTSL(ob, "&#x27;");
+			break;
+		
+		/* the space can be escaped to %20 or a plus
+		 * sign. we're going with the generic escape
+		 * for now. the plus thing is more commonly seen
+		 * when building GET strings */
+#if 0
+		case ' ':
+			bufputc(ob, '+');
+			break;
+#endif
+
+		/* every other character goes with a %XX escaping */
+		default:
+			hex_str[1] = hex_chars[(src[i] >> 4) & 0xF];
+			hex_str[2] = hex_chars[src[i] & 0xF];
+			bufput(ob, hex_str, 3);
+		}
+
+		i++;
+	}
+}

data/ext/markdown/houdini_html_e.c

@@ -0,0 +1,84 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+#define ESCAPE_GROW_FACTOR(x) (((x) * 12) / 10) /* this is very scientific, yes */
+
+/**
+ * According to the OWASP rules:
+ *
+ * & --> &amp;
+ * < --> &lt;
+ * > --> &gt;
+ * " --> &quot;
+ * ' --> &#x27;     &apos; is not recommended
+ * / --> &#x2F;     forward slash is included as it helps end an HTML entity
+ *
+ */
+static const char HTML_ESCAPE_TABLE[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const char *HTML_ESCAPES[] = {
+        "",
+        "&quot;",
+        "&amp;",
+        "&#39;",
+        "&#47;",
+        "&lt;",
+        "&gt;"
+};
+
+void
+houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure)
+{
+	size_t i = 0, org, esc = 0;
+
+	bufgrow(ob, ESCAPE_GROW_FACTOR(size));
+
+	while (i < size) {
+		org = i;
+		while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0)
+			i++;
+
+		if (i > org)
+			bufput(ob, src + org, i - org);
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		/* The forward slash is only escaped in secure mode */
+		if (src[i] == '/' && !secure) {
+			bufputc(ob, '/');
+		} else {
+			bufputs(ob, HTML_ESCAPES[esc]);
+		}
+
+		i++;
+	}
+}
+
+void
+houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size)
+{
+	houdini_escape_html0(ob, src, size, 1);
+}
+