patcito-rdiscount 1.6.8

data/ext/rdiscount.c

@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include "ruby.h"
+#include "mkdio.h"
+
+static VALUE rb_cRDiscount;
+
+static VALUE
+rb_rdiscount_to_html(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    char *res;
+    int szres;
+    VALUE encoding;
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    VALUE buf = rb_str_buf_new(1024);
+    Check_Type(text, T_STRING);
+
+    int flags = rb_rdiscount__get_flags(self);
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_document(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+
+    /* force the input encoding */
+    if ( rb_respond_to(text, rb_intern("encoding")) ) {
+      encoding = rb_funcall(text, rb_intern("encoding"), 0);
+      rb_funcall(buf, rb_intern("force_encoding"), 1, encoding);
+    }
+
+    return buf;
+}
+
+static VALUE
+rb_rdiscount_toc_content(int argc, VALUE *argv, VALUE self)
+{
+    char *res;
+    int szres;
+
+    int flags = rb_rdiscount__get_flags(self);
+
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+
+    /* allocate a ruby string buffer and wrap it in a stream */
+    VALUE buf = rb_str_buf_new(4096);
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_toc(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+    return buf;
+}
+
+int rb_rdiscount__get_flags(VALUE ruby_obj)
+{
+  /* compile flags */
+  int flags = MKD_TABSTOP | MKD_NOHEADER;
+
+  /* smart */
+  if ( rb_funcall(ruby_obj, rb_intern("smart"), 0) != Qtrue )
+      flags = flags | MKD_NOPANTS;
+
+  /* filter_html */
+  if ( rb_funcall(ruby_obj, rb_intern("filter_html"), 0) == Qtrue )
+      flags = flags | MKD_NOHTML;
+
+  /* generate_toc */
+  if ( rb_funcall(ruby_obj, rb_intern("generate_toc"), 0) == Qtrue)
+    flags = flags | MKD_TOC;
+
+  /* no_image */
+  if ( rb_funcall(ruby_obj, rb_intern("no_image"), 0) == Qtrue)
+    flags = flags | MKD_NOIMAGE;
+
+  /* no_links */
+  if ( rb_funcall(ruby_obj, rb_intern("no_links"), 0) == Qtrue)
+    flags = flags | MKD_NOLINKS;
+
+  /* no_tables */
+  if ( rb_funcall(ruby_obj, rb_intern("no_tables"), 0) == Qtrue)
+    flags = flags | MKD_NOTABLES;
+
+  /* strict */
+  if ( rb_funcall(ruby_obj, rb_intern("strict"), 0) == Qtrue)
+    flags = flags | MKD_STRICT;
+
+  /* autolink */
+  if ( rb_funcall(ruby_obj, rb_intern("autolink"), 0) == Qtrue)
+    flags = flags | MKD_AUTOLINK;
+
+  /* safelink */
+  if ( rb_funcall(ruby_obj, rb_intern("safelink"), 0) == Qtrue)
+    flags = flags | MKD_SAFELINK;
+
+  /* no_pseudo_protocols */
+  if ( rb_funcall(ruby_obj, rb_intern("no_pseudo_protocols"), 0) == Qtrue)
+    flags = flags | MKD_NO_EXT;
+
+  /* protect_math */
+  if ( rb_funcall(ruby_obj, rb_intern("protect_math"), 0) == Qtrue)
+    flags = flags | MKD_PROTECTMATH;
+
+  return flags;
+}
+
+
+void Init_rdiscount()
+{
+    rb_cRDiscount = rb_define_class("RDiscount", rb_cObject);
+    rb_define_method(rb_cRDiscount, "to_html", rb_rdiscount_to_html, -1);
+    rb_define_method(rb_cRDiscount, "toc_content", rb_rdiscount_toc_content, -1);
+}
+
+/* vim: set ts=4 sw=4: */

data/ext/resource.c

@@ -0,0 +1,157 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "config.h"
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+/* free a (single) line
+ */
+void
+___mkd_freeLine(Line *ptr)
+{
+    DELETE(ptr->text);
+    free(ptr);
+}
+
+
+/* free a list of lines
+ */
+void
+___mkd_freeLines(Line *p)
+{
+    if (p->next)
+	 ___mkd_freeLines(p->next);
+    ___mkd_freeLine(p);
+}
+
+
+/* bye bye paragraph.
+ */
+void
+___mkd_freeParagraph(Paragraph *p)
+{
+    if (p->next)
+	___mkd_freeParagraph(p->next);
+    if (p->down)
+	___mkd_freeParagraph(p->down);
+    if (p->text)
+	___mkd_freeLines(p->text);
+    if (p->ident)
+	free(p->ident);
+    free(p);
+}
+
+
+/* bye bye footnote.
+ */
+void
+___mkd_freefootnote(Footnote *f)
+{
+    DELETE(f->tag);
+    DELETE(f->link);
+    DELETE(f->title);
+}
+
+
+/* bye bye footnotes.
+ */
+void
+___mkd_freefootnotes(MMIOT *f)
+{
+    int i;
+
+    if ( f->footnotes ) {
+	for (i=0; i < S(*f->footnotes); i++)
+	    ___mkd_freefootnote( &T(*f->footnotes)[i] );
+	DELETE(*f->footnotes);
+	free(f->footnotes);
+    }
+}
+
+
+/* initialize a new MMIOT
+ */
+void
+___mkd_initmmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	memset(f, 0, sizeof *f);
+	CREATE(f->in);
+	CREATE(f->out);
+	CREATE(f->Q);
+	if ( footnotes )
+	    f->footnotes = footnotes;
+	else {
+	    f->footnotes = malloc(sizeof f->footnotes[0]);
+	    CREATE(*f->footnotes);
+	}
+    }
+}
+
+
+/* free the contents of a MMIOT, but leave the object alone.
+ */
+void
+___mkd_freemmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	DELETE(f->in);
+	DELETE(f->out);
+	DELETE(f->Q);
+	if ( f->footnotes != footnotes )
+	    ___mkd_freefootnotes(f);
+	memset(f, 0, sizeof *f);
+    }
+}
+
+
+/* free lines up to an barrier.
+ */
+void
+___mkd_freeLineRange(Line *anchor, Line *stop)
+{
+    Line *r = anchor->next;
+
+    if ( r != stop ) {
+	while ( r && (r->next != stop) )
+	    r = r->next;
+	if ( r ) r->next = 0;
+	___mkd_freeLines(anchor->next);
+    }
+    anchor->next = 0;
+}
+
+
+/* clean up everything allocated in __mkd_compile()
+ */
+void
+mkd_cleanup(Document *doc)
+{
+    if ( doc && (doc->magic == VALID_DOCUMENT) ) {
+	if ( doc->ctx ) {
+	    ___mkd_freemmiot(doc->ctx, 0);
+	    free(doc->ctx);
+	}
+
+	if ( doc->code) ___mkd_freeParagraph(doc->code);
+	if ( doc->title) ___mkd_freeLine(doc->title);
+	if ( doc->author) ___mkd_freeLine(doc->author);
+	if ( doc->date) ___mkd_freeLine(doc->date);
+	if ( T(doc->content) ) ___mkd_freeLines(T(doc->content));
+	memset(doc, 0, sizeof doc[0]);
+	free(doc);
+    }
+}

