challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/basename.c

@@ -0,0 +1,43 @@
+/*
+ * mkdio -- markdown front end input functions
+ *
+ * Copyright (C) 2007 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 "mkdio.h"
+#include "cstring.h"
+#include "amalloc.h"
+
+static char *
+e_basename(const char *string, const int size, void *context)
+{
+    char *ret;
+    char *base = (char*)context;
+    
+    if ( base && string && (*string == '/') && (ret=malloc(strlen(base)+size+2)) ) {
+	strcpy(ret, base);
+	strncat(ret, string, size);
+	return ret;
+    }
+    return 0;
+}
+
+static void
+e_free(char *string, void *context)
+{
+    if ( string ) free(string);
+}
+
+void
+mkd_basename(MMIOT *document, char *base)
+{
+    mkd_e_url(document, e_basename);
+    mkd_e_data(document, base);
+    mkd_e_free(document, e_free);
+}

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/config.h

@@ -0,0 +1,25 @@
+/*
+ * rdiscount extension discount configuration
+ */
+#ifndef __MARKDOWN_D
+#define __MARKDOWN_D 1
+
+/* tabs are four spaces */
+#define TABSTOP 4
+
+/* these are setup by extconf.rb */
+#if HAVE_RANDOM
+#define COINTOSS() (random()&1)
+#elif HAVE_RAND
+#define COINTOSS() (rand()&1)
+#endif
+
+#if HAVE_SRANDOM
+#define INITRNG(x) srandom((unsigned int)x)
+#elif HAVE_SRAND
+#define INITRNG(x) srand((unsigned int)x)
+#endif
+
+#include "ruby-config.h"
+
+#endif/* __MARKDOWN_D */

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/css.c

@@ -0,0 +1,85 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2009 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"
+
+
+/*
+ * dump out stylesheet sections.
+ */
+static void
+stylesheets(Paragraph *p, Cstring *f)
+{
+    Line* q;
+
+    for ( ; p ; p = p->next ) {
+	if ( p->typ == STYLE ) {
+	    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);
+    }
+}
+
+
+/* dump any embedded styles to a string
+ */
+int
+mkd_css(Document *d, char **res)
+{
+    Cstring f;
+    int size;
+
+    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 */
+			/* 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(f);
+	return size;
+    }
+    return EOF;
+}
+
+
+/* dump any embedded styles to a file
+ */
+int
+mkd_generatecss(Document *d, FILE *f)
+{
+    char *res;
+    int written = EOF, size = mkd_css(d, &res);
+
+    if ( size > 0 )
+	written = fwrite(res, 1, size, f);
+    if ( res )
+	free(res);
+    return (written == size) ? size : EOF;
+}

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/cstring.h

@@ -0,0 +1,77 @@
+/* two template types:  STRING(t) which defines a pascal-style string
+ * of element (t) [STRING(char) is the closest to the pascal string],
+ * and ANCHOR(t) which defines a baseplate that a linked list can be
+ * built up from.   [The linked list /must/ contain a ->next pointer
+ * for linking the list together with.]
+ */
+#ifndef _CSTRING_D
+#define _CSTRING_D
+
+#include <string.h>
+#include <stdlib.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*)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)) \
+					   : malloc(sizeof T(x)[0] * ((x).alloc += 100)) )]
+
+#define DELETE(x)	ALLOCATED(x) ? (free(T(x)), S(x) = (x).alloc = 0) \
+				     : ( S(x) = 0 )
+#define CLIP(t,i,sz)	\
+	    ( ((i) >= 0) && ((sz) > 0) && (((i)+(sz)) <= S(t)) ) ? \
+	    (memmove(&T(t)[i], &T(t)[i+sz], (S(t)-(i+sz)+1)*sizeof(T(t)[0])), \
+		S(t) -= (sz)) : -1
+
+#define RESERVE(x, sz)	T(x) = ((x).alloc > S(x) + (sz) \
+			    ? T(x) \
+			    : T(x) \
+				? realloc(T(x), sizeof T(x)[0] * ((x).alloc = 100+(sz)+S(x))) \
+				: malloc(sizeof T(x)[0] * ((x).alloc = 100+(sz)+S(x))))
+#define SUFFIX(t,p,sz)	\
+	    memcpy(((S(t) += (sz)) - (sz)) + \
+		    (T(t) = T(t) ? realloc(T(t), sizeof T(t)[0] * ((t).alloc += sz)) \
+				 : malloc(sizeof T(t)[0] * ((t).alloc += sz))), \
+		    (p), sizeof(T(t)[0])*(sz))
+
+#define PREFIX(t,p,sz)	\
+	    RESERVE( (t), (sz) ); \
+	    if ( S(t) ) { memmove(T(t)+(sz), T(t), S(t)); } \
+	    memcpy( T(t), (p), (sz) ); \
+	    S(t) += (sz)
+
+/* reference-style links (and images) are stored in an array
+ */
+#define T(x)		(x).text
+#define S(x)		(x).size
+#define ALLOCATED(x)	(x).alloc
+
+/* abstract anchor type that defines a list base
+ * with a function that attaches an element to
+ * the end of the list.
+ *
+ * the list base field is named .text so that the T()
+ * macro will work with it.
+ */
+#define ANCHOR(t)	struct { t *text, *end; }
+#define E(t)		((t).end)
+
+#define ATTACH(t, p)	( T(t) ? ( (E(t)->next = (p)), (E(t) = (p)) ) \
+			       : ( (T(t) = E(t) = (p)) ) )
+
+typedef STRING(char) Cstring;
+
+extern void Csputc(int, Cstring *);
+extern int Csprintf(Cstring *, char *, ...);
+extern int Cswrite(Cstring *, char *, int);
+extern void Csreparse(Cstring *, char *, int, int);
+
+#endif/*_CSTRING_D*/

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/docheader.c

