redcarpet 1.17.2 → 2.0.0b

data/ext/redcarpet/markdown.h

@@ -46,6 +46,7 @@ enum mkd_extensions {
 	MKDEXT_STRIKETHROUGH = (1 << 4),
 	MKDEXT_LAX_HTML_BLOCKS = (1 << 5),
 	MKDEXT_SPACE_HEADERS = (1 << 6),
+	MKDEXT_SUPERSCRIPT = (1 << 7),
 };
 
 /* mkd_renderer • functions for rendering parsed data */
@@ -75,6 +76,7 @@ struct mkd_renderer {
 	int (*raw_html_tag)(struct buf *ob, struct buf *tag, void *opaque);
 	int (*triple_emphasis)(struct buf *ob, struct buf *text, void *opaque);
 	int (*strikethrough)(struct buf *ob, struct buf *text, void *opaque);
+	int (*superscript)(struct buf *ob, struct buf *text, void *opaque);
 
 	/* low level callbacks - NULL copies input directly into the output */
 	void (*entity)(struct buf *ob, struct buf *entity, void *opaque);
@@ -100,23 +102,17 @@ struct mkd_renderer {
 #define MKD_TABLE_ALIGN_R (1 << 1)
 #define MKD_TABLE_ALIGN_CENTER (MKD_TABLE_ALIGN_L | MKD_TABLE_ALIGN_R)
 
-/*******************
- * Auxiliar methods
- *******************/
-int
-is_safe_link(const char *link, size_t link_len);
-
 /**********************
  * EXPORTED FUNCTIONS *
  **********************/
 
-/* ups_markdown * parses the input buffer and renders it into the output buffer */
+/* sd_markdown * parses the input buffer and renders it into the output buffer */
 extern void
-ups_markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndr, unsigned int extensions);
+sd_markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndr, unsigned int extensions);
 
-/* ups_version * returns the library version as major.minor.rev */
+/* sd_version * returns the library version as major.minor.rev */
 extern void
-ups_version(int *major, int *minor, int *revision);
+sd_version(int *major, int *minor, int *revision);
 
 #endif
 

data/ext/redcarpet/rc_markdown.c

