github-markdown-jekyll 0.7.0

data/ext/markdown/autolink.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2011, Vicent Marti
+ *
+ * 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 UPSKIRT_AUTOLINK_H
+#define UPSKIRT_AUTOLINK_H
+
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+	SD_AUTOLINK_SHORT_DOMAINS = (1 << 0),
+};
+
+int
+sd_autolink_issafe(const uint8_t *link, size_t link_len);
+
+size_t
+sd_autolink__www(size_t *rewind_p, struct buf *link,
+	uint8_t *data, size_t offset, size_t size, unsigned int flags);
+
+size_t
+sd_autolink__email(size_t *rewind_p, struct buf *link,
+	uint8_t *data, size_t offset, size_t size, unsigned int flags);
+
+size_t
+sd_autolink__url(size_t *rewind_p, struct buf *link,
+	uint8_t *data, size_t offset, size_t size, unsigned int flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* vim: set filetype=c: */

data/ext/markdown/buffer.c

@@ -0,0 +1,225 @@
+/*
+ * 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.
+ */
+
+#define BUFFER_MAX_ALLOC_SIZE (1024 * 1024 * 16) //16mb
+
+#include "buffer.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+/* MSVC compat */
+#if defined(_MSC_VER)
+#	define _buf_vsnprintf _vsnprintf
+#else
+#	define _buf_vsnprintf vsnprintf
+#endif
+
+int
+bufprefix(const struct buf *buf, const char *prefix)
+{
+	size_t i;
+	assert(buf && buf->unit);
+
+	for (i = 0; i < buf->size; ++i) {
+		if (prefix[i] == 0)
+			return 0;
+
+		if (buf->data[i] != prefix[i])
+			return buf->data[i] - prefix[i];
+	}
+
+	return 0;
+}
+
+/* bufgrow: increasing the allocated size to the given value */
+int
+bufgrow(struct buf *buf, size_t neosz)
+{
+	size_t neoasz;
+	void *neodata;
+
+	assert(buf && buf->unit);
+
+	if (neosz > BUFFER_MAX_ALLOC_SIZE)
+		return BUF_ENOMEM;
+
+	if (buf->asize >= neosz)
+		return BUF_OK;
+
+	neoasz = buf->asize + buf->unit;
+	while (neoasz < neosz)
+		neoasz += buf->unit;
+
+	neodata = realloc(buf->data, neoasz);
+	if (!neodata)
+		return BUF_ENOMEM;
+
+	buf->data = neodata;
+	buf->asize = neoasz;
+	return BUF_OK;
+}
+
+
+/* bufnew: allocation of a new buffer */
+struct buf *
+bufnew(size_t unit)
+{
+	struct buf *ret;
+	ret = malloc(sizeof (struct buf));
+
+	if (ret) {
+		ret->data = 0;
+		ret->size = ret->asize = 0;
+		ret->unit = unit;
+	}
+	return ret;
+}
+
+/* bufnullterm: NULL-termination of the string array */
+const char *
+bufcstr(struct buf *buf)
+{
+	assert(buf && buf->unit);
+
+	if (buf->size < buf->asize && buf->data[buf->size] == 0)
+		return (char *)buf->data;
+
+	if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1) == 0) {
+		buf->data[buf->size] = 0;
+		return (char *)buf->data;
+	}
+
+	return NULL;
+}
+
+/* bufprintf: formatted printing to a buffer */
+void
+bufprintf(struct buf *buf, const char *fmt, ...)
+{
+	va_list ap;
+	int n;
+
+	assert(buf && buf->unit);
+
+	if (buf->size >= buf->asize && bufgrow(buf, buf->size + 1) < 0)
+		return;
+	
+	va_start(ap, fmt);
+	n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+	va_end(ap);
+
+	if (n < 0) {
+#ifdef _MSC_VER
+		va_start(ap, fmt);
+		n = _vscprintf(fmt, ap);
+		va_end(ap);
+#else
+		return;
+#endif
+	}
+
+	if ((size_t)n >= buf->asize - buf->size) {
+		if (bufgrow(buf, buf->size + n + 1) < 0)
+			return;
+
+		va_start(ap, fmt);
+		n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+		va_end(ap);
+	}
+
+	if (n < 0)
+		return;
+
+	buf->size += n;
+}
+
+/* bufput: appends raw data to a buffer */
+void
+bufput(struct buf *buf, const void *data, size_t len)
+{
+	assert(buf && buf->unit);
+
+	if (buf->size + len > buf->asize && bufgrow(buf, buf->size + len) < 0)
+		return;
+
+	memcpy(buf->data + buf->size, data, len);
+	buf->size += len;
+}
+
+/* bufputs: appends a NUL-terminated string to a buffer */
+void
+bufputs(struct buf *buf, const char *str)
+{
+	bufput(buf, str, strlen(str));
+}
+
+
+/* bufputc: appends a single uint8_t to a buffer */
+void
+bufputc(struct buf *buf, int c)
+{
+	assert(buf && buf->unit);
+
+	if (buf->size + 1 > buf->asize && bufgrow(buf, buf->size + 1) < 0)
+		return;
+
+	buf->data[buf->size] = c;
+	buf->size += 1;
+}
+
+/* bufrelease: decrease the reference count and free the buffer if needed */
+void
+bufrelease(struct buf *buf)
+{
+	if (!buf)
+		return;
+
+	free(buf->data);
+	free(buf);
+}
+
+
+/* bufreset: frees internal data of the buffer */
+void
+bufreset(struct buf *buf)
+{
+	if (!buf)
+		return;
+
+	free(buf->data);
+	buf->data = NULL;
+	buf->size = buf->asize = 0;
+}
+
+/* bufslurp: removes a given number of bytes from the head of the array */
+void
+bufslurp(struct buf *buf, size_t len)
+{
+	assert(buf && buf->unit);
+
+	if (len >= buf->size) {
+		buf->size = 0;
+		return;
+	}
+
+	buf->size -= len;
+	memmove(buf->data, buf->data + len, buf->size);
+}
+

