root/tags/release_day_23/lib/markdown.php

<?php

#
# PHP Markdown Extra  -  A text-to-HTML conversion tool for web writers
#
# Copyright (c) 2004-2005 Michel Fortin  
# <http://www.michelf.com/projects/php-markdown/>
#
# Based on Markdown  
# Copyright (c) 2004-2005 John Gruber  
# <http://daringfireball.net/projects/markdown/>
#


global    $MarkdownPHPVersion, $MarkdownSyntaxVersion,
        $md_empty_element_suffix, $md_tab_width,
        $md_nested_brackets_depth, $md_nested_brackets, 
        $md_escape_table, $md_backslash_escape_table, 
        $md_list_level;

$MarkdownPHPVersion    = 'Extra 1.0'; # Mon 5 Sep 2005
$MarkdownSyntaxVersion = '1.0.1';  # Sun 12 Dec 2004


#
# Global default settings:
#
$md_empty_element_suffix = " />";     # Change to ">" for HTML output
$md_tab_width = 4;

#
# WordPress settings:
#
$md_wp_posts    = true;  # Set to false to remove Markdown from posts.
$md_wp_comments = true;  # Set to false to remove Markdown from comments.


# -- WordPress Plugin Interface -----------------------------------------------
/*
Plugin Name: PHP Markdown Extra
Plugin URI: http://www.michelf.com/projects/php-markdown/
Description: <a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://www.michelf.com/projects/php-markdown/">More...</a>
Version: Extra 1.0
Author: Michel Fortin
Author URI: http://www.michelf.com/
*/
if (isset($wp_version)) {
    # More details about how it works here:
    # <http://www.michelf.com/weblog/2005/wordpress-text-flow-vs-markdown/>
    
    # Post content and excerpts
    if ($md_wp_posts) {
        remove_filter('the_content',  'wpautop');
        remove_filter('the_excerpt',  'wpautop');
        add_filter('the_content',     'Markdown', 6);
        add_filter('get_the_excerpt', 'Markdown', 6);
        add_filter('get_the_excerpt', 'trim', 7);
        add_filter('the_excerpt',     'md_add_p');
        add_filter('the_excerpt_rss', 'md_strip_p');
        
        remove_filter('content_save_pre',  'balanceTags', 50);
        remove_filter('excerpt_save_pre',  'balanceTags', 50);
        add_filter('the_content',        'balanceTags', 50);
        add_filter('get_the_excerpt', 'balanceTags', 9);
        
        function md_add_p($text) {
            if (strlen($text) == 0) return;
            if (strcasecmp(substr($text, -3), '<p>') == 0) return $text;
            return '<p>'.$text.'</p>';
        }
        function md_strip_p($t) { return preg_replace('{</?[pP]>}', '', $t); }
    }
    
    # Comments
    if ($md_wp_comments) {
        remove_filter('comment_text', 'wpautop');
        remove_filter('comment_text', 'make_clickable');
        add_filter('pre_comment_content', 'Markdown', 6);
        add_filter('pre_comment_content', 'md_hide_tags', 8);
        add_filter('pre_comment_content', 'md_show_tags', 12);
        add_filter('get_comment_text',    'Markdown', 6);
        add_filter('get_comment_excerpt', 'Markdown', 6);
        add_filter('get_comment_excerpt', 'md_strip_p', 7);
    
        global $md_hidden_tags;
        $md_hidden_tags = array(
            '<p>'    => md5('<p>'),        '</p>'    => md5('</p>'),
            '<pre>'    => md5('<pre>'),    '</pre>'=> md5('</pre>'),
            '<ol>'    => md5('<ol>'),        '</ol>'    => md5('</ol>'),
            '<ul>'    => md5('<ul>'),        '</ul>'    => md5('</ul>'),
            '<li>'    => md5('<li>'),        '</li>'    => md5('</li>'),
            );
        
        function md_hide_tags($text) {
            global $md_hidden_tags;
            return str_replace(array_keys($md_hidden_tags), 
                                array_values($md_hidden_tags), $text);
        }
        function md_show_tags($text) {
            global $md_hidden_tags;
            return str_replace(array_values($md_hidden_tags), 
                                array_keys($md_hidden_tags), $text);
        }
    }
}