data/ext/tags.c

@@ -0,0 +1,123 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#define __WITHOUT_AMALLOC 1
+#include "cstring.h"
+#include "tags.h"
+
+STRING(struct kw) blocktags;
+
+
+/* define a html block tag
+ */
+void
+mkd_define_tag(char *id, int selfclose)
+{
+    struct kw *p = &EXPAND(blocktags);
+
+    p->id = id;
+    p->size = strlen(id);
+    p->selfclose = selfclose;
+}
+
+
+/* case insensitive string sort (for qsort() and bsearch() of block tags)
+ */
+static int
+casort(struct kw *a, struct kw *b)
+{
+    if ( a->size != b->size )
+	return a->size - b->size;
+    return strncasecmp(a->id, b->id, b->size);
+}
+
+
+/* stupid cast to make gcc shut up about the function types being
+ * passed into qsort() and bsearch()
+ */
+typedef int (*stfu)(const void*,const void*);
+
+
+/* sort the list of html block tags for later searching
+ */
+void
+mkd_sort_tags()
+{
+    qsort(T(blocktags), S(blocktags), sizeof(struct kw), (stfu)casort);
+}
+
+
+
+/* look for a token in the html block tag list
+ */
+struct kw*
+mkd_search_tags(char *pat, int len)
+{
+    struct kw key;
+    
+    key.id = pat;
+    key.size = len;
+    
+    return bsearch(&key, T(blocktags), S(blocktags), sizeof key, (stfu)casort);
+}
+
+
+static int populated = 0;
+
+
+/* load in the standard collection of html tags that markdown supports
+ */
+void
+mkd_prepare_tags()
+{
+
+#define KW(x)	mkd_define_tag(x, 0)
+#define SC(x)	mkd_define_tag(x, 1)
+
+    if ( populated ) return;
+    populated = 1;
+    
+    KW("STYLE");
+    KW("SCRIPT");
+    KW("ADDRESS");
+    KW("BDO");
+    KW("BLOCKQUOTE");
+    KW("CENTER");
+    KW("DFN");
+    KW("DIV");
+    KW("OBJECT");
+    KW("H1");
+    KW("H2");
+    KW("H3");
+    KW("H4");
+    KW("H5");
+    KW("H6");
+    KW("LISTING");
+    KW("NOBR");
+    KW("UL");
+    KW("P");
+    KW("OL");
+    KW("DL");
+    KW("PLAINTEXT");
+    KW("PRE");
+    KW("TABLE");
+    KW("WBR");
+    KW("XMP");
+    SC("HR");
+    SC("BR");
+    KW("IFRAME");
+    KW("MAP");
+
+    mkd_sort_tags();
+} /* mkd_prepare_tags */
+
+
+/* destroy the blocktags list (for shared libraries)
+ */
+void
+mkd_deallocate_tags()
+{
+    if ( S(blocktags) > 0 ) {
+	populated = 0;
+	DELETE(blocktags);
+    }
+} /* mkd_deallocate_tags */