@@ -0,0 +1,49 @@
+/*
+ * docheader -- get values from the document header
+ *
+ * Copyright (C) 2007 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"
+
+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->title )
+	return onlyifset(doc->title);
+    return 0;
+}
+
+
+char *
+mkd_doc_author(Document *doc)
+{
+    if ( doc && doc->author )
+	return onlyifset(doc->author);
+    return 0;
+}
+
+
+char *
+mkd_doc_date(Document *doc)
+{
+    if ( doc && doc->date )
+	return onlyifset(doc->date);
+    return 0;
+}

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/dumptree.c

@@ -0,0 +1,152 @@
+/* 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 "markdown.h"
+#include "cstring.h"
+#include "amalloc.h"
+
+struct frame {
+    int indent;
+    char c;
+};
+
+typedef STRING(struct frame) Stack;
+
+static char *
+Pptype(int typ)
+{
+    switch (typ) {
+    case WHITESPACE: return "whitespace";
+    case CODE      : return "code";
+    case QUOTE     : return "quote";
+    case MARKUP    : return "markup";
+    case HTML      : return "html";
+    case DL        : return "dl";
+    case UL        : return "ul";
+    case OL        : return "ol";
+    case LISTITEM  : return "item";
+    case HDR       : return "header";
+    case HR        : return "hr";
+    case TABLE     : return "table";
+    case SOURCE    : return "source";
+    case STYLE     : return "style";
+    default        : return "mystery node!";
+    }
+}
+
+static void
+pushpfx(int indent, char c, Stack *sp)
+{
+    struct frame *q = &EXPAND(*sp);
+
+    q->indent = indent;
+    q->c = c;
+}
+
+
+static void
+poppfx(Stack *sp)
+{
+    S(*sp)--;
+}
+
+
+static void
+changepfx(Stack *sp, char c)
+{
+    char ch;
+
+    if ( !S(*sp) ) return;
+
+    ch = T(*sp)[S(*sp)-1].c;
+
+    if ( ch == '+' || ch == '|' )
+	T(*sp)[S(*sp)-1].c = c;
+}
+
+
+static void
+printpfx(Stack *sp, FILE *f)
+{
+    int i;
+    char c;
+
+    if ( !S(*sp) ) return;
+
+    c = T(*sp)[S(*sp)-1].c;
+
+    if ( c == '+' || c == '-' ) {
+	fprintf(f, "--%c", c);
+	T(*sp)[S(*sp)-1].c = (c == '-') ? ' ' : '|';
+    }
+    else
+	for ( i=0; i < S(*sp); i++ ) {
+	    if ( i )
+		fprintf(f, "  ");
+	    fprintf(f, "%*s%c", T(*sp)[i].indent + 2, " ", T(*sp)[i].c);
+	    if ( T(*sp)[i].c == '`' )
+		T(*sp)[i].c = ' ';
+	}
+    fprintf(f, "--");
+}
+
+
+static void
+dumptree(Paragraph *pp, Stack *sp, FILE *f)
+{
+    int count;
+    Line *p;
+    int d;
+    static char *Begin[] = { 0, "P", "center" };
+
+    while ( pp ) {
+	if ( !pp->next )
+	    changepfx(sp, '`');
+	printpfx(sp, f);
+
+	d = fprintf(f, "[%s", Pptype(pp->typ));
+	if ( pp->ident )
+	    d += fprintf(f, " %s", pp->ident);
+	if ( pp->align > 1 )
+	    d += fprintf(f, ", <%s>", Begin[pp->align]);
+
+	for (count=0, p=pp->text; p; ++count, (p = p->next) )
+	    ;
+
+	if ( count )
+	    d += fprintf(f, ", %d line%s", count, (count==1)?"":"s");
+
+	d += fprintf(f, "]");
+
+	if ( pp->down ) {
+	    pushpfx(d, pp->down->next ? '+' : '-', sp);
+	    dumptree(pp->down, sp, f);
+	    poppfx(sp);
+	}
+	else fputc('\n', f);
+	pp = pp->next;
+    }
+}
+
+
+int
+mkd_dump(Document *doc, FILE *out, int flags, char *title)
+{
+    Stack stack;
+
+    if (mkd_compile(doc, flags) ) {
+
+	CREATE(stack);
+	pushpfx(fprintf(out, "%s", title), doc->code->next ? '+' : '-', &stack);
+	dumptree(doc->code, &stack, out);
+	DELETE(stack);
+
+	mkd_cleanup(doc);
+	return 0;
+    }
+    return -1;
+}

data/vendor/bundle/gems/rdiscount-2.0.7.3/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 */