# -- bBlog Plugin Info --------------------------------------------------------
function identify_modifier_markdown() {
    global $MarkdownPHPVersion;
    return array(
        'name'            => 'markdown',
        'type'            => 'modifier',
        'nicename'        => 'PHP Markdown Extra',
        'description'    => 'A text-to-HTML conversion tool for web writers',
        'authors'        => 'Michel Fortin and John Gruber',
        'licence'        => 'GPL',
        'version'        => $MarkdownPHPVersion,
        'help'            => '<a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://www.michelf.com/projects/php-markdown/">More...</a>'
    );
}

# -- Smarty Modifier Interface ------------------------------------------------
function smarty_modifier_markdown($text) {
    return Markdown($text);
}

# -- Textile Compatibility Mode -----------------------------------------------
# Rename this file to "classTextile.php" and it can replace Textile anywhere.
if (strcasecmp(substr(__FILE__, -16), "classTextile.php") == 0) {
    # Try to include PHP SmartyPants. Should be in the same directory.
    @include_once 'smartypants.php';
    # Fake Textile class. It calls Markdown instead.
    class Textile {
        function TextileThis($text, $lite='', $encode='', $noimage='', $strict='') {
            if ($lite == '' && $encode == '')   $text = Markdown($text);
            if (function_exists('SmartyPants')) $text = SmartyPants($text);
            return $text;
        }
    }
}



#
# Globals:
#

# Regex to match balanced [brackets].
# Needed to insert a maximum bracked depth while converting to PHP.
$md_nested_brackets_depth = 6;
$md_nested_brackets = 
    str_repeat('(?>[^\[\]]+|\[', $md_nested_brackets_depth).
    str_repeat('\])*', $md_nested_brackets_depth);

# Table of hash values for escaped characters:
$md_escape_table = array(
    "\\" => md5("\\"),
    "`" => md5("`"),
    "*" => md5("*"),
    "_" => md5("_"),
    "{" => md5("{"),
    "}" => md5("}"),
    "[" => md5("["),
    "]" => md5("]"),
    "(" => md5("("),
    ")" => md5(")"),
    ">" => md5(">"),
    "#" => md5("#"),
    "+" => md5("+"),
    "-" => md5("-"),
    "." => md5("."),
    "!" => md5("!"),
    ":" => md5(":"),
    "|" => md5("|"),
);
# Create an identical table but for escaped characters.
$md_backslash_escape_table;
foreach ($md_escape_table as $key => $char)
    $md_backslash_escape_table["\\$key"] = $char;



function Markdown($text) {
#
# Main function. The order in which other subs are called here is
# essential. Link and image substitutions need to happen before
# _EscapeSpecialCharsWithinTagAttributes(), so that any *'s or _'s in the <a>
# and <img> tags get encoded.
#
    # Clear the global hashes. If we don't clear these, you get conflicts
    # from other articles when generating a page which contains more than
    # one article (e.g. an index page that shows the N most recent
    # articles):
    global $md_urls, $md_titles, $md_html_blocks, $md_html_hashes;
    $md_urls = array();
    $md_titles = array();
    $md_html_blocks = array();
    $md_html_hashes = array();

    # Standardize line endings:
    #   DOS to Unix and Mac to Unix
    $text = str_replace(array("\r\n", "\r"), "\n", $text);

    # Make sure $text ends with a couple of newlines:
    $text .= "\n\n";

    # Convert all tabs to spaces.
    $text = _Detab($text);

    # Turn block-level HTML blocks into hash entries
    $text = _HashHTMLBlocks($text);

    # Strip any lines consisting only of spaces and tabs.
    # This makes subsequent regexen easier to write, because we can
    # match consecutive blank lines with /\n+/ instead of something
    # contorted like /[ \t]*\n+/ .
    $text = preg_replace('/^[ \t]+$/m', '', $text);

    # Strip link definitions, store in hashes.
    $text = _StripLinkDefinitions($text);

    $text = _RunBlockGamut($text, FALSE);

    $text = _UnescapeSpecialChars($text);

    return $text . "\n";
}