data/ext/tags.h

@@ -0,0 +1,19 @@
+/* block-level tags for passing html blocks through the blender
+ */
+#ifndef _TAGS_D
+#define _TAGS_D
+
+struct kw {
+    char *id;
+    int  size;
+    int  selfclose;
+} ;
+
+
+struct kw* mkd_search_tags(char *, int);
+void mkd_prepare_tags();
+void mkd_deallocate_tags();
+void mkd_sort_tags();
+void mkd_define_tag(char *, int);
+
+#endif

data/ext/toc.c

@@ -0,0 +1,101 @@
+/*
+ * toc -- spit out a table of contents based on header blocks
+ *
+ * Copyright (C) 2008 Jjgod Jiang, David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+/* write an header index
+ */
+int
+mkd_toc(Document *p, char **doc)
+{
+    Paragraph *tp, *srcp;
+    int last_hnumber = 0;
+    Cstring res;
+    int size;
+    
+    if ( !(doc && p && p->ctx) ) return -1;
+
+    *doc = 0;
+    
+    if ( ! (p->ctx->flags & MKD_TOC) ) return 0;
+
+    CREATE(res);
+    RESERVE(res, 100);
+
+    for ( tp = p->code; tp ; tp = tp->next ) {
+	if ( tp->typ == SOURCE ) {
+	    for ( srcp = tp->down; srcp; srcp = srcp->next ) {
+		if ( srcp->typ == HDR && srcp->text ) {
+	    
+		    if ( last_hnumber >= srcp->hnumber ) {
+			while ( last_hnumber > srcp->hnumber ) {
+			    Csprintf(&res, "%*s</ul></li>\n", last_hnumber-1,"");
+			    --last_hnumber;
+			}
+		    }
+
+		    while ( srcp->hnumber > last_hnumber ) {
+			Csprintf(&res, "%*s%s<ul>\n", last_hnumber, "",
+				    last_hnumber ? "<li>" : "");
+			++last_hnumber;
+		    }
+		    Csprintf(&res, "%*s<li><a href=\"#", srcp->hnumber, "");
+		    mkd_string_to_anchor(T(srcp->text->text),
+					 S(srcp->text->text), Csputc, &res,1);
+		    Csprintf(&res, "\">");
+		    mkd_string_to_anchor(T(srcp->text->text),
+					 S(srcp->text->text), Csputc, &res,0);
+		    Csprintf(&res, "</a>");
+		    Csprintf(&res, "</li>\n");
+		}
+	    }
+        }
+    }
+
+    while ( last_hnumber > 0 ) {
+	--last_hnumber;
+	Csprintf(&res, last_hnumber ? "%*s</ul></li>\n" : "%*s</ul>\n", last_hnumber, "");
+    }
+
+    if ( (size = S(res)) > 0 ) {
+	EXPAND(res) = 0;
+			/* HACK ALERT! HACK ALERT! HACK ALERT! */
+	*doc = T(res);  /* we know that a T(Cstring) is a character pointer
+			 * so we can simply pick it up and carry it away,
+			 * leaving the husk of the Ctring on the stack
+			 * END HACK ALERT
+			 */
+    }
+    else
+	DELETE(res);
+    return size;
+}
+
+
+/* write an header index
+ */
+int
+mkd_generatetoc(Document *p, FILE *out)
+{
+    char *buf = 0;
+    int sz = mkd_toc(p, &buf);
+    int ret = EOF;
+
+    if ( sz > 0 )
+	ret = fwrite(buf, 1, sz, out);
+
+    if ( buf ) free(buf);
+
+    return (ret == sz) ? ret : EOF;
+}