@@ -0,0 +1,108 @@
+#define RSTRING_NOT_MODIFIED
+
+#include <stdio.h>
+#include "ruby.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#else
+#define rb_enc_copy(dst, src)
+#endif
+
+#include "markdown.h"
+
+VALUE rb_mRedcarpet;
+VALUE rb_cMarkdown;
+
+extern VALUE rb_cRenderBase;
+
+static void rb_redcarpet_md_flags(VALUE ruby_obj, unsigned int *enabled_extensions_p)
+{
+	unsigned int extensions = 0;
+
+	/**
+	 * Markdown extensions -- all disabled by default 
+	 */
+	if (rb_funcall(ruby_obj, rb_intern("no_intra_emphasis"), 0) == Qtrue)
+		extensions |= MKDEXT_NO_INTRA_EMPHASIS;
+
+	if (rb_funcall(ruby_obj, rb_intern("tables"), 0) == Qtrue)
+		extensions |= MKDEXT_TABLES;
+
+	if (rb_funcall(ruby_obj, rb_intern("fenced_code_blocks"), 0) == Qtrue)
+		extensions |= MKDEXT_FENCED_CODE;
+
+	if (rb_funcall(ruby_obj, rb_intern("autolink"), 0) == Qtrue)
+		extensions |= MKDEXT_AUTOLINK;
+
+	if (rb_funcall(ruby_obj, rb_intern("strikethrough"), 0) == Qtrue)
+		extensions |= MKDEXT_STRIKETHROUGH;
+
+	if (rb_funcall(ruby_obj, rb_intern("lax_html_blocks"), 0) == Qtrue)
+		extensions |= MKDEXT_LAX_HTML_BLOCKS;
+
+	if (rb_funcall(ruby_obj, rb_intern("space_after_headers"), 0) == Qtrue)
+		extensions |= MKDEXT_SPACE_HEADERS;
+
+	if (rb_funcall(ruby_obj, rb_intern("superscript"), 0) == Qtrue)
+		extensions |= MKDEXT_SUPERSCRIPT;
+
+	*enabled_extensions_p = extensions;
+}
+
+static VALUE rb_redcarpet_md_render_with(VALUE self, VALUE rb_rndr, VALUE text)
+{
+	VALUE result;
+
+	struct mkd_renderer *renderer;
+	struct buf input_buf, *output_buf;
+	unsigned int enabled_extensions = 0;
+
+	Check_Type(text, T_STRING);
+
+	if (!rb_obj_is_kind_of(rb_rndr, rb_cRenderBase))
+		rb_raise(rb_eTypeError, "Invalid Renderer instance");
+
+	if (rb_respond_to(rb_rndr, rb_intern("preprocess")))
+		text = rb_funcall(rb_rndr, rb_intern("preprocess"), 1, text);
+
+	memset(&input_buf, 0x0, sizeof(struct buf));
+	input_buf.data = RSTRING_PTR(text);
+	input_buf.size = RSTRING_LEN(text);
+
+	output_buf = bufnew(128);
+	bufgrow(output_buf, RSTRING_LEN(text) * 1.4f);
+
+	Data_Get_Struct(rb_rndr, struct mkd_renderer, renderer);
+
+	rb_redcarpet_md_flags(self, &enabled_extensions);
+	sd_markdown(output_buf, &input_buf, renderer, enabled_extensions);
+	result = rb_str_new(output_buf->data, output_buf->size);
+	rb_enc_copy(result, text);
+
+	bufrelease(output_buf);
+
+	if (rb_respond_to(rb_rndr, rb_intern("postprocess")))
+		result = rb_funcall(rb_rndr, rb_intern("postprocess"), 1, result);
+
+	return result;
+}
+
+static VALUE rb_redcarpet_md_render(VALUE self, VALUE text)
+{
+	return rb_redcarpet_md_render_with(self, rb_iv_get(self, "@renderer"), text);
+}
+
+extern void Init_redcarpet_rndr();
+
+void Init_redcarpet()
+{
+    rb_mRedcarpet = rb_define_module("Redcarpet");
+
+	rb_cMarkdown = rb_define_class_under(rb_mRedcarpet, "Markdown", rb_cObject);
+    rb_define_method(rb_cMarkdown, "render", rb_redcarpet_md_render, 1);
+    rb_define_method(rb_cMarkdown, "render_with", rb_redcarpet_md_render_with, 2);
+
+	Init_redcarpet_rndr();
+}
+

data/ext/redcarpet/rc_render.c