data/vendor/bundle/gems/rdiscount-2.0.7.3/ext/extconf.rb

@@ -0,0 +1,37 @@
+require 'mkmf'
+
+dir_config('rdiscount')
+
+HAVE_RANDOM = have_func('random')
+HAVE_SRANDOM = have_func('srandom')
+HAVE_RAND = have_func('rand')
+HAVE_SRAND = have_func('srand')
+
+def sized_int(size, types)
+  types.find { |type| check_sizeof(type) == 4 } ||
+    abort("no int with size #{size}")
+end
+
+DWORD = sized_int(4, ["unsigned long", "unsigned int"])
+WORD =  sized_int(2, ["unsigned int", "unsigned short"])
+BYTE = "unsigned char"
+VERSION = IO.read('VERSION').strip
+
+open(File.join(File.dirname(__FILE__), "ruby-config.h"), "wb") do |f|
+  f.write <<-EOF
+// These data types may be already defined if building on Windows (using MinGW)
+#ifndef DWORD
+  #define DWORD #{DWORD}
+#endif
+#ifndef WORD
+  #define WORD #{WORD}
+#endif
+#ifndef BYTE
+  #define BYTE #{BYTE}
+#endif
+  EOF
+end
+
+$defs.push("-DVERSION=\\\"#{VERSION}\\\"")
+
+create_makefile('rdiscount')