rpeg-markdown 0.1.0 → 0.2.0

data/ext/markdown_peg.h

@@ -1,13 +1,9 @@
 /* markdown_peg.h */
+#include "markdown_lib.h"
+#include <glib.h>
 
 extern char *strdup(const char *string);
 
-/**********************************************************************
-
-  Data Structures
-
- ***********************************************************************/
-
 /* Information (label, URL and title) for a link. */
 struct Link {
     struct Element   *label;
@@ -20,7 +16,7 @@ typedef struct Link link;
 /* Union for contents of an Element (string, list, or link). */
 union Contents {
     char             *str;
-    struct Link      link;
+    struct Link      *link;
 };
 
 /* Types of semantic values returned by parsers. */ 
@@ -52,7 +48,7 @@ enum keys { LIST,   /* A generic list of values.  For ordered and bullet lists,
             HTMLBLOCK,
             HRULE,
             REFERENCE,
-            NOTE,
+            NOTE
           };
 
 /* Semantic value of a parsing action. */
@@ -65,20 +61,10 @@ struct Element {
 
 typedef struct Element element;
 
-enum markdown_extensions { 
-    EXT_SMART            = 1,
-    EXT_NOTES            = 2
-};  
-
-element *cons(element new, element *list);
-element *reverse(element *list);
-element markdown(char *string, int extensions);
-
-/* Output formats. */
-enum formats { HTML_FORMAT,
-               LATEX_FORMAT,
-               GROFF_MM_FORMAT
-             };
-
-void print_element(element elt, int format);
+element * parse_references(char *string, int extensions);
+element * parse_notes(char *string, int extensions, element *reference_list);
+element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list);
+void free_element_list(element * elt);
+void free_element(element *elt);
+void print_element_list(GString *out, element *elt, int format, int exts);
 

data/ext/parsing_functions.c

@@ -0,0 +1,104 @@
+/* parsing_functions.c - Functions for parsing markdown and
+ * freeing element lists. */
+
+int yyparse(void);
+
+static void free_element_contents(element elt);
+
+/* free_element_list - free list of elements recursively */
+void free_element_list(element * elt) {
+    element * next = NULL;
+    while (elt != NULL) {
+        next = elt->next;
+        free_element_contents(*elt);
+        if (elt->children != NULL) {
+            free_element_list(elt->children);
+            elt->children = NULL;
+        }
+        free(elt);
+        elt = next;
+    }
+}
+
+/* free_element_contents - free element contents depending on type */
+static void free_element_contents(element elt) {
+    switch (elt.key) {
+      case STR:
+      case SPACE:
+      case RAW:
+      case HTMLBLOCK:
+      case HTML:
+      case VERBATIM:
+      case CODE:
+      case NOTE:
+        free(elt.contents.str);
+        elt.contents.str = NULL;
+        break;
+      case LINK:
+      case IMAGE:
+      case REFERENCE:
+        free(elt.contents.link->url);
+        elt.contents.link->url = NULL;
+        free(elt.contents.link->title);
+        elt.contents.link->title = NULL;
+        free_element_list(elt.contents.link->label);
+        free(elt.contents.link);
+        elt.contents.link = NULL;
+        break;
+      default:
+        ;
+    }
+}
+
+/* free_element - free element and contents */
+void free_element(element *elt) {
+    free_element_contents(*elt);
+    free(elt);
+}
+
+element * parse_references(char *string, int extensions) {
+
+    char *oldcharbuf;
+    syntax_extensions = extensions;
+
+    oldcharbuf = charbuf;
+    charbuf = string;
+    yyparsefrom(yy_References);    /* first pass, just to collect references */
+    charbuf = oldcharbuf;
+
+    return references;
+}
+
+element * parse_notes(char *string, int extensions, element *reference_list) {
+
+    char *oldcharbuf;
+    notes = NULL;
+    syntax_extensions = extensions;
+
+    if (extension(EXT_NOTES)) {
+        references = reference_list;
+        oldcharbuf = charbuf;
+        charbuf = string;
+        yyparsefrom(yy_Notes);     /* second pass for notes */
+        charbuf = oldcharbuf;
+    }
+
+    return notes;
+}
+
+element * parse_markdown(char *string, int extensions, element *reference_list, element *note_list) {
+
+    char *oldcharbuf;
+    syntax_extensions = extensions;
+    references = reference_list;
+    notes = note_list;
+
+    oldcharbuf = charbuf;
+    charbuf = string;
+
+    yyparsefrom(yy_Doc);
+
+    charbuf = oldcharbuf;          /* restore charbuf to original value */
+    return parse_result;
+
+}

data/ext/utility_functions.c

@@ -0,0 +1,220 @@
+/* utility_functions.c - List manipulation functions, element
+ * constructors, and macro definitions for leg markdown parser. */
+
+extern int strcasecmp(const char *string1, const char *string2);
+
+/**********************************************************************
+
+  List manipulation functions
+
+ ***********************************************************************/
+
+/* cons - cons an element onto a list, returning pointer to new head */
+static element * cons(element *new, element *list) {
+    assert(new != NULL);
+    new->next = list;
+    return new;
+}
+
+/* reverse - reverse a list, returning pointer to new list */
+static element *reverse(element *list) {
+    element *new = NULL;
+    element *next = NULL;
+    while (list != NULL) {
+        next = list->next;
+        new = cons(list, new);
+        list = next;
+    }
+    return new;
+}
+
+/* concat_string_list - concatenates string contents of list of STR elements.
+ * Frees STR elements as they are added to the concatenation. */
+static GString *concat_string_list(element *list) {
+    GString *result;
+    element *next;
+    result = g_string_new("");
+    while (list != NULL) {
+        assert(list->key == STR);
+        assert(list->contents.str != NULL);
+        g_string_append(result, list->contents.str);
+        next = list->next;
+        free_element(list);
+        list = next;
+    }
+    return result;
+}
+
+/**********************************************************************
+
+  Global variables used in parsing
+
+ ***********************************************************************/
+
+static char *charbuf = "";     /* Buffer of characters to be parsed. */
+static element *references = NULL;    /* List of link references found. */
+static element *notes = NULL;         /* List of footnotes found. */
+static element *parse_result;  /* Results of parse. */
+static int syntax_extensions;  /* Syntax extensions selected. */
+
+/**********************************************************************
+
+  Auxiliary functions for parsing actions.
+  These make it easier to build up data structures (including lists)
+  in the parsing actions.
+
+ ***********************************************************************/
+
+/* mk_element - generic constructor for element */
+static element * mk_element(int key) {
+    element *result = malloc(sizeof(element));
+    result->key = key;
+    result->children = NULL;
+    result->next = NULL;
+    result->contents.str = NULL;
+    return result;
+}
+
+/* mk_str - constructor for STR element */
+static element * mk_str(char *string) {
+    element *result;
+    assert(string != NULL);
+    result = mk_element(STR);
+    result->contents.str = strdup(string);
+    return result;
+}
+
+/* mk_str_from_list - makes STR element by concatenating a
+ * reversed list of strings, adding optional extra newline */
+static element * mk_str_from_list(element *list, bool extra_newline) {
+    element *result;
+    GString *c = concat_string_list(reverse(list));
+    if (extra_newline)
+        g_string_append(c, "\n");
+    result = mk_element(STR);
+    result->contents.str = c->str;
+    g_string_free(c, false);
+    return result;
+}
+
+/* mk_list - makes new list with key 'key' and children the reverse of 'lst'.
+ * This is designed to be used with cons to build lists in a parser action.
+ * The reversing is necessary because cons adds to the head of a list. */
+static element * mk_list(int key, element *lst) {
+    element *result;
+    result = mk_element(key);
+    result->children = reverse(lst);
+    return result;
+}
+
+/* mk_link - constructor for LINK element */
+static element * mk_link(element *label, char *url, char *title) {
+    element *result;
+    result = mk_element(LINK);
+    result->contents.link = malloc(sizeof(link));
+    result->contents.link->label = label;
+    result->contents.link->url = strdup(url);
+    result->contents.link->title = strdup(title);
+    return result;
+}
+
+/* extension = returns true if extension is selected */
+static bool extension(int ext) {
+    return (syntax_extensions & ext);
+}
+
+/* match_inlines - returns true if inline lists match (case-insensitive...) */
+static bool match_inlines(element *l1, element *l2) {
+    while (l1 != NULL && l2 != NULL) {
+      if (l1->key != l2->key)
+            return false;
+        switch (l1->key) {
+        case SPACE:
+        case LINEBREAK:
+            break;
+        case CODE:
+        case STR:
+        case HTML:
+            if (strcasecmp(l1->contents.str, l2->contents.str) == 0)
+                break;
+            else
+                return false;
+        case EMPH:
+        case STRONG:
+        case LIST:
+            if (match_inlines(l1->children, l2->children))
+                break;
+            else
+                return false;
+        case LINK:
+        case IMAGE:
+            return false;  /* No links or images within links */
+        default:
+            fprintf(stderr, "match_inlines encountered unknown key = %d\n", l1->key);
+            exit(EXIT_FAILURE);
+            break;
+        }
+        l1 = l1->next;
+        l2 = l2->next;
+    }
+    return (l1 == NULL && l2 == NULL);  /* return true if both lists exhausted */
+}
+
+/* find_reference - return true if link found in references matching label.
+ * 'link' is modified with the matching url and title. */
+static bool find_reference(link *result, element *label) {
+    element *cur = references;  /* pointer to walk up list of references */
+    link *curitem;
+    while (cur != NULL) {
+        curitem = cur->contents.link;
+        if (match_inlines(label, curitem->label)) {
+            *result = *curitem;
+            return true;
+        }
+        else
+            cur = cur->next;
+    }
+    return false;
+}
+
+/* find_note - return true if note found in notes matching label.
+if found, 'result' is set to point to matched note. */
+
+static bool find_note(element **result, char *label) {
+   element *cur = notes;  /* pointer to walk up list of notes */
+   while (cur != NULL) {
+       if (strcmp(label, cur->contents.str) == 0) {
+           *result = cur;
+           return true;
+       }
+       else
+           cur = cur->next;
+   }
+   return false;
+}
+
+/**********************************************************************
+
+  Definitions for leg parser generator.
+  YY_INPUT is the function the parser calls to get new input.
+  We take all new input from (static) charbuf.
+
+ ***********************************************************************/
+
+# define YYSTYPE element *
+#ifdef __DEBUG__
+# define YY_DEBUG 1
+#endif
+
+#define YY_INPUT(buf, result, max_size)              \
+{                                                    \
+    int yyc;                                         \
+    if (charbuf && *charbuf != '\0') {               \
+        yyc= *charbuf++;                             \
+    } else {                                         \
+        yyc= EOF;                                    \
+    }                                                \
+    result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1);     \
+}
+
+

data/lib/markdown.rb

@@ -5,12 +5,32 @@ class Markdown
   # Original Markdown formatted text.
   attr_reader :text
 
-  # Whether smarty-like quote translation should be performed.
+  # Set true to have smarty-like quote translation performed.
   attr_accessor :smart
 
-  # Whether footnotes should be 
+  # Set true to have footnotes processed.
   attr_accessor :notes
 
+  # BlueCloth compatible output filtering.
+  attr_accessor :filter_styles, :filter_html
+
+  # RedCloth compatible line folding -- not used for Markdown but
+  # included for compatibility.
+  attr_accessor :fold_lines
+
+  # Create a new 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>:notes</tt> - Enable footnotes.
+  # * <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).
+  #
+  # NOTE: The <tt>:filter_styles</tt> and <tt>:filter_html</tt> extensions
+  # are not yet implemented.
   def initialize(text, *extensions)
     @smart = false
     @notes = false

data/test/MarkdownTest_1.0/MarkdownTest.pl

@@ -0,0 +1,157 @@
+#!/usr/bin/perl
+
+#
+# MarkdownTester -- Run tests for Markdown implementations
+#
+# Copyright (c) 2004 John Gruber
+# <http://daringfireball.net/projects/markdown/>
+#
+
+use strict;
+use warnings;
+use Getopt::Long;
+use Benchmark;
+
+our $VERSION = '1.0';
+# Mon 13 Dec 2004
+
+my $time_start = new Benchmark;
+my $test_dir = "Tests";
+my $script  = "./Markdown.pl";
+my $use_tidy = 0;
+my ($flag_version);
+
+GetOptions (
+			"script=s"   => \$script,
+			"testdir=s"  => \$test_dir,
+			"tidy"       => \$use_tidy,
+			"version"    => \$flag_version,
+			);
+
+if($flag_version) {
+	my $progname = $0;
+	$progname =~ s{.*/}{};
+	die "$progname version $VERSION\n";
+}
+
+unless (-d $test_dir) { die "'$test_dir' is not a directory.\n"; }
+unless (-f $script)   { die "$script does not exist.\n"; }
+unless (-x $script)   { die "$script is not executable.\n"; }
+
+my $tests_passed = 0;
+my $tests_failed = 0;
+
+foreach my $testfile (glob "$test_dir/*.text") {
+	my $testname = $testfile;
+	$testname =~ s{.*/(.+)\.text$}{$1}i; 
+	print "$testname ... ";
+
+	# Look for a corresponding .html file for each .text file:
+	my $resultfile = $testfile;
+	$resultfile =~ s{\.text$}{\.html}i;
+	unless (-f $resultfile) {die "'$resultfile' does not exist.\n";}
+	
+	# open(TEST, $testfile)     || die("Can't open testfile: $!");
+	open(RESULT, $resultfile) || die("Can't open resultfile: $!");
+	undef $/;
+	# my $t_input = <TEST>;
+	my $t_result = <RESULT>;
+
+	my $t_output = `$script '$testfile'`;
+
+	# Normalize the output and expected result strings:
+	$t_result =~ s/\s+\z//; # trim trailing whitespace
+	$t_output =~ s/\s+\z//; # trim trailing whitespace
+	if ($use_tidy) {
+		#  Escape the strings, pass them through to CLI tidy tool for tag-level equivalency
+		$t_result =~ s{'}{'\\''}g; # escape ' chars for shell
+		$t_output =~ s{'}{'\\''}g;
+		$t_result = `echo '$t_result' | tidy --show-body-only 1 --quiet 1 --show-warnings 0`;
+		$t_output = `echo '$t_output' | tidy --show-body-only 1 --quiet 1 --show-warnings 0`;
+	}
+
+	if ($t_output eq $t_result) {
+		print "OK\n";
+		$tests_passed++;
+	}
+	else {
+		print "FAILED\n\n";
+		$tests_failed++;
+	}
+}
+
+print "\n\n";
+print "$tests_passed passed; $tests_failed failed.\n";
+
+my $time_end = new Benchmark;
+my $time_diff = timediff($time_end, $time_start);
+print "Benchmark: ", timestr($time_diff), "\n";
+
+
+__END__
+
+=pod
+
+=head1 NAME
+
+B<MarkdownTest>
+
+
+=head1 SYNOPSIS
+
+B<MarkdownTest.pl> [ B<--options> ]  [ I<file> ... ]
+
+
+=head1 DESCRIPTION
+
+
+=head1 OPTIONS
+
+Use "--" to end switch parsing. For example, to open a file named "-z", use:
+
+	MarkdownTest.pl -- -z
+
+=over 4
+
+=item B<--script>
+
+Specify the path to the Markdown script to test. Defaults to
+"./Markdown.pl". Example:
+
+	./MarkdownTest.pl --script ./PHP-Markdown/php-markdown
+
+=item B<--testdir>
+
+Specify the path to a directory containing test data. Defaults to "Tests".
+
+=item B<--tidy>
+
+Flag to turn on using the command line 'tidy' tool to normalize HTML
+output before comparing script output to the expected test result.
+Assumes that the 'tidy' command is available in your PATH. Defaults to
+off.
+
+=back
+
+
+
+=head1 BUGS
+
+
+
+=head1 VERSION HISTORY
+
+1.0	Mon 13 Dec 2004
+
+
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2004 John Gruber  
+<http://daringfireball.net/>   
+All rights reserved.
+
+This is free software; you may redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=cut

data/test/MarkdownTest_1.0/Tests/Amps and angle encoding.html

@@ -0,0 +1,17 @@
+<p>AT&amp;T has an ampersand in their name.</p>
+
+<p>AT&amp;T is another way to write it.</p>
+
+<p>This &amp; that.</p>
+
+<p>4 &lt; 5.</p>
+
+<p>6 > 5.</p>
+
+<p>Here's a <a href="http://example.com/?foo=1&amp;bar=2">link</a> with an ampersand in the URL.</p>
+
+<p>Here's a link with an amersand in the link text: <a href="http://att.com/" title="AT&amp;T">AT&amp;T</a>.</p>
+
+<p>Here's an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>
+
+<p>Here's an inline <a href="/script?foo=1&amp;bar=2">link</a>.</p>

data/test/MarkdownTest_1.0/Tests/Amps and angle encoding.text

@@ -0,0 +1,21 @@
+AT&T has an ampersand in their name.
+
+AT&T is another way to write it.
+
+This & that.
+
+4 < 5.
+
+6 > 5.
+
+Here's a [link] [1] with an ampersand in the URL.
+
+Here's a link with an amersand in the link text: [AT&T] [2].
+
+Here's an inline [link](/script?foo=1&bar=2).
+
+Here's an inline [link](</script?foo=1&bar=2>).
+
+
+[1]: http://example.com/?foo=1&bar=2
+[2]: http://att.com/  "AT&T"

data/test/MarkdownTest_1.0/Tests/Auto links.html

@@ -0,0 +1,18 @@
+<p>Link: <a href="http://example.com/">http://example.com/</a>.</p>
+
+<p>With an ampersand: <a href="http://example.com/?foo=1&amp;bar=2">http://example.com/?foo=1&amp;bar=2</a></p>
+
+<ul>
+<li>In a list?</li>
+<li><a href="http://example.com/">http://example.com/</a></li>
+<li>It should.</li>
+</ul>
+
+<blockquote>
+  <p>Blockquoted: <a href="http://example.com/">http://example.com/</a></p>
+</blockquote>
+
+<p>Auto-links should not occur here: <code>&lt;http://example.com/&gt;</code></p>
+
+<pre><code>or here: &lt;http://example.com/&gt;
+</code></pre>

data/test/MarkdownTest_1.0/Tests/Auto links.text

@@ -0,0 +1,13 @@
+Link: <http://example.com/>.
+
+With an ampersand: <http://example.com/?foo=1&bar=2>
+
+* In a list?
+* <http://example.com/>
+* It should.
+
+> Blockquoted: <http://example.com/>
+
+Auto-links should not occur here: `<http://example.com/>`
+
+	or here: <http://example.com/>