bluecloth 2.0.7-x86-mingw32 → 2.0.11pre158-x86-mingw32

data/ext/VERSION

@@ -1 +1 @@
-1.5.8
+2.0.5

data/ext/bluecloth.c

@@ -1,6 +1,6 @@
 /* 
  * BlueCloth -- a Ruby implementation of Markdown
- * $Id$
+ * $Id: bluecloth.c,v 0cda68a5fc00 2011/02/09 22:33:27 ged $
  * 
  * = Authors
  * 
@@ -32,11 +32,11 @@ VALUE bluecloth_default_opthash;
 static MMIOT *
 bluecloth_alloc( VALUE text, int flags ) {
 	MMIOT *document;
-	
+
 	document = mkd_string( RSTRING_PTR(text), RSTRING_LEN(text), flags );
 	if ( !document )
 		rb_raise( rb_eRuntimeError, "Failed to create a BlueCloth object for: %s", RSTRING_PTR(text) );
-	
+
 	return document;
 }
 
@@ -44,7 +44,7 @@ bluecloth_alloc( VALUE text, int flags ) {
 /*
  * GC Free function
  */
-static void 
+static void
 bluecloth_gc_free( MMIOT *document ) {
 	if ( document ) {
 		mkd_cleanup( document );
@@ -100,7 +100,7 @@ bluecloth_check_ptr( VALUE self ) {
 		rb_raise( rb_eTypeError, "wrong argument type %s (expected BlueCloth object)",
 				  rb_class2name(CLASS_OF( self )) );
     }
-	
+
 	return DATA_PTR( self );
 }
 
@@ -181,12 +181,13 @@ bluecloth_s_discount_version( VALUE klass ) {
  *   superscript notation. Defaults to +true+.
  * 
  */
-static VALUE 
+static VALUE
 bluecloth_initialize( int argc, VALUE *argv, VALUE self ) {
 	if ( !bluecloth_check_ptr(self) ) {
 		MMIOT *document;
-		VALUE text, textcopy, optflags, fullhash, opthash = Qnil;
+		VALUE text, optflags, fullhash, opthash = Qnil;
 		int flags = 0;
+		VALUE utf8text = Qnil;
 
 		rb_scan_args( argc, argv, "02", &text, &opthash );
 
@@ -201,7 +202,7 @@ bluecloth_initialize( int argc, VALUE *argv, VALUE self ) {
 			text = rb_str_new( "", 0 );
 		}
 		else {
-			text = rb_obj_as_string( text );
+			text = rb_obj_dup( rb_obj_as_string(text) );
 		}
 
 		/* Merge the options hash with the defaults and turn it into a flags int */
@@ -210,13 +211,21 @@ bluecloth_initialize( int argc, VALUE *argv, VALUE self ) {
 		fullhash = rb_funcall( bluecloth_cBlueCloth, rb_intern("opthash_from_flags"), 1, optflags );
 
 		flags = NUM2INT( optflags );
+
+#ifdef M17N_SUPPORTED
+		bluecloth_debug( "Bytes before utf8ification: %s",
+			RSTRING_PTR(rb_funcall(text, rb_intern("dump"), 0, Qnil)) );
+		utf8text = rb_str_export_to_enc( rb_str_dup(text), rb_utf8_encoding() );
+		DATA_PTR( self ) = document = bluecloth_alloc( utf8text, flags );
+#else
 		DATA_PTR( self ) = document = bluecloth_alloc( text, flags );
+#endif /* M17N_SUPPORTED */
+
 		if ( !mkd_compile(document, flags) )
 			rb_raise( rb_eRuntimeError, "Failed to compile markdown" );
 
-		textcopy = rb_str_dup( text );
-		OBJ_FREEZE( textcopy );
-		rb_iv_set( self, "@text", textcopy );
+		OBJ_FREEZE( text );
+		rb_iv_set( self, "@text", text );
 		OBJ_FREEZE( fullhash );
 		rb_iv_set( self, "@options", fullhash );
 
@@ -242,12 +251,20 @@ bluecloth_to_html( VALUE self ) {
 	VALUE result = Qnil;
 
 	bluecloth_debug( "Compiling document %p", document );
-	
+
 	if ( (length = mkd_document( document, &output )) != EOF ) {
-		bluecloth_debug( "Pointer to results: %p, length = %d", output, length );
-		result = rb_str_new( output, length );
+#ifdef M17N_SUPPORTED
+		VALUE orig_encoding = rb_obj_encoding( rb_iv_get(self, "@text") );
+		VALUE utf8_result = rb_enc_str_new( output, strlen(output), rb_utf8_encoding() );
+		result = rb_str_encode( utf8_result, orig_encoding, 0, Qnil );
+		bluecloth_debug( "Bytes after un-utf8ification (if necessary): %s",
+			RSTRING_PTR(rb_funcall(result, rb_intern("dump"), 0, Qnil)) );
+#else
+		result = rb_str_new2( output );
+#endif /* M17N_SUPPORTED */
 
 		OBJ_INFECT( result, self );
+
 		return result;
 	} else {
 		return Qnil;
@@ -283,7 +300,7 @@ bluecloth_header( VALUE self ) {
 	VALUE fieldstring, headers = rb_hash_new();
 
 	bluecloth_debug( "Fetching pandoc headers for document %p", document );
-	
+
 	if ( (field = mkd_doc_title(document)) ) {
 		fieldstring = rb_str_new2( field );
 		OBJ_INFECT( fieldstring, self );
@@ -312,6 +329,9 @@ bluecloth_header( VALUE self ) {
 void Init_bluecloth_ext( void ) {
 	bluecloth_cBlueCloth = rb_define_class( "BlueCloth", rb_cObject );
 
+	mkd_with_html5_tags();
+	mkd_initialize();
+
 	rb_define_alloc_func( bluecloth_cBlueCloth, bluecloth_s_allocate );
 	rb_define_singleton_method( bluecloth_cBlueCloth, "discount_version", 
 		bluecloth_s_discount_version, 0 );
@@ -321,10 +341,10 @@ void Init_bluecloth_ext( void ) {
 	rb_define_method( bluecloth_cBlueCloth, "to_html", bluecloth_to_html, 0 );
 	rb_define_method( bluecloth_cBlueCloth, "header", bluecloth_header, 0 );
 	rb_define_alias( bluecloth_cBlueCloth, "pandoc_header", "header" );
-	
+
 	/* The original Markdown text the object was constructed with */
 	rb_define_attr( bluecloth_cBlueCloth, "text", 1, 0 );
-	
+
 	/* The options hash that describes the options in effect when the object was created */
 	rb_define_attr( bluecloth_cBlueCloth, "options", 1, 0 );
 
@@ -339,22 +359,37 @@ void Init_bluecloth_ext( void ) {
 
 	/* Do not do Smartypants-style mangling of quotes, dashes, or ellipses. */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_NOPANTS",  INT2FIX(MKD_NOPANTS) );
-	
+
 	/* Escape all opening angle brackets in the input text instead of allowing block-level HTML */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_NOHTML",   INT2FIX(MKD_NOHTML) );
 
 	/* disable SUPERSCRIPT, RELAXED_EMPHASIS */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_STRICT",   INT2FIX(MKD_STRICT) );
-	
+
 	/* process text inside an html tag; no <em>, no <bold>, no html or [] expansion */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_TAGTEXT",  INT2FIX(MKD_TAGTEXT) );
-	
+
 	/* don't allow pseudo-protocols */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_NO_EXT",   INT2FIX(MKD_NO_EXT) );
-	
+
+	/* Generate code for xml ![CDATA[...]] */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_CDATA", INT2FIX(MKD_CDATA) );
+
+	/* Don't use superscript extension */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NOSUPERSCRIPT", INT2FIX(MKD_NOSUPERSCRIPT) );
+
+	/* Relaxed emphasis -- emphasis happens everywhere */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NORELAXED", INT2FIX(MKD_NORELAXED) );
+
+	/* disallow tables */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NOTABLES", INT2FIX(MKD_NOTABLES) );
+
+	/* forbid ~~strikethrough~~ */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NOSTRIKETHROUGH", INT2FIX(MKD_NOSTRIKETHROUGH) );
+
 	/* do table-of-contents processing */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_TOC",      INT2FIX(MKD_TOC) );
-	
+
 	/* MarkdownTest 1.0 Compatibility Mode */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_1_COMPAT", INT2FIX(MKD_1_COMPAT) );
 
@@ -367,10 +402,21 @@ void Init_bluecloth_ext( void ) {
 	/* Be paranoid about link protocols */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_SAFELINK", INT2FIX(MKD_SAFELINK) );
 
-
 	/* don't process header blocks */
 	rb_define_const( bluecloth_cBlueCloth, "MKD_NOHEADER", INT2FIX(MKD_NOHEADER) );
 
+	/* Expand tabs to 4 spaces */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_TABSTOP", INT2FIX(MKD_TABSTOP) );
+
+	/* Forbid '>%class%' blocks */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NODIVQUOTE", INT2FIX(MKD_NODIVQUOTE) );
+
+	/* Forbid alphabetic lists */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NOALPHALIST", INT2FIX(MKD_NOALPHALIST) );
+
+	/* Forbid definition lists */
+	rb_define_const( bluecloth_cBlueCloth, "MKD_NODLIST", INT2FIX(MKD_NODLIST) );
+
 
 	/* Make sure the Ruby side is loaded */
 	rb_require( "bluecloth" );

data/ext/bluecloth.h

@@ -1,6 +1,6 @@
 /* 
  * BlueCloth -- a Ruby implementation of Markdown
- * $Id$
+ * $Id: bluecloth.h,v 0cda68a5fc00 2011/02/09 22:33:27 ged $
  * 
  */
 
@@ -8,12 +8,23 @@
 #define BLUECLOTH_H
 
 #include "config.h"
+#include "assert.h"
 
 #include "mkdio.h"
 #include "ruby.h"
 
-#ifdef HAVE_RUBY_ENCODING_H
+void mkd_initialize  		_(( void ));
+void mkd_with_html5_tags	_(( void ));
+
+#if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
+#	define M17N_SUPPORTED
 #	include "ruby/encoding.h"
 #endif
 
+/* Replace the macro from encoding.h that refers to static 'rb_encoding_list' */
+#ifdef ENC_FROM_ENCINDEX
+#undef ENC_FROM_ENCINDEX
+#define ENC_FROM_ENCINDEX(idx) (rb_enc_from_index(idx))
+#endif
+
 #endif

data/ext/config.h

@@ -1,11 +1,22 @@
 /*
- * configuration for markdown, generated Tue Dec 23 06:19:25 PST 2008
- * by ged@tenar.home.faeriemud.org
+ * Hacked-up version of the config file generated by discount
  */
 
 #ifndef CONFIG_H_RZLE3ADO
 #define CONFIG_H_RZLE3ADO
 
+#include "extconf.h"
+
+#if SIZEOF_LONG == 8
+#	define DWORD unsigned int
+#	define WORD unsigned short
+#else
+#	define DWORD unsigned long
+#	define WORD unsigned int
+#endif
+
+#define BYTE unsigned char
+
 #ifdef RUBY_EXTCONF_H
 #	include RUBY_EXTCONF_H
 #endif

data/ext/css.c

@@ -28,9 +28,10 @@ stylesheets(Paragraph *p, Cstring *f)
 
     for ( ; p ; p = p->next ) {
 	if ( p->typ == STYLE ) {
-	    for ( q = p->text; q ; q = q->next )
+	    for ( q = p->text; q ; q = q->next ) {
 		Cswrite(f, T(q->text), S(q->text));
 		Csputc('\n', f);
+	    }
 	}
 	if ( p->down )
 	    stylesheets(p->down, f);
@@ -44,17 +45,25 @@ int
 mkd_css(Document *d, char **res)
 {
     Cstring f;
+    int size;
 
-    if ( res && *res && d && d->compiled ) {
+    if ( res && d && d->compiled ) {
+	*res = 0;
 	CREATE(f);
 	RESERVE(f, 100);
 	stylesheets(d->code, &f);
 			
+	if ( (size = S(f)) > 0 ) {
+	    EXPAND(f) = 0;
 			/* HACK ALERT! HACK ALERT! HACK ALERT! */
-	*res = T(f);	/* we know that a T(Cstring) is a character pointer */
+	    *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 */
+			/* leaving the husk of the Ctring on the stack */
 			/* END HACK ALERT */
+	}
+	else
+	    DELETE(f);
+	return size;
     }
     return EOF;
 }
@@ -69,7 +78,7 @@ mkd_generatecss(Document *d, FILE *f)
     int written = EOF, size = mkd_css(d, &res);
 
     if ( size > 0 )
-	written = fwrite(res, size, 1, f);
+	written = fwrite(res, 1, size, f);
     if ( res )
 	free(res);
     return (written == size) ? size : EOF;

data/ext/cstring.h

@@ -10,13 +10,15 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include "amalloc.h"
+#ifndef __WITHOUT_AMALLOC
+# include "amalloc.h"
+#endif
 
 /* expandable Pascal-style string.
  */
 #define STRING(type)	struct { type *text; int size, alloc; }
 
-#define CREATE(x)	T(x) = (void*)(S(x) = (x).alloc = 0)
+#define CREATE(x)	( (T(x) = (void*)0), (S(x) = (x).alloc = 0) )
 #define EXPAND(x)	(S(x)++)[(S(x) < (x).alloc) \
 			    ? (T(x)) \
 			    : (T(x) = T(x) ? realloc(T(x), sizeof T(x)[0] * ((x).alloc += 100)) \

data/ext/docheader.c

@@ -14,13 +14,19 @@
 #include "markdown.h"
 #include "amalloc.h"
 
-#define afterdle(t)	(T((t)->text) + (t)->dle)
+static char *
+onlyifset(Line *l)
+{
+    char *ret = T(l->text) + l->dle;
+
+    return ret[0] ? ret : 0;
+}
 
 char *
 mkd_doc_title(Document *doc)
 {
-    if ( doc && doc->headers )
-	return afterdle(doc->headers);
+    if ( doc && doc->title )
+	return onlyifset(doc->title);
     return 0;
 }
 
@@ -28,8 +34,8 @@ mkd_doc_title(Document *doc)
 char *
 mkd_doc_author(Document *doc)
 {
-    if ( doc && doc->headers && doc->headers->next )
-	return afterdle(doc->headers->next);
+    if ( doc && doc->author )
+	return onlyifset(doc->author);
     return 0;
 }
 
@@ -37,7 +43,7 @@ mkd_doc_author(Document *doc)
 char *
 mkd_doc_date(Document *doc)
 {
-    if ( doc && doc->headers && doc->headers->next && doc->headers->next->next )
-	return afterdle(doc->headers->next->next);
+    if ( doc && doc->date )
+	return onlyifset(doc->date);
     return 0;
 }

data/ext/emmatch.c

@@ -0,0 +1,188 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2010 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"
+
+
+/* emmatch: the emphasis mangler that's run after a block
+ *          of html has been generated.
+ *
+ *          It should create MarkdownTest_1.0 (and _1.0.3)
+ *          compatable emphasis for non-pathological cases
+ *          and it should fail in a standards-compliant way
+ *          when someone attempts to feed it junk.
+ *
+ *          Emmatching is done after the input has been 
+ *          processed into a STRING (f->Q) of text and
+ *          emphasis blocks.   After ___mkd_emblock() finishes,
+ *          it truncates f->Q and leaves the rendered paragraph
+ *          if f->out.
+ */
+
+
+/* empair() -- find the NEAREST matching emphasis token (or
+ *             subtoken of a 3+ long emphasis token.
+ */
+static int
+empair(MMIOT *f, int first, int last, int match)
+{
+    
+    int i;
+    block *begin, *p;
+
+    begin = &T(f->Q)[first];
+
+    for (i=first+1; i <= last; i++) {
+	p = &T(f->Q)[i];
+
+	if ( (p->b_type != bTEXT) && (p->b_count <= 0) )
+	    continue; /* break? */
+	
+	if ( p->b_type == begin->b_type ) {
+	    if ( p->b_count == match )	/* exact match */
+		return i;
+
+	    if ( p->b_count > 2 )	/* fuzzy match */
+		return i;
+	}
+    }
+    return 0;
+} /* empair */
+
+
+/* emfill() -- if an emphasis token has leftover stars or underscores,
+ *             convert them back into character and append them to b_text.
+ */
+static void
+emfill(block *p)
+{
+    int j;
+
+    if ( p->b_type == bTEXT )
+	return;
+	
+    for (j=0; j < p->b_count; j++)
+	  EXPAND(p->b_text) = p->b_char;
+    p->b_count = 0;
+} /* emfill */
+
+
+static void
+emclose(MMIOT *f, int first, int last)
+{
+    int j;
+
+    for (j=first+1; j<last-1; j++)
+	emfill(&T(f->Q)[j]);
+}
+
+
+static struct emtags {
+    char open[10];
+    char close[10];
+    int size;
+} emtags[] = {  { "<em>" , "</em>", 5 }, { "<strong>", "</strong>", 9 } };
+
+
+static void emblock(MMIOT*,int,int);
+
+
+/* emmatch() -- match emphasis for a single emphasis token.
+ */
+static void
+emmatch(MMIOT *f, int first, int last)
+{
+    block *start = &T(f->Q)[first];
+    int e, e2, match;
+
+    switch (start->b_count) {
+    case 2: if ( e = empair(f,first,last,match=2) )
+		break;
+    case 1: e = empair(f,first,last,match=1);
+	    break;
+    case 0: return;
+    default:
+	    e = empair(f,first,last,1);
+	    e2= empair(f,first,last,2);
+
+	    if ( e2 >= e ) {
+		e = e2;
+		match = 2;
+	    } 
+	    else
+		match = 1;
+	    break;
+    }
+
+    if ( e ) {
+	/* if we found emphasis to match, match it, recursively call
+	 * emblock to match emphasis inside the new html block, add
+	 * the emphasis markers for the block, then (tail) recursively
+	 * call ourself to match any remaining emphasis on this token.
+	 */
+	block *end = &T(f->Q)[e];
+
+	end->b_count -= match;
+	start->b_count -= match;
+
+	emblock(f, first, e);
+
+	PREFIX(start->b_text, emtags[match-1].open, emtags[match-1].size-1);
+	SUFFIX(end->b_post, emtags[match-1].close, emtags[match-1].size);
+
+	emmatch(f, first, last);
+    }
+} /* emmatch */
+
+
+/* emblock() -- walk a blocklist, attempting to match emphasis
+ */
+static void
+emblock(MMIOT *f, int first, int last)
+{
+    int i;
+    
+    for ( i = first; i <= last; i++ )
+	if ( T(f->Q)[i].b_type != bTEXT )
+	    emmatch(f, i, last);
+    emclose(f, first, last);
+} /* emblock */
+
+
+/* ___mkd_emblock() -- emblock a string of blocks, then concatenate the
+ *                     resulting text onto f->out.
+ */
+void
+___mkd_emblock(MMIOT *f)
+{
+    int i;
+    block *p;
+
+    emblock(f, 0, S(f->Q)-1);
+    
+    for (i=0; i < S(f->Q); i++) {
+	p = &T(f->Q)[i];
+	emfill(p);
+	
+	if ( S(p->b_post) ) { SUFFIX(f->out, T(p->b_post), S(p->b_post));
+			      DELETE(p->b_post); }
+	if ( S(p->b_text) ) { SUFFIX(f->out, T(p->b_text), S(p->b_text));
+			      DELETE(p->b_text); }
+    }
+    
+    S(f->Q) = 0;
+} /* ___mkd_emblock */