data/ext/xml.c

@@ -0,0 +1,82 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "config.h"
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+/* return the xml version of a character
+ */
+static char *
+mkd_xmlchar(unsigned char c)
+{
+    switch (c) {
+    case '<':   return "&lt;";
+    case '>':   return "&gt;";
+    case '&':   return "&amp;";
+    case '"':   return "&quot;";
+    case '\'':  return "&apos;";
+    default:    if ( isascii(c) || (c & 0x80) )
+		    return 0;
+		return "";
+    }
+}
+
+
+/* write output in XML format
+ */
+int
+mkd_generatexml(char *p, int size, FILE *out)
+{
+    unsigned char c;
+    char *entity;
+
+    while ( size-- > 0 ) {
+	c = *p++;
+
+	if ( entity = mkd_xmlchar(c) )
+	    fputs(entity, out);
+	else
+	    fputc(c, out);
+    }
+    return 0;
+}
+
+
+/* build a xml'ed version of a string
+ */
+int
+mkd_xml(char *p, int size, char **res)
+{
+    unsigned char c;
+    char *entity;
+    Cstring f;
+
+    CREATE(f);
+    RESERVE(f, 100);
+
+    while ( size-- > 0 ) {
+	c = *p++;
+	if ( entity = mkd_xmlchar(c) )
+	    Cswrite(&f, entity, strlen(entity));
+	else
+	    Csputc(c, &f);
+    }
+			/* HACK ALERT! HACK ALERT! HACK ALERT! */
+    *res = T(f);	/* we know that a T(Cstring) is a character pointer */
+			/* so we can simply pick it up and carry it away, */
+    return S(f);	/* leaving the husk of the Ctring on the stack */
+			/* END HACK ALERT */
+}

data/lib/markdown.rb

@@ -0,0 +1 @@
+require 'rdiscount'

data/lib/rdiscount.rb