@@ -0,0 +1,469 @@
+/*
+ * 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.
+ */
+
+#define RSTRING_NOT_MODIFIED
+
+#include <ruby.h>
+#include "markdown.h"
+#include "html.h"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#else
+#define rb_enc_copy(dst, src)
+#endif
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+#define SPAN_CALLBACK(method_name, ...) {\
+	struct redcarpet_pload *load = opaque;\
+	VALUE ret = rb_funcall(load->self, rb_intern(method_name), __VA_ARGS__);\
+	if (NIL_P(ret)) return 0;\
+	Check_Type(ret, T_STRING);\
+	bufput(ob, RSTRING_PTR(ret), RSTRING_LEN(ret));\
+	return 1;\
+}
+
+#define BLOCK_CALLBACK(method_name, ...) {\
+	struct redcarpet_pload *load = opaque;\
+	VALUE ret = rb_funcall(load->self, rb_intern(method_name), __VA_ARGS__);\
+	if (NIL_P(ret)) return;\
+	Check_Type(ret, T_STRING);\
+	bufput(ob, RSTRING_PTR(ret), RSTRING_LEN(ret));\
+}
+
+extern VALUE rb_mRedcarpet;
+VALUE rb_mRender;
+VALUE rb_cRenderBase;
+VALUE rb_cRenderHTML;
+VALUE rb_cRenderHTML_TOC;
+VALUE rb_mSmartyPants;
+
+struct redcarpet_pload {
+	VALUE self;
+};
+
+static inline VALUE
+buf2str(struct buf *text)
+{
+	if (!text || !text->size) return Qnil;
+	return rb_str_new(text->data, text->size);
+}
+
+
+static void
+rndr_blockcode(struct buf *ob, struct buf *text, struct buf *lang, void *opaque)
+{
+	BLOCK_CALLBACK("block_code", 2, buf2str(text), buf2str(lang));
+}
+
+static void
+rndr_blockquote(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("block_quote", 1, buf2str(text));
+}
+
+static void
+rndr_raw_block(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("block_html", 1, buf2str(text));
+}
+
+static void
+rndr_header(struct buf *ob, struct buf *text, int level, void *opaque)
+{
+	BLOCK_CALLBACK("header", 2, buf2str(text), INT2FIX(level));
+}
+
+static void
+rndr_hrule(struct buf *ob, void *opaque)
+{
+	BLOCK_CALLBACK("hrule", 0);
+}
+
+static void
+rndr_list(struct buf *ob, struct buf *text, int flags, void *opaque)
+{
+	BLOCK_CALLBACK("list", 2, buf2str(text),
+			(flags & MKD_LIST_ORDERED) ? CSTR2SYM("ordered") : CSTR2SYM("unordered"));
+}
+
+static void
+rndr_listitem(struct buf *ob, struct buf *text, int flags, void *opaque)
+{
+	BLOCK_CALLBACK("list_item", 1, buf2str(text));
+}
+
+static void
+rndr_paragraph(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("paragraph", 1, buf2str(text));
+}
+
+static void
+rndr_table(struct buf *ob, struct buf *header, struct buf *body, void *opaque)
+{
+	BLOCK_CALLBACK("table", 2, buf2str(header), buf2str(body));
+}
+
+static void
+rndr_tablerow(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("table_row", 1, buf2str(text));
+}
+
+static void
+rndr_tablecell(struct buf *ob, struct buf *text, int align, void *opaque)
+{
+	VALUE rb_align;
+
+	switch (align) {
+	case MKD_TABLE_ALIGN_L:
+		rb_align = CSTR2SYM("left");
+		break;
+
+	case MKD_TABLE_ALIGN_R:
+		rb_align = CSTR2SYM("right");
+		break;
+
+	case MKD_TABLE_ALIGN_CENTER:
+		rb_align = CSTR2SYM("center");
+		break;
+
+	default:
+		rb_align = Qnil;
+		break;
+	}
+
+	BLOCK_CALLBACK("table_cell", 2, buf2str(text), rb_align);
+}
+
+
+
+
+/***
+ * SPAN LEVEL
+ */
+static int
+rndr_autolink(struct buf *ob, struct buf *link, enum mkd_autolink type, void *opaque)
+{
+	SPAN_CALLBACK("autolink", 2, buf2str(link),
+		type == MKDA_NORMAL ? CSTR2SYM("url") : CSTR2SYM("email"));
+}
+
+static int
+rndr_codespan(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("codespan", 1, buf2str(text));
+}
+
+static int
+rndr_double_emphasis(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("double_emphasis", 1, buf2str(text));
+}
+
+static int
+rndr_emphasis(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("emphasis", 1, buf2str(text));
+}
+
+static int
+rndr_image(struct buf *ob, struct buf *link, struct buf *title, struct buf *alt, void *opaque)
+{
+	SPAN_CALLBACK("image", 3, buf2str(link), buf2str(title), buf2str(alt));
+}
+
+static int
+rndr_linebreak(struct buf *ob, void *opaque)
+{
+	SPAN_CALLBACK("linebreak", 0);
+}
+
+static int
+rndr_link(struct buf *ob, struct buf *link, struct buf *title, struct buf *content, void *opaque)
+{
+	SPAN_CALLBACK("link", 3, buf2str(link), buf2str(title), buf2str(content));
+}
+
+static int
+rndr_raw_html(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("raw_html", 1, buf2str(text));
+}
+
+static int
+rndr_triple_emphasis(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("triple_emphasis", 1, buf2str(text));
+}
+
+static int
+rndr_strikethrough(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("strikethrough", 1, buf2str(text));
+}
+
+static int
+rndr_superscript(struct buf *ob, struct buf *text, void *opaque)
+{
+	SPAN_CALLBACK("superscript", 1, buf2str(text));
+}
+
+/**
+ * direct writes
+ */
+static void
+rndr_entity(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("entity", 1, buf2str(text));
+}
+
+static void
+rndr_normal_text(struct buf *ob, struct buf *text, void *opaque)
+{
+	BLOCK_CALLBACK("normal_text", 1, buf2str(text));
+}
+
+static void
+rndr_doc_header(struct buf *ob, void *opaque)
+{
+	BLOCK_CALLBACK("doc_header", 0);
+}
+
+static void
+rndr_doc_footer(struct buf *ob, void *opaque)
+{
+	BLOCK_CALLBACK("doc_footer", 0);
+}
+
+static struct mkd_renderer rb_redcarpet_rndr = {
+	rndr_blockcode,
+	rndr_blockquote,
+	rndr_raw_block,
+	rndr_header,
+	rndr_hrule,
+	rndr_list,
+	rndr_listitem,
+	rndr_paragraph,
+	rndr_table,
+	rndr_tablerow,
+	rndr_tablecell,
+
+	rndr_autolink,
+	rndr_codespan,
+	rndr_double_emphasis,
+	rndr_emphasis,
+	rndr_image,
+	rndr_linebreak,
+	rndr_link,
+	rndr_raw_html,
+	rndr_triple_emphasis,
+	rndr_strikethrough,
+	rndr_superscript,
+
+	rndr_entity,
+	rndr_normal_text,
+
+	rndr_doc_header,
+	rndr_doc_footer,
+
+	NULL
+};
+
+static const char *rb_redcarpet_method_names[] = {
+	"block_code",
+	"block_quote",
+	"block_html",
+	"header",
+	"hrule",
+	"list",
+	"list_item",
+	"paragraph",
+	"table",
+	"table_row",
+	"table_cell",
+
+	"autolink",
+	"codespan",
+	"double_emphasis",
+	"emphasis",
+	"image",
+	"linebreak",
+	"link",
+	"raw_html",
+	"triple_emphasis",
+	"strikethrough",
+	"superscript",
+
+	"entity",
+	"normal_text",
+
+	"doc_header",
+	"doc_footer"
+};
+
+static const size_t rb_redcarpet_method_count = sizeof(rb_redcarpet_method_names)/sizeof(char *);
+
+static void rb_redcarpet_rbase_free(struct mkd_renderer *rndr)
+{
+	xfree(rndr->opaque);
+	xfree(rndr);
+}
+
+static VALUE rb_redcarpet_rbase_alloc(VALUE klass)
+{
+	struct mkd_renderer *rndr = ALLOC(struct mkd_renderer);
+	memset(rndr, 0x0, sizeof(struct mkd_renderer));
+	return Data_Wrap_Struct(klass, NULL, rb_redcarpet_rbase_free, rndr);
+}
+
+static void rb_redcarpet__overload(VALUE self)
+{
+	size_t i;
+	struct mkd_renderer *rndr;
+
+	void **source = (void **)&rb_redcarpet_rndr;
+	void **dest;
+
+	Data_Get_Struct(self, struct mkd_renderer, rndr);
+	dest = (void **)rndr;
+
+	for (i = 0; i < rb_redcarpet_method_count; ++i) {
+		if (rb_respond_to(self, rb_intern(rb_redcarpet_method_names[i])))
+			dest[i] = source[i];
+	}
+}
+
+static VALUE rb_redcarpet_rbase_init(VALUE self)
+{
+	struct mkd_renderer *rndr;
+	struct redcarpet_pload *payload;
+
+	Data_Get_Struct(self, struct mkd_renderer, rndr);
+	rb_redcarpet__overload(self);
+
+	payload = ALLOC(struct redcarpet_pload);
+	payload->self = self;
+
+	rndr->opaque = payload;
+	return Qnil;
+}
+
+static VALUE rb_redcarpet_html_init(int argc, VALUE *argv, VALUE self)
+{
+	struct mkd_renderer *rndr;
+	unsigned int render_flags = 0;
+	VALUE hash;
+
+	Data_Get_Struct(self, struct mkd_renderer, rndr);
+
+	if (rb_scan_args(argc, argv, "01", &hash) == 1)
+	{
+		Check_Type(hash, T_HASH);
+
+		/* filter_html */
+		if (rb_hash_aref(hash, CSTR2SYM("filter_html")) == Qtrue)
+			render_flags |= HTML_SKIP_HTML;
+
+		/* no_image */
+		if (rb_hash_aref(hash, CSTR2SYM("no_image")) == Qtrue)
+			render_flags |= HTML_SKIP_IMAGES;
+
+		/* no_links */
+		if (rb_hash_aref(hash, CSTR2SYM("no_links")) == Qtrue)
+			render_flags |= HTML_SKIP_LINKS;
+
+		/* filter_style */
+		if (rb_hash_aref(hash, CSTR2SYM("no_styles")) == Qtrue)
+			render_flags |= HTML_SKIP_STYLE;
+
+		/* safelink */
+		if (rb_hash_aref(hash, CSTR2SYM("safe_links_only")) == Qtrue)
+			render_flags |= HTML_SAFELINK;
+
+		if (rb_hash_aref(hash, CSTR2SYM("with_toc_data")) == Qtrue)
+			render_flags |= HTML_TOC;
+
+		if (rb_hash_aref(hash, CSTR2SYM("hard_wrap")) == Qtrue)
+			render_flags |= HTML_HARD_WRAP;
+
+		if (rb_hash_aref(hash, CSTR2SYM("xhtml")) == Qtrue)
+			render_flags |= HTML_USE_XHTML;	
+	}
+
+	sdhtml_renderer(rndr, render_flags, (void *)self);
+
+	if (rb_obj_class(self) != rb_cRenderHTML)
+		rb_redcarpet__overload(self);
+
+	return Qnil;
+}
+
+static VALUE rb_redcarpet_htmltoc_init(VALUE self)
+{
+	struct mkd_renderer *rndr;
+	Data_Get_Struct(self, struct mkd_renderer, rndr);
+
+	sdhtml_toc_renderer(rndr, (void *)self);
+
+	if (rb_obj_class(self) != rb_cRenderHTML_TOC)
+		rb_redcarpet__overload(self);
+
+	return Qnil;
+}
+
+static VALUE rb_redcarpet_smartypants_render(VALUE self, VALUE text)
+{
+	VALUE result;
+	struct buf input_buf, *output_buf;
+
+	Check_Type(text, T_STRING);
+
+	memset(&input_buf, 0x0, sizeof(struct buf));
+	input_buf.data = RSTRING_PTR(text);
+	input_buf.size = RSTRING_LEN(text);
+
+	output_buf = bufnew(128);
+	bufgrow(output_buf, RSTRING_LEN(text) * 1.1f);
+
+	sdhtml_smartypants(output_buf, &input_buf);
+	result = rb_str_new(output_buf->data, output_buf->size);
+	rb_enc_copy(result, text);
+
+	bufrelease(output_buf);
+	return result;
+}
+
+
+void Init_redcarpet_rndr()
+{
+	rb_mRender = rb_define_module_under(rb_mRedcarpet, "Render");
+
+	rb_cRenderBase = rb_define_class_under(rb_mRender, "Base", rb_cObject);
+	rb_define_alloc_func(rb_cRenderBase, rb_redcarpet_rbase_alloc);
+	rb_define_method(rb_cRenderBase, "initialize", rb_redcarpet_rbase_init, 0);
+
+	rb_cRenderHTML = rb_define_class_under(rb_mRender, "HTML", rb_cRenderBase);
+	rb_define_method(rb_cRenderHTML, "initialize", rb_redcarpet_html_init, -1);
+
+	rb_cRenderHTML_TOC = rb_define_class_under(rb_mRender, "HTML_TOC", rb_cRenderBase);
+	rb_define_method(rb_cRenderHTML_TOC, "initialize", rb_redcarpet_htmltoc_init, 0);
+
+	rb_mSmartyPants = rb_define_module_under(rb_mRender, "SmartyPants");
+	rb_define_singleton_method(rb_mSmartyPants, "postprocess", rb_redcarpet_smartypants_render, 1);
+}