function _StripLinkDefinitions($text) {
#
# Strips link definitions from text, stores the URLs and titles in
# hash references.
#
    global $md_tab_width;
    $less_than_tab = $md_tab_width - 1;

    # Link defs are in the form: ^[id]: url "optional title"
    $text = preg_replace_callback('{
                        ^[ ]{0,'.$less_than_tab.'}\[(.+)\]:    # id = $1
                          [ \t]*
                          \n?                # maybe *one* newline
                          [ \t]*
                        <?(\S+?)>?            # url = $2
                          [ \t]*
                          \n?                # maybe one newline
                          [ \t]*
                        (?:
                            (?<=\s)            # lookbehind for whitespace
                            ["(]
                            (.+?)            # title = $3
                            [")]
                            [ \t]*
                        )?    # title is optional
                        (?:\n+|\Z)
        }xm',
        '_StripLinkDefinitions_callback',
        $text);
    return $text;
}
function _StripLinkDefinitions_callback($matches) {
    global $md_urls, $md_titles;
    $link_id = strtolower($matches[1]);
    $md_urls[$link_id] = _EncodeAmpsAndAngles($matches[2]);
    if (isset($matches[3]))
        $md_titles[$link_id] = str_replace('"', '&quot;', $matches[3]);
    return ''; # String that will replace the block
}


function _HashHTMLBlocks($text) {
#
# Hashify HTML Blocks and "clean tags".
#
# We only want to do this for block-level HTML tags, such as headers,
# lists, and tables. That's because we still want to wrap <p>s around
# "paragraphs" that are wrapped in non-block-level tags, such as anchors,
# phrase emphasis, and spans. The list of tags we're looking for is
# hard-coded.
#
# This works by calling _HashHTMLBlocks_InMarkdown, which then calls
# _HashHTMLBlocks_InHTML when it encounter block tags. When the markdown="1" 
# attribute is found whitin a tag, _HashHTMLBlocks_InHTML calls back
#  _HashHTMLBlocks_InMarkdown to handle the Markdown syntax within the tag.
# These two functions are calling each other. It's recursive!
# 
    global    $block_tags, $context_block_tags, $contain_span_tags, 
            $clean_tags, $auto_close_tags;
    
    # Tags that are always treated as block tags:
    $block_tags = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|'.
                    'form|fieldset|iframe|hr|legend';
    
    # Tags treated as block tags only if the opening tag is alone on it's line:
    $context_block_tags = 'script|noscript|math|ins|del';
    
    # Tags where markdown="1" default to span mode:
    $contain_span_tags = 'p|h[1-6]|li|dd|dt|td|th|legend';
    
    # Tags which must not have their contents modified, no matter where 
    # they appear:
    $clean_tags = 'script|math';
    
    # Tags that do not need to be closed.
    $auto_close_tags = 'hr|img';
    
    # Regex to match any tag.
    global $tag_match;
    $tag_match =
        '{
            (                    # $2: Capture hole tag.
                </?                    # Any opening or closing tag.
                    [\w:$]+            # Tag name.
                    \s*                # Whitespace.
                    (?:
                        ".*?"        |    # Double quotes (can contain `>`)
                        \'.*?\'       |    # Single quotes (can contain `>`)
                        .+?                # Anything but quotes and `>`.
                    )*?
                >                    # End of tag.
            |
                <!--    .*?     -->    # HTML Comment
            |
                <\?     .*?     \?>    # Processing instruction
            |
                <!\[CDATA\[.*?\]\]>    # CData Block
            )
        }xs';
    
    #
    # Call the HTML-in-Markdown hasher.
    #
    list($text, ) = _HashHTMLBlocks_InMarkdown($text);
    
    return $text;
}
function _HashHTMLBlocks_InMarkdown($text, $indent = 0, 
                                    $enclosing_tag = '', $md_span = false)
{
#
# Parse markdown text, calling _HashHTMLBlocks_InHTML for block tags.
#
# *   $indent is the number of space to be ignored when checking for code 
#     blocks. This is important because if we don't take the indent into 
#     account, something like this (which looks right) won't work as expected:
#
#     <div>
#         <div markdown="1">
#         Hello World.  <-- Is this a Markdown code block or text?
#         </div>  <-- Is this a Markdown code block or a real tag?
#     <div>
#
#     If you don't like this, just don't indent the tag on which
#     you apply the markdown="1" attribute.
#
# *   If $enclosing_tag is not empty, stops at the first unmatched closing 
#     tag with that name. Nested tags supported.
#
# *   If $md_span is true, text inside must treated as span. So any double 
#     newline will be replaced by a single newline so that it does not create 
#     paragraphs.
#
# Returns an array of that form: ( processed text , remaining text )
#
    global    $block_tags, $context_block_tags, $clean_tags, $auto_close_tags,
            $tag_match;
    
    if ($text === '') return array('', '');

    # Regex to check for the presense of newlines around a block tag.
    $newline_match_before = "/(?:^\n?|\n\n) *$/";
    $newline_match_after = 
        '{
            ^                        # Start of text following the tag.
            (?:[ ]*<!--.*?-->)?        # Optional comment.
            [ ]*\n                    # Must be followed by newline.
        }xs';
    
    # Regex to match any tag.
    $block_tag_match =
        '{
            (                    # $2: Capture hole tag.
                </?                    # Any opening or closing tag.
                    (?:                # Tag name.
                        '.$block_tags.'            |
                        '.$context_block_tags.'    |
                        '.$clean_tags.'            |
                        (?!\s)'.$enclosing_tag.'
                    )
                    \s*                # Whitespace.
                    (?:
                        ".*?"        |    # Double quotes (can contain `>`)
                        \'.*?\'       |    # Single quotes (can contain `>`)
                        .+?                # Anything but quotes and `>`.
                    )*?
                >                    # End of tag.
            |
                <!--    .*?     -->    # HTML Comment
            |
                <\?     .*?     \?>    # Processing instruction
            |
                <!\[CDATA\[.*?\]\]>    # CData Block
            )
        }xs';

    
    $depth = 0;        # Current depth inside the tag tree.
    $parsed = "";    # Parsed text that will be returned.

    #
    # Loop through every tag until we find the closing tag of the parent
    # or loop until reaching the end of text if no parent tag specified.
    #
    do {
        #
        # Split the text using the first $tag_match pattern found.
        # Text before  pattern will be first in the array, text after
        # pattern will be at the end, and between will be any catches made 
        # by the pattern.
        #
        $parts = preg_split($block_tag_match, $text, 2, 
                            PREG_SPLIT_DELIM_CAPTURE);
        
        # If in Markdown span mode, replace any multiple newlines that would 
        # trigger a new paragraph.
        if ($md_span) {
            $parts[0] = preg_replace('/\n\n/', "\n", $parts[0]);
        }
        
        $parsed .= $parts[0]; # Text before current tag.
        
        # If end of $text has been reached. Stop loop.
        if (count($parts) < 3) {
            $text = "";
            break;
        }
        
        $tag  = $parts[1]; # Tag to handle.
        $text = $parts[2]; # Remaining text after current tag.
        
        #
        # Check for: Tag inside code block or span
        #
        if (# Find current paragraph
            preg_match('/(?>^\n?|\n\n)((?>.\n?)+?)$/', $parsed, $matches) &&
            (
            # Then match in it either a code block...
            preg_match('/^ {'.($indent+4).'}.*(?>\n {'.($indent+4).'}.*)*'.
                        '(?!\n)$/', $matches[1], $x) ||
            # ...or unbalenced code span markers. (the regex matches balenced)
            !preg_match('/^(?>[^`]+|(`+)(?>[^`]+|(?!\1[^`])`)*?\1(?!`))*$/s',
                         $matches[1])
            ))
        {
            # Tag is in code block or span and may not be a tag at all. So we
            # simply skip the first char (should be a `<`).
            $parsed .= $tag{0};
            $text = substr($tag, 1) . $text; # Put back $tag minus first char.
        }
        #
        # Check for: Opening Block level tag or
        #            Opening Content Block tag (like ins and del) 
        #               used as a block tag (tag is alone on it's line).
        #
        else if (preg_match("{^<(?:$block_tags)\b}", $tag) ||
            (    preg_match("{^<(?:$context_block_tags)\b}", $tag) &&
                preg_match($newline_match_before, $parsed) &&
                preg_match($newline_match_after, $text)    )
            )
        {
            # Need to parse tag and following text using the HTML parser.
            list($block_text, $text) = 
                _HashHTMLBlocks_InHTML($tag . $text,
                                    "_HashHTMLBlocks_HashBlock", TRUE);
            
            # Make sure it stays outside of any paragraph by adding newlines.
            $parsed .= "\n\n$block_text\n\n";
        }
        #
        # Check for: Clean tag (like script, math)
        #            HTML Comments, processing instructions.
        #
        else if (preg_match("{^<(?:$clean_tags)\b}", $tag) ||
            $tag{1} == '!' || $tag{1} == '?')
        {
            # Need to parse tag and following text using the HTML parser.
            # (don't check for markdown attribute)
            list($block_text, $text) = 
                _HashHTMLBlocks_InHTML($tag . $text, 
                                    "_HashHTMLBlocks_HashClean", FALSE);
            
            $parsed .= $block_text;
        }
        #
        # Check for: Tag with same name as enclosing tag.
        #
        else if ($enclosing_tag !== '' &&
            # Same name as enclosing tag.
            preg_match("{^</?(?:$enclosing_tag)\b}", $tag))
        {
            #
            # Increase/decrease nested tag count.
            #
            if ($tag{1} == '/')                        $depth--;
            else if ($tag{strlen($tag)-2} != '/')    $depth++;

            if ($depth < 0) {
                #
                # Going out of parent element. Clean up and break so we
                # return to the calling function.
                #
                $text = $tag . $text;
                break;
            }
            
            $parsed .= $tag;
        }
        else {
            $parsed .= $tag;
        }
    } while ($depth >= 0);
    
    return array($parsed, $text);
}
function _HashHTMLBlocks_InHTML($text, $hash_function, $md_attr) {
#
# Parse HTML, calling _HashHTMLBlocks_InMarkdown for block tags.
#
# *   Calls $hash_function to convert any blocks.
# *   Stops when the first opening tag closes.
# *   $md_attr indicate if the use of the `markdown="1"` attribute is allowed.
#     (it is not inside clean tags)
#
# Returns an array of that form: ( processed text , remaining text )
#
    global $auto_close_tags, $contain_span_tags, $tag_match;
    
    if ($text === '') return array('', '');
    
    # Regex to match `markdown` attribute inside of a tag.
    $markdown_attr_match = '
        {
            \s*            # Eat whitespace before the `markdown` attribute
            markdown
            \s*=\s*
            (["\'])        # $1: quote delimiter        
            (.*?)        # $2: attribute value
            \1            # matching delimiter    
        }xs';
    
    $original_text = $text;        # Save original text in case of faliure.
    
    $depth        = 0;    # Current depth inside the tag tree.
    $block_text    = "";    # Temporary text holder for current text.