Updates to README and MANIFEST files.
[matthijs/upstream/blosxom-plugins.git] / general / Markdown
1 #!/usr/bin/perl
2
3 #
4 # Markdown -- A text-to-HTML conversion tool for web writers
5 #
6 # Copyright (c) 2004 John Gruber
7 # <http://daringfireball.net/projects/markdown/>
8 #
9 # With minor modifications made by the Blosxom Plugin Development Team 
10 # <blosxom-devel@lists.sourceforge.net>.
11 #
12
13
14 package Markdown;
15 require 5.006_000;
16 use strict;
17 use warnings;
18
19 use Digest::MD5 qw(md5_hex);
20 use vars qw($VERSION);
21 $VERSION = '1.0.1b';
22 # Tue 14 Dec 2004
23
24 ## Disabled; causes problems under Perl 5.6.1:
25 # use utf8;
26 # binmode( STDOUT, ":utf8" );  # c.f.: http://acis.openlib.org/dev/perl-unicode-struggle.html
27
28
29 #
30 # Global default settings:
31 #
32 my $g_empty_element_suffix = " />";     # Change to ">" for HTML output
33 my $g_tab_width = 4;
34
35
36 #
37 # Globals:
38 #
39
40 # Regex to match balanced [brackets]. See Friedl's
41 # "Mastering Regular Expressions", 2nd Ed., pp. 328-331.
42 my $g_nested_brackets;
43 $g_nested_brackets = qr{
44         (?>                                                             # Atomic matching
45            [^\[\]]+                                                     # Anything other than brackets
46          | 
47            \[
48                  (??{ $g_nested_brackets })             # Recursive set of nested brackets
49            \]
50         )*
51 }x;
52
53
54 # Table of hash values for escaped characters:
55 my %g_escape_table;
56 foreach my $char (split //, '\\`*_{}[]()>#+-.!') {
57         $g_escape_table{$char} = md5_hex($char);
58 }
59
60
61 # Global hashes, used by various utility routines
62 my %g_urls;
63 my %g_titles;
64 my %g_html_blocks;
65
66 # Used to track when we're inside an ordered or unordered list
67 # (see _ProcessListItems() for details):
68 my $g_list_level = 0;
69
70
71 #### Blosxom plug-in interface ##########################################
72
73 # Set $g_blosxom_use_meta to 1 to use Blosxom's meta plug-in to determine
74 # which posts Markdown should process, using a "meta-markup: markdown"
75 # header. If it's set to 0 (the default), Markdown will process all
76 # entries.
77 my $g_blosxom_use_meta = 0;
78
79 sub start { 1; }
80 sub story {
81         my($pkg, $path, $filename, $story_ref, $title_ref, $body_ref) = @_;
82
83         if ( (! $g_blosxom_use_meta) or
84              (defined($meta::markup) and ($meta::markup =~ /^\s*markdown\s*$/i))
85              ){
86                         $$body_ref  = Markdown($$body_ref);
87      }
88      1;
89 }
90
91
92 #### Movable Type plug-in interface #####################################
93 eval {require MT};  # Test to see if we're running in MT.
94 unless ($@) {
95     require MT;
96     import  MT;
97     require MT::Template::Context;
98     import  MT::Template::Context;
99
100         eval {require MT::Plugin};  # Test to see if we're running >= MT 3.0.
101         unless ($@) {
102                 require MT::Plugin;
103                 import  MT::Plugin;
104                 my $plugin = new MT::Plugin({
105                         name => "Markdown",
106                         description => "A plain-text-to-HTML formatting plugin. (Version: $VERSION)",
107                         doc_link => 'http://daringfireball.net/projects/markdown/'
108                 });
109                 MT->add_plugin( $plugin );
110         }
111
112         MT::Template::Context->add_container_tag(MarkdownOptions => sub {
113                 my $ctx  = shift;
114                 my $args = shift;
115                 my $builder = $ctx->stash('builder');
116                 my $tokens = $ctx->stash('tokens');
117
118                 if (defined ($args->{'output'}) ) {
119                         $ctx->stash('markdown_output', lc $args->{'output'});
120                 }
121
122                 defined (my $str = $builder->build($ctx, $tokens) )
123                         or return $ctx->error($builder->errstr);
124                 $str;           # return value
125         });
126
127         MT->add_text_filter('markdown' => {
128                 label     => 'Markdown',
129                 docs      => 'http://daringfireball.net/projects/markdown/',
130                 on_format => sub {
131                         my $text = shift;
132                         my $ctx  = shift;
133                         my $raw  = 0;
134                     if (defined $ctx) {
135                         my $output = $ctx->stash('markdown_output'); 
136                                 if (defined $output  &&  $output =~ m/^html/i) {
137                                         $g_empty_element_suffix = ">";
138                                         $ctx->stash('markdown_output', '');
139                                 }
140                                 elsif (defined $output  &&  $output eq 'raw') {
141                                         $raw = 1;
142                                         $ctx->stash('markdown_output', '');
143                                 }
144                                 else {
145                                         $raw = 0;
146                                         $g_empty_element_suffix = " />";
147                                 }
148                         }
149                         $text = $raw ? $text : Markdown($text);
150                         $text;
151                 },
152         });
153
154         # If SmartyPants is loaded, add a combo Markdown/SmartyPants text filter:
155         my $smartypants;
156
157         {
158                 no warnings "once";
159                 $smartypants = $MT::Template::Context::Global_filters{'smarty_pants'};
160         }
161
162         if ($smartypants) {
163                 MT->add_text_filter('markdown_with_smartypants' => {
164                         label     => 'Markdown With SmartyPants',
165                         docs      => 'http://daringfireball.net/projects/markdown/',
166                         on_format => sub {
167                                 my $text = shift;
168                                 my $ctx  = shift;
169                                 if (defined $ctx) {
170                                         my $output = $ctx->stash('markdown_output'); 
171                                         if (defined $output  &&  $output eq 'html') {
172                                                 $g_empty_element_suffix = ">";
173                                         }
174                                         else {
175                                                 $g_empty_element_suffix = " />";
176                                         }
177                                 }
178                                 $text = Markdown($text);
179                                 $text = $smartypants->($text, '1');
180                         },
181                 });
182         }
183 }
184 else {
185 #### BBEdit/command-line text filter interface ##########################
186 # Needs to be hidden from MT (and Blosxom when running in static mode).
187
188     # We're only using $blosxom::version once; tell Perl not to warn us:
189         no warnings 'once';
190     unless ( defined($blosxom::version) ) {
191                 use warnings;
192
193                 #### Check for command-line switches: #################
194                 my %cli_opts;
195                 use Getopt::Long;
196                 Getopt::Long::Configure('pass_through');
197                 GetOptions(\%cli_opts,
198                         'version',
199                         'shortversion',
200                         'html4tags',
201                 );
202                 if ($cli_opts{'version'}) {             # Version info
203                         print "\nThis is Markdown, version $VERSION.\n";
204                         print "Copyright 2004 John Gruber\n";
205                         print "http://daringfireball.net/projects/markdown/\n\n";
206                         exit 0;
207                 }
208                 if ($cli_opts{'shortversion'}) {                # Just the version number string.
209                         print $VERSION;
210                         exit 0;
211                 }
212                 if ($cli_opts{'html4tags'}) {                   # Use HTML tag style instead of XHTML
213                         $g_empty_element_suffix = ">";
214                 }
215
216
217                 #### Process incoming text: ###########################
218                 my $text;
219                 {
220                         local $/;               # Slurp the whole file
221                         $text = <>;
222                 }
223         print Markdown($text);
224     }
225 }
226
227
228
229 sub Markdown {
230 #
231 # Main function. The order in which other subs are called here is
232 # essential. Link and image substitutions need to happen before
233 # _EscapeSpecialChars(), so that any *'s or _'s in the <a>
234 # and <img> tags get encoded.
235 #
236         my $text = shift;
237
238         # Clear the global hashes. If we don't clear these, you get conflicts
239         # from other articles when generating a page which contains more than
240         # one article (e.g. an index page that shows the N most recent
241         # articles):
242         %g_urls = ();
243         %g_titles = ();
244         %g_html_blocks = ();
245
246
247         # Standardize line endings:
248         $text =~ s{\r\n}{\n}g;  # DOS to Unix
249         $text =~ s{\r}{\n}g;    # Mac to Unix
250
251         # Make sure $text ends with a couple of newlines:
252         $text .= "\n\n";
253
254         # Convert all tabs to spaces.
255         $text = _Detab($text);
256
257         # Strip any lines consisting only of spaces and tabs.
258         # This makes subsequent regexen easier to write, because we can
259         # match consecutive blank lines with /\n+/ instead of something
260         # contorted like /[ \t]*\n+/ .
261         $text =~ s/^[ \t]+$//mg;
262
263         # Turn block-level HTML blocks into hash entries
264         $text = _HashHTMLBlocks($text);
265
266         # Strip link definitions, store in hashes.
267         $text = _StripLinkDefinitions($text);
268
269         $text = _RunBlockGamut($text);
270
271         $text = _UnescapeSpecialChars($text);
272
273         return $text . "\n";
274 }
275
276
277 sub _StripLinkDefinitions {
278 #
279 # Strips link definitions from text, stores the URLs and titles in
280 # hash references.
281 #
282         my $text = shift;
283         my $less_than_tab = $g_tab_width - 1;
284
285         # Link defs are in the form: ^[id]: url "optional title"
286         while ($text =~ s{
287                                                 ^[ ]{0,$less_than_tab}\[(.+)\]: # id = $1
288                                                   [ \t]*
289                                                   \n?                           # maybe *one* newline
290                                                   [ \t]*
291                                                 <?(\S+?)>?                      # url = $2
292                                                   [ \t]*
293                                                   \n?                           # maybe one newline
294                                                   [ \t]*
295                                                 (?:
296                                                         (?<=\s)                 # lookbehind for whitespace
297                                                         ["(]
298                                                         (.+?)                   # title = $3
299                                                         [")]
300                                                         [ \t]*
301                                                 )?      # title is optional
302                                                 (?:\n+|\Z)
303                                         }
304                                         {}mx) {
305                 $g_urls{lc $1} = _EncodeAmpsAndAngles( $2 );    # Link IDs are case-insensitive
306                 if ($3) {
307                         $g_titles{lc $1} = $3;
308                         $g_titles{lc $1} =~ s/"/&quot;/g;
309                 }
310         }
311
312         return $text;
313 }
314
315
316 sub _HashHTMLBlocks {
317         my $text = shift;
318         my $less_than_tab = $g_tab_width - 1;
319
320         # Hashify HTML blocks:
321         # We only want to do this for block-level HTML tags, such as headers,
322         # lists, and tables. That's because we still want to wrap <p>s around
323         # "paragraphs" that are wrapped in non-block-level tags, such as anchors,
324         # phrase emphasis, and spans. The list of tags we're looking for is
325         # hard-coded:
326         my $block_tags_a = qr/p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del/;
327         my $block_tags_b = qr/p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math/;
328
329         # First, look for nested blocks, e.g.:
330         #       <div>
331         #               <div>
332         #               tags for inner block must be indented.
333         #               </div>
334         #       </div>
335         #
336         # The outermost tags must start at the left margin for this to match, and
337         # the inner nested divs must be indented.
338         # We need to do this before the next, more liberal match, because the next
339         # match will start at the first `<div>` and stop at the first `</div>`.
340         $text =~ s{
341                                 (                                               # save in $1
342                                         ^                                       # start of line  (with /m)
343                                         <($block_tags_a)        # start tag = $2
344                                         \b                                      # word break
345                                         (.*\n)*?                        # any number of lines, minimally matching
346                                         </\2>                           # the matching end tag
347                                         [ \t]*                          # trailing spaces/tabs
348                                         (?=\n+|\Z)      # followed by a newline or end of document
349                                 )
350                         }{
351                                 my $key = md5_hex($1);
352                                 $g_html_blocks{$key} = $1;
353                                 "\n\n" . $key . "\n\n";
354                         }egmx;
355
356
357         #
358         # Now match more liberally, simply from `\n<tag>` to `</tag>\n`
359         #
360         $text =~ s{
361                                 (                                               # save in $1
362                                         ^                                       # start of line  (with /m)
363                                         <($block_tags_b)        # start tag = $2
364                                         \b                                      # word break
365                                         (.*\n)*?                        # any number of lines, minimally matching
366                                         .*</\2>                         # the matching end tag
367                                         [ \t]*                          # trailing spaces/tabs
368                                         (?=\n+|\Z)      # followed by a newline or end of document
369                                 )
370                         }{
371                                 my $key = md5_hex($1);
372                                 $g_html_blocks{$key} = $1;
373                                 "\n\n" . $key . "\n\n";
374                         }egmx;
375         # Special case just for <hr />. It was easier to make a special case than
376         # to make the other regex more complicated.     
377         $text =~ s{
378                                 (?:
379                                         (?<=\n\n)               # Starting after a blank line
380                                         |                               # or
381                                         \A\n?                   # the beginning of the doc
382                                 )
383                                 (                                               # save in $1
384                                         [ ]{0,$less_than_tab}
385                                         <(hr)                           # start tag = $2
386                                         \b                                      # word break
387                                         ([^<>])*?                       # 
388                                         /?>                                     # the matching end tag
389                                         [ \t]*
390                                         (?=\n{2,}|\Z)           # followed by a blank line or end of document
391                                 )
392                         }{
393                                 my $key = md5_hex($1);
394                                 $g_html_blocks{$key} = $1;
395                                 "\n\n" . $key . "\n\n";
396                         }egx;
397
398         # Special case for standalone HTML comments:
399         $text =~ s{
400                                 (?:
401                                         (?<=\n\n)               # Starting after a blank line
402                                         |                               # or
403                                         \A\n?                   # the beginning of the doc
404                                 )
405                                 (                                               # save in $1
406                                         [ ]{0,$less_than_tab}
407                                         (?s:
408                                                 <!
409                                                 (--.*?--\s*)+
410                                                 >
411                                         )
412                                         [ \t]*
413                                         (?=\n{2,}|\Z)           # followed by a blank line or end of document
414                                 )
415                         }{
416                                 my $key = md5_hex($1);
417                                 $g_html_blocks{$key} = $1;
418                                 "\n\n" . $key . "\n\n";
419                         }egx;
420
421
422         return $text;
423 }
424
425
426 sub _RunBlockGamut {
427 #
428 # These are all the transformations that form block-level
429 # tags like paragraphs, headers, and list items.
430 #
431         my $text = shift;
432
433         $text = _DoHeaders($text);
434
435         # Do Horizontal Rules:
436         $text =~ s{^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
437         $text =~ s{^[ ]{0,2}([ ]? -[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
438         $text =~ s{^[ ]{0,2}([ ]? _[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
439
440         $text = _DoLists($text);
441
442         $text = _DoCodeBlocks($text);
443
444         $text = _DoBlockQuotes($text);
445
446         # We already ran _HashHTMLBlocks() before, in Markdown(), but that
447         # was to escape raw HTML in the original Markdown source. This time,
448         # we're escaping the markup we've just created, so that we don't wrap
449         # <p> tags around block-level tags.
450         $text = _HashHTMLBlocks($text);
451
452         $text = _FormParagraphs($text);
453
454         return $text;
455 }
456
457
458 sub _RunSpanGamut {
459 #
460 # These are all the transformations that occur *within* block-level
461 # tags like paragraphs, headers, and list items.
462 #
463         my $text = shift;
464
465         $text = _DoCodeSpans($text);
466
467         $text = _EscapeSpecialChars($text);
468
469         # Process anchor and image tags. Images must come first,
470         # because ![foo][f] looks like an anchor.
471         $text = _DoImages($text);
472         $text = _DoAnchors($text);
473
474         # Make links out of things like `<http://example.com/>`
475         # Must come after _DoAnchors(), because you can use < and >
476         # delimiters in inline links like [this](<url>).
477         $text = _DoAutoLinks($text);
478
479         $text = _EncodeAmpsAndAngles($text);
480
481         $text = _DoItalicsAndBold($text);
482
483         # Do hard breaks:
484         $text =~ s/ {2,}\n/ <br$g_empty_element_suffix\n/g;
485
486         return $text;
487 }
488
489
490 sub _EscapeSpecialChars {
491         my $text = shift;
492         my $tokens ||= _TokenizeHTML($text);
493
494         $text = '';   # rebuild $text from the tokens
495 #       my $in_pre = 0;  # Keep track of when we're inside <pre> or <code> tags.
496 #       my $tags_to_skip = qr!<(/?)(?:pre|code|kbd|script|math)[\s>]!;
497
498         foreach my $cur_token (@$tokens) {
499                 if ($cur_token->[0] eq "tag") {
500                         # Within tags, encode * and _ so they don't conflict
501                         # with their use in Markdown for italics and strong.
502                         # We're replacing each such character with its
503                         # corresponding MD5 checksum value; this is likely
504                         # overkill, but it should prevent us from colliding
505                         # with the escape values by accident.
506                         $cur_token->[1] =~  s! \* !$g_escape_table{'*'}!gx;
507                         $cur_token->[1] =~  s! _  !$g_escape_table{'_'}!gx;
508                         $text .= $cur_token->[1];
509                 } else {
510                         my $t = $cur_token->[1];
511                         $t = _EncodeBackslashEscapes($t);
512                         $text .= $t;
513                 }
514         }
515         return $text;
516 }
517
518
519 sub _DoAnchors {
520 #
521 # Turn Markdown link shortcuts into XHTML <a> tags.
522 #
523         my $text = shift;
524
525         #
526         # First, handle reference-style links: [link text] [id]
527         #
528         $text =~ s{
529                 (                                       # wrap whole match in $1
530                   \[
531                     ($g_nested_brackets)        # link text = $2
532                   \]
533
534                   [ ]?                          # one optional space
535                   (?:\n[ ]*)?           # one optional newline followed by spaces
536
537                   \[
538                     (.*?)               # id = $3
539                   \]
540                 )
541         }{
542                 my $result;
543                 my $whole_match = $1;
544                 my $link_text   = $2;
545                 my $link_id     = lc $3;
546
547                 if ($link_id eq "") {
548                         $link_id = lc $link_text;     # for shortcut links like [this][].
549                 }
550
551                 if (defined $g_urls{$link_id}) {
552                         my $url = $g_urls{$link_id};
553                         $url =~ s! \* !$g_escape_table{'*'}!gx;         # We've got to encode these to avoid
554                         $url =~ s!  _ !$g_escape_table{'_'}!gx;         # conflicting with italics/bold.
555                         $result = "<a href=\"$url\"";
556                         if ( defined $g_titles{$link_id} ) {
557                                 my $title = $g_titles{$link_id};
558                                 $title =~ s! \* !$g_escape_table{'*'}!gx;
559                                 $title =~ s!  _ !$g_escape_table{'_'}!gx;
560                                 $result .=  " title=\"$title\"";
561                         }
562                         $result .= ">$link_text</a>";
563                 }
564                 else {
565                         $result = $whole_match;
566                 }
567                 $result;
568         }xsge;
569
570         #
571         # Next, inline-style links: [link text](url "optional title")
572         #
573         $text =~ s{
574                 (                               # wrap whole match in $1
575                   \[
576                     ($g_nested_brackets)        # link text = $2
577                   \]
578                   \(                    # literal paren
579                         [ \t]*
580                         <?(.*?)>?       # href = $3
581                         [ \t]*
582                         (                       # $4
583                           (['"])        # quote char = $5
584                           (.*?)         # Title = $6
585                           \5            # matching quote
586                         )?                      # title is optional
587                   \)
588                 )
589         }{
590                 my $result;
591                 my $whole_match = $1;
592                 my $link_text   = $2;
593                 my $url                 = $3;
594                 my $title               = $6;
595
596                 $url =~ s! \* !$g_escape_table{'*'}!gx;         # We've got to encode these to avoid
597                 $url =~ s!  _ !$g_escape_table{'_'}!gx;         # conflicting with italics/bold.
598                 $result = "<a href=\"$url\"";
599
600                 if (defined $title) {
601                         $title =~ s/"/&quot;/g;
602                         $title =~ s! \* !$g_escape_table{'*'}!gx;
603                         $title =~ s!  _ !$g_escape_table{'_'}!gx;
604                         $result .=  " title=\"$title\"";
605                 }
606
607                 $result .= ">$link_text</a>";
608
609                 $result;
610         }xsge;
611
612         return $text;
613 }
614
615
616 sub _DoImages {
617 #
618 # Turn Markdown image shortcuts into <img> tags.
619 #
620         my $text = shift;
621
622         #
623         # First, handle reference-style labeled images: ![alt text][id]
624         #
625         $text =~ s{
626                 (                               # wrap whole match in $1
627                   !\[
628                     (.*?)               # alt text = $2
629                   \]
630
631                   [ ]?                          # one optional space
632                   (?:\n[ ]*)?           # one optional newline followed by spaces
633
634                   \[
635                     (.*?)               # id = $3
636                   \]
637
638                 )
639         }{
640                 my $result;
641                 my $whole_match = $1;
642                 my $alt_text    = $2;
643                 my $link_id     = lc $3;
644
645                 if ($link_id eq "") {
646                         $link_id = lc $alt_text;     # for shortcut links like ![this][].
647                 }
648
649                 $alt_text =~ s/"/&quot;/g;
650                 if (defined $g_urls{$link_id}) {
651                         my $url = $g_urls{$link_id};
652                         $url =~ s! \* !$g_escape_table{'*'}!gx;         # We've got to encode these to avoid
653                         $url =~ s!  _ !$g_escape_table{'_'}!gx;         # conflicting with italics/bold.
654                         $result = "<img src=\"$url\" alt=\"$alt_text\"";
655                         if (defined $g_titles{$link_id}) {
656                                 my $title = $g_titles{$link_id};
657                                 $title =~ s! \* !$g_escape_table{'*'}!gx;
658                                 $title =~ s!  _ !$g_escape_table{'_'}!gx;
659                                 $result .=  " title=\"$title\"";
660                         }
661                         $result .= $g_empty_element_suffix;
662                 }
663                 else {
664                         # If there's no such link ID, leave intact:
665                         $result = $whole_match;
666                 }
667
668                 $result;
669         }xsge;
670
671         #
672         # Next, handle inline images:  ![alt text](url "optional title")
673         # Don't forget: encode * and _
674
675         $text =~ s{
676                 (                               # wrap whole match in $1
677                   !\[
678                     (.*?)               # alt text = $2
679                   \]
680                   \(                    # literal paren
681                         [ \t]*
682                         <?(\S+?)>?      # src url = $3
683                         [ \t]*
684                         (                       # $4
685                           (['"])        # quote char = $5
686                           (.*?)         # title = $6
687                           \5            # matching quote
688                           [ \t]*
689                         )?                      # title is optional
690                   \)
691                 )
692         }{
693                 my $result;
694                 my $whole_match = $1;
695                 my $alt_text    = $2;
696                 my $url                 = $3;
697                 my $title               = '';
698                 if (defined($6)) {
699                         $title          = $6;
700                 }
701
702                 $alt_text =~ s/"/&quot;/g;
703                 $title    =~ s/"/&quot;/g;
704                 $url =~ s! \* !$g_escape_table{'*'}!gx;         # We've got to encode these to avoid
705                 $url =~ s!  _ !$g_escape_table{'_'}!gx;         # conflicting with italics/bold.
706                 $result = "<img src=\"$url\" alt=\"$alt_text\"";
707                 if (defined $title) {
708                         $title =~ s! \* !$g_escape_table{'*'}!gx;
709                         $title =~ s!  _ !$g_escape_table{'_'}!gx;
710                         $result .=  " title=\"$title\"";
711                 }
712                 $result .= $g_empty_element_suffix;
713
714                 $result;
715         }xsge;
716
717         return $text;
718 }
719
720
721 sub _DoHeaders {
722         my $text = shift;
723
724         # Setext-style headers:
725         #         Header 1
726         #         ========
727         #  
728         #         Header 2
729         #         --------
730         #
731         $text =~ s{ ^(.+)[ \t]*\n=+[ \t]*\n+ }{
732                 "<h1>"  .  _RunSpanGamut($1)  .  "</h1>\n\n";
733         }egmx;
734
735         $text =~ s{ ^(.+)[ \t]*\n-+[ \t]*\n+ }{
736                 "<h2>"  .  _RunSpanGamut($1)  .  "</h2>\n\n";
737         }egmx;
738
739
740         # atx-style headers:
741         #       # Header 1
742         #       ## Header 2
743         #       ## Header 2 with closing hashes ##
744         #       ...
745         #       ###### Header 6
746         #
747         $text =~ s{
748                         ^(\#{1,6})      # $1 = string of #'s
749                         [ \t]*
750                         (.+?)           # $2 = Header text
751                         [ \t]*
752                         \#*                     # optional closing #'s (not counted)
753                         \n+
754                 }{
755                         my $h_level = length($1);
756                         "<h$h_level>"  .  _RunSpanGamut($2)  .  "</h$h_level>\n\n";
757                 }egmx;
758
759         return $text;
760 }
761
762
763 sub _DoLists {
764 #
765 # Form HTML ordered (numbered) and unordered (bulleted) lists.
766 #
767         my $text = shift;
768         my $less_than_tab = $g_tab_width - 1;
769
770         # Re-usable patterns to match list item bullets and number markers:
771         my $marker_ul  = qr/[*+-]/;
772         my $marker_ol  = qr/\d+[.]/;
773         my $marker_any = qr/(?:$marker_ul|$marker_ol)/;
774
775         # Re-usable pattern to match any entirel ul or ol list:
776         my $whole_list = qr{
777                 (                                                               # $1 = whole list
778                   (                                                             # $2
779                         [ ]{0,$less_than_tab}
780                         (${marker_any})                         # $3 = first list item marker
781                         [ \t]+
782                   )
783                   (?s:.+?)
784                   (                                                             # $4
785                           \z
786                         |
787                           \n{2,}
788                           (?=\S)
789                           (?!                                           # Negative lookahead for another list item marker
790                                 [ \t]*
791                                 ${marker_any}[ \t]+
792                           )
793                   )
794                 )
795         }mx;
796
797         # We use a different prefix before nested lists than top-level lists.
798         # See extended comment in _ProcessListItems().
799         #
800         # Note: There's a bit of duplication here. My original implementation
801         # created a scalar regex pattern as the conditional result of the test on
802         # $g_list_level, and then only ran the $text =~ s{...}{...}egmx
803         # substitution once, using the scalar as the pattern. This worked,
804         # everywhere except when running under MT on my hosting account at Pair
805         # Networks. There, this caused all rebuilds to be killed by the reaper (or
806         # perhaps they crashed, but that seems incredibly unlikely given that the
807         # same script on the same server ran fine *except* under MT. I've spent
808         # more time trying to figure out why this is happening than I'd like to
809         # admit. My only guess, backed up by the fact that this workaround works,
810         # is that Perl optimizes the substition when it can figure out that the
811         # pattern will never change, and when this optimization isn't on, we run
812         # afoul of the reaper. Thus, the slightly redundant code to that uses two
813         # static s/// patterns rather than one conditional pattern.
814
815         if ($g_list_level) {
816                 $text =~ s{
817                                 ^
818                                 $whole_list
819                         }{
820                                 my $list = $1;
821                                 my $list_type = ($3 =~ m/$marker_ul/) ? "ul" : "ol";
822                                 # Turn double returns into triple returns, so that we can make a
823                                 # paragraph for the last item in a list, if necessary:
824                                 $list =~ s/\n{2,}/\n\n\n/g;
825                                 my $result = _ProcessListItems($list, $marker_any);
826                                 $result = "<$list_type>\n" . $result . "</$list_type>\n";
827                                 $result;
828                         }egmx;
829         }
830         else {
831                 $text =~ s{
832                                 (?:(?<=\n\n)|\A\n?)
833                                 $whole_list
834                         }{
835                                 my $list = $1;
836                                 my $list_type = ($3 =~ m/$marker_ul/) ? "ul" : "ol";
837                                 # Turn double returns into triple returns, so that we can make a
838                                 # paragraph for the last item in a list, if necessary:
839                                 $list =~ s/\n{2,}/\n\n\n/g;
840                                 my $result = _ProcessListItems($list, $marker_any);
841                                 $result = "<$list_type>\n" . $result . "</$list_type>\n";
842                                 $result;
843                         }egmx;
844         }
845
846
847         return $text;
848 }
849
850
851 sub _ProcessListItems {
852 #
853 #       Process the contents of a single ordered or unordered list, splitting it
854 #       into individual list items.
855 #
856
857         my $list_str = shift;
858         my $marker_any = shift;
859
860
861         # The $g_list_level global keeps track of when we're inside a list.
862         # Each time we enter a list, we increment it; when we leave a list,
863         # we decrement. If it's zero, we're not in a list anymore.
864         #
865         # We do this because when we're not inside a list, we want to treat
866         # something like this:
867         #
868         #               I recommend upgrading to version
869         #               8. Oops, now this line is treated
870         #               as a sub-list.
871         #
872         # As a single paragraph, despite the fact that the second line starts
873         # with a digit-period-space sequence.
874         #
875         # Whereas when we're inside a list (or sub-list), that line will be
876         # treated as the start of a sub-list. What a kludge, huh? This is
877         # an aspect of Markdown's syntax that's hard to parse perfectly
878         # without resorting to mind-reading. Perhaps the solution is to
879         # change the syntax rules such that sub-lists must start with a
880         # starting cardinal number; e.g. "1." or "a.".
881
882         $g_list_level++;
883
884         # trim trailing blank lines:
885         $list_str =~ s/\n{2,}\z/\n/;
886
887
888         $list_str =~ s{
889                 (\n)?                                                   # leading line = $1
890                 (^[ \t]*)                                               # leading whitespace = $2
891                 ($marker_any) [ \t]+                    # list marker = $3
892                 ((?s:.+?)                                               # list item text   = $4
893                 (\n{1,2}))
894                 (?= \n* (\z | \2 ($marker_any) [ \t]+))
895         }{
896                 my $item = $4;
897                 my $leading_line = $1;
898                 my $leading_space = $2;
899
900                 if ($leading_line or ($item =~ m/\n{2,}/)) {
901                         $item = _RunBlockGamut(_Outdent($item));
902                 }
903                 else {
904                         # Recursion for sub-lists:
905                         $item = _DoLists(_Outdent($item));
906                         chomp $item;
907                         $item = _RunSpanGamut($item);
908                 }
909
910                 "<li>" . $item . "</li>\n";
911         }egmx;
912
913         $g_list_level--;
914         return $list_str;
915 }
916
917
918
919 sub _DoCodeBlocks {
920 #
921 #       Process Markdown `<pre><code>` blocks.
922 #       
923
924         my $text = shift;
925
926         $text =~ s{
927                         (?:\n\n|\A)
928                         (                   # $1 = the code block -- one or more lines, starting with a space/tab
929                           (?:
930                             (?:[ ]{$g_tab_width} | \t)  # Lines must start with a tab or a tab-width of spaces
931                             .*\n+
932                           )+
933                         )
934                         ((?=^[ ]{0,$g_tab_width}\S)|\Z) # Lookahead for non-space at line-start, or end of doc
935                 }{
936                         my $codeblock = $1;
937                         my $result; # return value
938
939                         $codeblock = _EncodeCode(_Outdent($codeblock));
940                         $codeblock = _Detab($codeblock);
941                         $codeblock =~ s/\A\n+//; # trim leading newlines
942                         $codeblock =~ s/\s+\z//; # trim trailing whitespace
943
944                         $result = "\n\n<pre><code>" . $codeblock . "\n</code></pre>\n\n";
945
946                         $result;
947                 }egmx;
948
949         return $text;
950 }
951
952
953 sub _DoCodeSpans {
954 #
955 #       *       Backtick quotes are used for <code></code> spans.
956
957 #       *       You can use multiple backticks as the delimiters if you want to
958 #               include literal backticks in the code span. So, this input:
959 #     
960 #         Just type ``foo `bar` baz`` at the prompt.
961 #     
962 #       Will translate to:
963 #     
964 #         <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
965 #     
966 #               There's no arbitrary limit to the number of backticks you
967 #               can use as delimters. If you need three consecutive backticks
968 #               in your code, use four for delimiters, etc.
969 #
970 #       *       You can use spaces to get literal backticks at the edges:
971 #     
972 #         ... type `` `bar` `` ...
973 #     
974 #       Turns to:
975 #     
976 #         ... type <code>`bar`</code> ...
977 #
978
979         my $text = shift;
980
981         $text =~ s@
982                         (`+)            # $1 = Opening run of `
983                         (.+?)           # $2 = The code block
984                         (?<!`)
985                         \1                      # Matching closer
986                         (?!`)
987                 @
988                         my $c = "$2";
989                         $c =~ s/^[ \t]*//g; # leading whitespace
990                         $c =~ s/[ \t]*$//g; # trailing whitespace
991                         $c = _EncodeCode($c);
992                         "<code>$c</code>";
993                 @egsx;
994
995         return $text;
996 }
997
998
999 sub _EncodeCode {
1000 #
1001 # Encode/escape certain characters inside Markdown code runs.
1002 # The point is that in code, these characters are literals,
1003 # and lose their special Markdown meanings.
1004 #
1005     local $_ = shift;
1006
1007         # Encode all ampersands; HTML entities are not
1008         # entities within a Markdown code span.
1009         s/&/&amp;/g;
1010
1011         # Encode $'s, but only if we're running under Blosxom.
1012         # (Blosxom interpolates Perl variables in article bodies.)
1013         {
1014                 no warnings 'once';
1015         if (defined($blosxom::version)) {
1016                 s/\$/&#036;/g;  
1017         }
1018     }
1019
1020
1021         # Do the angle bracket song and dance:
1022         s! <  !&lt;!gx;
1023         s! >  !&gt;!gx;
1024
1025         # Now, escape characters that are magic in Markdown:
1026         s! \* !$g_escape_table{'*'}!gx;
1027         s! _  !$g_escape_table{'_'}!gx;
1028         s! {  !$g_escape_table{'{'}!gx;
1029         s! }  !$g_escape_table{'}'}!gx;
1030         s! \[ !$g_escape_table{'['}!gx;
1031         s! \] !$g_escape_table{']'}!gx;
1032         s! \\ !$g_escape_table{'\\'}!gx;
1033
1034         return $_;
1035 }
1036
1037
1038 sub _DoItalicsAndBold {
1039         my $text = shift;
1040
1041         # <strong> must go first:
1042         $text =~ s{ (?<!\w) (\*\*|__) (?=\S) (.+?[*_]*) (?<=\S) \1 (?!\w) }
1043                 {<strong>$2</strong>}gsx;
1044
1045         $text =~ s{ (?<!\w) (\*|_) (?=\S) (.+?) (?<=\S) \1 (?!\w) }
1046                 {<em>$2</em>}gsx;
1047
1048         return $text;
1049 }
1050
1051
1052 sub _DoBlockQuotes {
1053         my $text = shift;
1054
1055         $text =~ s{
1056                   (                                                             # Wrap whole match in $1
1057                         (
1058                           ^[ \t]*>[ \t]?                        # '>' at the start of a line
1059                             .+\n                                        # rest of the first line
1060                           (.+\n)*                                       # subsequent consecutive lines
1061                           \n*                                           # blanks
1062                         )+
1063                   )
1064                 }{
1065                         my $bq = $1;
1066                         $bq =~ s/^[ \t]*>[ \t]?//gm;    # trim one level of quoting
1067                         $bq =~ s/^[ \t]+$//mg;                  # trim whitespace-only lines
1068                         $bq = _RunBlockGamut($bq);              # recurse
1069
1070                         $bq =~ s/^/  /g;
1071                         # These leading spaces screw with <pre> content, so we need to fix that:
1072                         $bq =~ s{
1073                                         (\s*<pre>.+?</pre>)
1074                                 }{
1075                                         my $pre = $1;
1076                                         $pre =~ s/^  //mg;
1077                                         $pre;
1078                                 }egsx;
1079
1080                         "<blockquote>\n$bq\n</blockquote>\n\n";
1081                 }egmx;
1082
1083
1084         return $text;
1085 }
1086
1087
1088 sub _FormParagraphs {
1089 #
1090 #       Params:
1091 #               $text - string to process with html <p> tags
1092 #
1093         my $text = shift;
1094
1095         # Strip leading and trailing lines:
1096         $text =~ s/\A\n+//;
1097         $text =~ s/\n+\z//;
1098
1099         my @grafs = split(/\n{2,}/, $text);
1100
1101         #
1102         # Wrap <p> tags.
1103         #
1104         foreach (@grafs) {
1105                 unless (defined( $g_html_blocks{$_} )) {
1106                         $_ = _RunSpanGamut($_);
1107                         s/^([ \t]*)/<p>/;
1108                         $_ .= "</p>";
1109                 }
1110         }
1111
1112         #
1113         # Unhashify HTML blocks
1114         #
1115         foreach (@grafs) {
1116                 if (defined( $g_html_blocks{$_} )) {
1117                         $_ = $g_html_blocks{$_};
1118                 }
1119         }
1120
1121         return join "\n\n", @grafs;
1122 }
1123
1124
1125 sub _EncodeAmpsAndAngles {
1126 # Smart processing for ampersands and angle brackets that need to be encoded.
1127
1128         my $text = shift;
1129
1130         # Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
1131         #   http://bumppo.net/projects/amputator/
1132         $text =~ s/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/&amp;/g;
1133
1134         # Encode naked <'s
1135         $text =~ s{<(?![a-z/?\$!])}{&lt;}gi;
1136
1137         return $text;
1138 }
1139
1140
1141 sub _EncodeBackslashEscapes {
1142 #
1143 #   Parameter:  String.
1144 #   Returns:    The string, with after processing the following backslash
1145 #               escape sequences.
1146 #
1147     local $_ = shift;
1148
1149     s! \\\\  !$g_escape_table{'\\'}!gx;         # Must process escaped backslashes first.
1150     s! \\`   !$g_escape_table{'`'}!gx;
1151     s! \\\*  !$g_escape_table{'*'}!gx;
1152     s! \\_   !$g_escape_table{'_'}!gx;
1153     s! \\\{  !$g_escape_table{'{'}!gx;
1154     s! \\\}  !$g_escape_table{'}'}!gx;
1155     s! \\\[  !$g_escape_table{'['}!gx;
1156     s! \\\]  !$g_escape_table{']'}!gx;
1157     s! \\\(  !$g_escape_table{'('}!gx;
1158     s! \\\)  !$g_escape_table{')'}!gx;
1159     s! \\>   !$g_escape_table{'>'}!gx;
1160     s! \\\#  !$g_escape_table{'#'}!gx;
1161     s! \\\+  !$g_escape_table{'+'}!gx;
1162     s! \\\-  !$g_escape_table{'-'}!gx;
1163     s! \\\.  !$g_escape_table{'.'}!gx;
1164     s{ \\!  }{$g_escape_table{'!'}}gx;
1165
1166     return $_;
1167 }
1168
1169
1170 sub _DoAutoLinks {
1171         my $text = shift;
1172
1173         $text =~ s{<((https?|ftp):[^'">\s]+)>}{<a href="$1">$1</a>}gi;
1174
1175         # Email addresses: <address@domain.foo>
1176         $text =~ s{
1177                 <
1178         (?:mailto:)?
1179                 (
1180                         [-.\w]+
1181                         \@
1182                         [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
1183                 )
1184                 >
1185         }{
1186                 _EncodeEmailAddress( _UnescapeSpecialChars($1) );
1187         }egix;
1188
1189         return $text;
1190 }
1191
1192
1193 sub _EncodeEmailAddress {
1194 #
1195 #       Input: an email address, e.g. "foo@example.com"
1196 #
1197 #       Output: the email address as a mailto link, with each character
1198 #               of the address encoded as either a decimal or hex entity, in
1199 #               the hopes of foiling most address harvesting spam bots. E.g.:
1200 #
1201 #         <a href="&#x6D;&#97;&#105;&#108;&#x74;&#111;:&#102;&#111;&#111;&#64;&#101;
1202 #       x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;">&#102;&#111;&#111;
1203 #       &#64;&#101;x&#x61;&#109;&#x70;&#108;&#x65;&#x2E;&#99;&#111;&#109;</a>
1204 #
1205 #       Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
1206 #       mailing list: <http://tinyurl.com/yu7ue>
1207 #
1208
1209         my $addr = shift;
1210
1211         srand;
1212         my @encode = (
1213                 sub { '&#' .                 ord(shift)   . ';' },
1214                 sub { '&#x' . sprintf( "%X", ord(shift) ) . ';' },
1215                 sub {                            shift          },
1216         );
1217
1218         $addr = "mailto:" . $addr;
1219
1220         $addr =~ s{(.)}{
1221                 my $char = $1;
1222                 if ( $char eq '@' ) {
1223                         # this *must* be encoded. I insist.
1224                         $char = $encode[int rand 1]->($char);
1225                 } elsif ( $char ne ':' ) {
1226                         # leave ':' alone (to spot mailto: later)
1227                         my $r = rand;
1228                         # roughly 10% raw, 45% hex, 45% dec
1229                         $char = (
1230                                 $r > .9   ?  $encode[2]->($char)  :
1231                                 $r < .45  ?  $encode[1]->($char)  :
1232                                                          $encode[0]->($char)
1233                         );
1234                 }
1235                 $char;
1236         }gex;
1237
1238         $addr = qq{<a href="$addr">$addr</a>};
1239         $addr =~ s{">.+?:}{">}; # strip the mailto: from the visible part
1240
1241         return $addr;
1242 }
1243
1244
1245 sub _UnescapeSpecialChars {
1246 #
1247 # Swap back in all the special characters we've hidden.
1248 #
1249         my $text = shift;
1250
1251         while( my($char, $hash) = each(%g_escape_table) ) {
1252                 $text =~ s/$hash/$char/g;
1253         }
1254     return $text;
1255 }
1256
1257
1258 sub _TokenizeHTML {
1259 #
1260 #   Parameter:  String containing HTML markup.
1261 #   Returns:    Reference to an array of the tokens comprising the input
1262 #               string. Each token is either a tag (possibly with nested,
1263 #               tags contained therein, such as <a href="<MTFoo>">, or a
1264 #               run of text between tags. Each element of the array is a
1265 #               two-element array; the first is either 'tag' or 'text';
1266 #               the second is the actual value.
1267 #
1268 #
1269 #   Derived from the _tokenize() subroutine from Brad Choate's MTRegex plugin.
1270 #       <http://www.bradchoate.com/past/mtregex.php>
1271 #
1272
1273     my $str = shift;
1274     my $pos = 0;
1275     my $len = length $str;
1276     my @tokens;
1277
1278     my $depth = 6;
1279     my $nested_tags = join('|', ('(?:<[a-z/!$](?:[^<>]') x $depth) . (')*>)' x  $depth);
1280     my $match = qr/(?s: <! ( -- .*? -- \s* )+ > ) |  # comment
1281                    (?s: <\? .*? \?> ) |              # processing instruction
1282                    $nested_tags/ix;                   # nested tags
1283
1284     while ($str =~ m/($match)/g) {
1285         my $whole_tag = $1;
1286         my $sec_start = pos $str;
1287         my $tag_start = $sec_start - length $whole_tag;
1288         if ($pos < $tag_start) {
1289             push @tokens, ['text', substr($str, $pos, $tag_start - $pos)];
1290         }
1291         push @tokens, ['tag', $whole_tag];
1292         $pos = pos $str;
1293     }
1294     push @tokens, ['text', substr($str, $pos, $len - $pos)] if $pos < $len;
1295     \@tokens;
1296 }
1297
1298
1299 sub _Outdent {
1300 #
1301 # Remove one level of line-leading tabs or spaces
1302 #
1303         my $text = shift;
1304
1305         $text =~ s/^(\t|[ ]{1,$g_tab_width})//gm;
1306         return $text;
1307 }
1308
1309
1310 sub _Detab {
1311 #
1312 # Cribbed from a post by Bart Lateur:
1313 # <http://www.nntp.perl.org/group/perl.macperl.anyperl/154>
1314 #
1315         my $text = shift;
1316
1317         $text =~ s{(.*?)\t}{$1.(' ' x ($g_tab_width - length($1) % $g_tab_width))}ge;
1318         return $text;
1319 }
1320
1321
1322 1;
1323
1324 __END__
1325
1326
1327 =pod
1328
1329 =head1 NAME
1330
1331 B<Markdown>
1332
1333
1334 =head1 SYNOPSIS
1335
1336 B<Markdown.pl> [ B<--html4tags> ] [ B<--version> ] [ B<-shortversion> ]
1337     [ I<file> ... ]
1338
1339
1340 =head1 DESCRIPTION
1341
1342 Markdown is a text-to-HTML filter; it translates an easy-to-read /
1343 easy-to-write structured text format into HTML. Markdown's text format
1344 is most similar to that of plain text email, and supports features such
1345 as headers, *emphasis*, code blocks, blockquotes, and links.
1346
1347 Markdown's syntax is designed not as a generic markup language, but
1348 specifically to serve as a front-end to (X)HTML. You can  use span-level
1349 HTML tags anywhere in a Markdown document, and you can use block level
1350 HTML tags (like <div> and <table> as well).
1351
1352 For more information about Markdown's syntax, see:
1353
1354     http://daringfireball.net/projects/markdown/
1355
1356
1357 =head1 OPTIONS
1358
1359 Use "--" to end switch parsing. For example, to open a file named "-z", use:
1360
1361         Markdown.pl -- -z
1362
1363 =over 4
1364
1365
1366 =item B<--html4tags>
1367
1368 Use HTML 4 style for empty element tags, e.g.:
1369
1370     <br>
1371
1372 instead of Markdown's default XHTML style tags, e.g.:
1373
1374     <br />
1375
1376
1377 =item B<-v>, B<--version>
1378
1379 Display Markdown's version number and copyright information.
1380
1381
1382 =item B<-s>, B<--shortversion>
1383
1384 Display the short-form version number.
1385
1386
1387 =back
1388
1389
1390
1391 =head1 BUGS
1392
1393 To file bug reports or feature requests (other than topics listed in the
1394 Caveats section above) please send email to:
1395
1396     support@daringfireball.net
1397
1398 Please include with your report: (1) the example input; (2) the output
1399 you expected; (3) the output Markdown actually produced.
1400
1401
1402 =head1 VERSION HISTORY
1403
1404 See the readme file for detailed release notes for this version.
1405
1406 1.0.1 - 14 Dec 2004
1407
1408 1.0 - 28 Aug 2004
1409
1410
1411 =head1 AUTHOR
1412
1413     John Gruber
1414     http://daringfireball.net
1415
1416     PHP port and other contributions by Michel Fortin
1417     http://michelf.com
1418
1419
1420 =head1 COPYRIGHT AND LICENSE
1421
1422 Copyright (c) 2003-2004 John Gruber   
1423 <http://daringfireball.net/>   
1424 All rights reserved.
1425
1426 Redistribution and use in source and binary forms, with or without
1427 modification, are permitted provided that the following conditions are
1428 met:
1429
1430 * Redistributions of source code must retain the above copyright notice,
1431   this list of conditions and the following disclaimer.
1432
1433 * Redistributions in binary form must reproduce the above copyright
1434   notice, this list of conditions and the following disclaimer in the
1435   documentation and/or other materials provided with the distribution.
1436
1437 * Neither the name "Markdown" nor the names of its contributors may
1438   be used to endorse or promote products derived from this software
1439   without specific prior written permission.
1440
1441 This software is provided by the copyright holders and contributors "as
1442 is" and any express or implied warranties, including, but not limited
1443 to, the implied warranties of merchantability and fitness for a
1444 particular purpose are disclaimed. In no event shall the copyright owner
1445 or contributors be liable for any direct, indirect, incidental, special,
1446 exemplary, or consequential damages (including, but not limited to,
1447 procurement of substitute goods or services; loss of use, data, or
1448 profits; or business interruption) however caused and on any theory of
1449 liability, whether in contract, strict liability, or tort (including
1450 negligence or otherwise) arising in any way out of the use of this
1451 software, even if advised of the possibility of such damage.
1452
1453 =cut