data/ext/markdown/buffer.h

@@ -0,0 +1,96 @@
+/*
+ * 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>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#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)));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markdown/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+$CFLAGS << " -fvisibility=hidden "
+
+dir_config('github/markdown')
+create_makefile('github/markdown')

data/ext/markdown/gh-markdown.c

@@ -0,0 +1,225 @@
+/*
+ * 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"
+#include "plaintext.h"
+
+#define RUBY_EXPORT __attribute__ ((visibility ("default")))
+
+static struct {
+	struct sd_markdown *md;
+	struct html_renderopt render_opts; 
+} g_markdown, g_GFM, g_plaintext;
+
+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 if (mode == rb_intern("plaintext")) {
+		md = g_plaintext.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 = 32;
+
+/* Default flags for all Markdown pipelines:
+ *
+ *	- NO_INTRA_EMPHASIS: disallow emphasis inside of words
+ *	- LAX_SPACING: Do spacing like in Markdown 1.0.0 (i.e.
+ *		do not require an empty line between two different
+ *		blocks in a paragraph)
+ *	- 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 ~~~.
+ *	- AUTOLINK: Well. That. Link stuff automatically.
+ */
+static const int GITHUB_MD_FLAGS =
+	MKDEXT_NO_INTRA_EMPHASIS |
+	MKDEXT_LAX_SPACING |
+	MKDEXT_STRIKETHROUGH |
+	MKDEXT_TABLES |
+	MKDEXT_FENCED_CODE |
+	MKDEXT_AUTOLINK;
+
+/* 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
+	);
+}
+
+static void rb_ghmd__init_plaintext(void)
+{
+	struct sd_callbacks callbacks;
+
+	sdtext_renderer(&callbacks);
+	g_plaintext.md = sd_markdown_new(
+		GITHUB_MD_FLAGS,
+		GITHUB_MD_NESTING,
+		&callbacks, NULL
+	);
+}
+
+void RUBY_EXPORT 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();
+	rb_ghmd__init_plaintext();
+}
+