@@ -0,0 +1,101 @@
+# Discount is an implementation of John Gruber's Markdown markup
+# language in C. It implements all of the language as described in
+# {Markdown Syntax}[http://daringfireball.net/projects/markdown/syntax]
+# and passes the Markdown 1.0 test suite. The RDiscount extension makes
+# the Discount processor available via a Ruby C Extension library.
+#
+# == Usage
+#
+# RDiscount implements the basic protocol popularized by RedCloth and adopted
+# by BlueCloth:
+#   require 'rdiscount'
+#   markdown = RDiscount.new("Hello World!")
+#   puts markdown.to_html
+#
+# == Replacing BlueCloth
+#
+# Inject RDiscount into your BlueCloth-using code by replacing your bluecloth
+# require statements with the following:
+#   begin
+#     require 'rdiscount'
+#     BlueCloth = RDiscount
+#   rescue LoadError
+#     require 'bluecloth'
+#   end
+#
+class RDiscount
+  VERSION = '1.6.8'
+
+  # Original Markdown formatted text.
+  attr_reader :text
+
+  # Set true to have smarty-like quote translation performed.
+  attr_accessor :smart
+
+  # Do not output <tt><style></tt> tags included in the source text.
+  attr_accessor :filter_styles
+
+  # Do not output any raw HTML included in the source text.
+  attr_accessor :filter_html
+
+  # RedCloth compatible line folding -- not used for Markdown but
+  # included for compatibility.
+  attr_accessor :fold_lines
+
+  # Enable Table Of Contents generation
+  attr_accessor :generate_toc
+
+  # Do not process <tt>![]</tt> and remove <tt><img></tt> tags from the output.
+  attr_accessor :no_image
+
+  # Do not process <tt>[]</tt> and remove <tt><a></tt> tags from the output.
+  attr_accessor :no_links
+
+  # Do not process tables
+  attr_accessor :no_tables
+
+  # Disable superscript and relaxed emphasis processing.
+  attr_accessor :strict
+
+  # Convert URL in links, even if they aren't encased in <tt><></tt>
+  attr_accessor :autolink
+
+  # Don't make hyperlinks from <tt>[][]</tt> links that have unknown URL types.
+  attr_accessor :safelink
+
+  # Do not process pseudo-protocols like <tt>[](id:name)</tt>
+  attr_accessor :no_pseudo_protocols
+
+  # Protect text enclosed in dollar signs from being scrambled by smartypants
+  # and/or markdown.
+  attr_accessor :protect_math
+
+  # Create a RDiscount Markdown processor. The +text+ argument
+  # should be a string containing Markdown text. Additional arguments may be
+  # supplied to set various processing options:
+  #
+  # * <tt>:smart</tt> - Enable SmartyPants processing.
+  # * <tt>:filter_styles</tt> - Do not output <tt><style></tt> tags.
+  # * <tt>:filter_html</tt> - Do not output any raw HTML tags included in
+  #   the source text.
+  # * <tt>:fold_lines</tt> - RedCloth compatible line folding (not used).
+  # * <tt>:generate_toc</tt> - Enable Table Of Contents generation
+  # * <tt>:no_image</tt> - Do not output any <tt><img></tt> tags.
+  # * <tt>:no_links</tt> - Do not output any <tt><a></tt> tags.
+  # * <tt>:no_tables</tt> - Do not output any tables.
+  # * <tt>:strict</tt> - Disable superscript and relaxed emphasis processing.
+  # * <tt>:autolink</tt> - Greedily urlify links.
+  # * <tt>:safelink</tt> - Do not make links for unknown URL types.
+  # * <tt>:no_pseudo_protocols</tt> - Do not process pseudo-protocols.
+  # * <tt>:protect_math</tt> - Do not modify text enclosed in dollar signs.
+  #
+  def initialize(text, *extensions)
+    @text  = text
+    extensions.each { |e| send("#{e}=", true) }
+  end
+
+end
+
+Markdown = RDiscount unless defined? Markdown
+
+require 'rdiscount.so'