RubyGems - radiant - Versions diffs - 0.5.2 → 0.6.0 - Mend

radiant 0.5.2 → 0.6.0

Potentially problematic release.

This version of radiant might be problematic. Click here for more details.

Files changed (1442) hide show

@@ -0,0 +1,99 @@
+BlueCloth
+=========
+Version 1.0.0 - 2004/08/24
+Original version by John Gruber <http://daringfireball.net/>.
+Ruby port by Michael Granger <http://www.deveiate.org/>.
+BlueCloth is a Ruby implementation of [Markdown][1], a text-to-HTML conversion
+tool for web writers. To quote from the project page: Markdown allows you to
+write using an easy-to-read, easy-to-write plain text format, then convert it to
+structurally valid XHTML (or HTML).
+It borrows a naming convention and several helpings of interface from
+[Redcloth][2], [Why the Lucky Stiff][3]'s processor for a similar text-to-HTML
+conversion syntax called [Textile][4].
+Installation
+------------
+You can install this module either by running the included `install.rb` script,
+or by simply copying `lib/bluecloth.rb` to a directory in your load path.
+Dependencies
+------------
+BlueCloth uses the `StringScanner` class from the `strscan` library, which comes
+with Ruby 1.8.x and later or may be downloaded from the RAA for earlier
+versions, and the `logger` library, which is also included in 1.8.x and later.
+Example Usage
+-------------
+The BlueCloth class is a subclass of Ruby's String, and can be used thusly:
+    bc = BlueCloth::new( str )
+    puts bc.to_html
+This `README` file is an example of Markdown syntax. The sample program
+`bluecloth` in the `bin/` directory can be used to convert this (or any other)
+file with Markdown syntax into HTML:
+    $ bin/bluecloth README > README.html
+Acknowledgements
+----------------
+This library is a port of the canonical Perl one, and so owes most of its
+functionality to its author, John Gruber. The bugs in this code are most
+certainly an artifact of my porting it and not an artifact of the excellent code
+from which it is derived.
+It also, as mentioned before, borrows its API liberally from RedCloth, both for
+compatibility's sake, and because I think Why's code is beautiful. His excellent
+code and peerless prose have been an inspiration to me, and this module is
+intended as the sincerest flattery.
+Also contributing to any success this module may enjoy are those among my peers
+who have taken the time to help out, either by submitting patches, testing, or
+offering suggestions and review:
+* Martin Chase <stillflame@FaerieMUD.org>
+* Florian Gross <flgr@ccan.de>
+Author/Legal
+------------
+Original version:
+Copyright (c) 2003-2004 John Gruber
+<http://daringfireball.net/>
+All rights reserved.
+Ruby version:
+Copyright (c) 2004 The FaerieMUD Consortium
+BlueCloth is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+BlueCloth is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+  [1]: http://daringfireball.net/projects/markdown/
+  [2]: http://www.whytheluckystiff.net/ruby/redcloth/
+  [3]: http://www.whytheluckystiff.net/
+  [4]: http://www.textism.com/tools/textile/
+$Id: README 65 2004-08-24 14:56:47Z ged $
+$URL: svn+ssh://svn.FaerieMUD.org/usr/local/svn/BlueCloth/trunk/README $

data/vendor/bluecloth/bin/bluecloth ADDED

@@ -0,0 +1,83 @@
+#!/usr/bin/ruby
+#
+# = bluecloth
+#
+# Format one or more text files with the markdown formatter.
+#
+# = Synopsis
+#
+#   bluecloth [OPTIONS] [FILES]
+#
+#
+#
+BEGIN {
+	require 'bluecloth'
+	require 'optparse'
+}
+DocumentWrapper = %{
+<html>
+  <head><title>%s</title></head>
+  <body>
+%s
+  </body>
+</html>
+}
+def main
+	fragment = false
+	destination = '.'
+	ARGV.options do |oparser|
+		oparser.banner = "Usage: #$0 [OPTIONS] FILES"
+		# Debug mode
+		oparser.on( "--debug", "-d", TrueClass, "Turn debugging output on" ) {
+			$DEBUG = true
+		}
+		# 'Fragment' mode
+		oparser.on( "--fragment", "-f", TrueClass,
+			"Output HTML fragments instead of whole documents" ) {
+			fragment = true
+		}
+		# Output destination
+		#oparser.on( "--output=DESTINATION", "-o DESTINATION", String,
+		#	"Write output to DESTINATION instead of the current directory" ) {|arg|
+		#	destination = arg
+		#}
+		oparser.parse!
+	end
+	# Filter mode if no arguments
+	ARGV.push( "-" ) if ARGV.empty?
+	ARGV.each {|file|
+		if file == '-'
+			contents = $stdin.readlines(nil)
+		else
+			contents = File::readlines( file, nil )
+		end
+		bc = BlueCloth::new( contents.join )
+		if fragment
+			$stdout.puts bc.to_html
+		else
+			$stdout.puts DocumentWrapper % [ file, bc.to_html ]
+		end
+	}
+rescue => err
+	$stderr.puts "Aborting: Fatal error: %s" % err.message
+	exit 255
+end
+main

data/vendor/bluecloth/install.rb ADDED

@@ -0,0 +1,150 @@
+#!/usr/bin/ruby
+#
+#	BlueCloth Module Install Script
+#	$Id: install.rb,v 1.3 2003/10/09 13:23:09 deveiant Exp $
+#
+#	Thanks to Masatoshi SEKI for ideas found in his install.rb.
+#
+#	Copyright (c) 2001-2004 The FaerieMUD Consortium.
+#
+#	This is free software. You may use, modify, and/or redistribute this
+#	software under the terms of the Perl Artistic License. (See
+#	http://language.perl.com/misc/Artistic.html)
+#
+require './utils.rb'
+include UtilityFunctions
+require 'rbconfig'
+include Config
+require 'find'
+require 'ftools'
+$version	= %q$Revision: 1.3 $
+$rcsId		= %q$Id: install.rb,v 1.3 2003/10/09 13:23:09 deveiant Exp $
+# Define required libraries
+RequiredLibraries = [
+	# libraryname, nice name, RAA URL, Download URL
+	[ 'strscan', "StrScan",
+		'http://raa.ruby-lang.org/list.rhtml?name=strscan',
+		'http://i.loveruby.net/archive/strscan/strscan-0.6.7.tar.gz' ],
+	[ 'logger', "Devel-Logger",
+		'http://raa.ruby-lang.org/list.rhtml?name=devel-logger',
+		'http://rrr.jin.gr.jp/download/devel-logger-1_2_2.tar.gz' ],
+]
+class Installer
+	@@PrunePatterns = [
+		/CVS/,
+		/~$/,
+		%r:(^|/)\.:,
+		/\.tpl$/,
+	]
+	def initialize( testing=false )
+		@ftools = (testing) ? self : File
+	end
+	### Make the specified dirs (which can be a String or an Array of Strings)
+	### with the specified mode.
+	def makedirs( dirs, mode=0755, verbose=false )
+		dirs = [ dirs ] unless dirs.is_a? Array
+		oldumask = File::umask
+		File::umask( 0777 - mode )
+		for dir in dirs
+			if @ftools == File
+				File::mkpath( dir, $verbose )
+			else
+				$stderr.puts "Make path %s with mode %o" % [ dir, mode ]
+			end
+		end
+		File::umask( oldumask )
+	end
+	def install( srcfile, dstfile, mode=nil, verbose=false )
+		dstfile = File.catname(srcfile, dstfile)
+		unless FileTest.exist? dstfile and File.cmp srcfile, dstfile
+			$stderr.puts "   install #{srcfile} -> #{dstfile}"
+		else
+			$stderr.puts "   skipping #{dstfile}: unchanged"
+		end
+	end
+	public
+	def installFiles( src, dstDir, mode=0444, verbose=false )
+		directories = []
+		files = []
+		if File.directory?( src )
+			Find.find( src ) {|f|
+				Find.prune if @@PrunePatterns.find {|pat| f =~ pat}
+				next if f == src
+				if FileTest.directory?( f )
+					directories << f.gsub( /^#{src}#{File::Separator}/, '' )
+					next
+				elsif FileTest.file?( f )
+					files << f.gsub( /^#{src}#{File::Separator}/, '' )
+				else
+					Find.prune
+				end
+			}
+		else
+			files << File.basename( src )
+			src = File.dirname( src )
+		end
+		dirs = [ dstDir ]
+		dirs |= directories.collect {|d| File.join(dstDir,d)}
+		makedirs( dirs, 0755, verbose )
+		files.each {|f|
+			srcfile = File.join(src,f)
+			dstfile = File.dirname(File.join( dstDir,f ))
+			if verbose
+				if mode
+					$stderr.puts "Install #{srcfile} -> #{dstfile} (mode %o)" % mode
+				else
+					$stderr.puts "Install #{srcfile} -> #{dstfile}"
+				end
+			end
+			@ftools.install( srcfile, dstfile, mode, verbose )
+		}
+	end
+end
+if $0 == __FILE__
+	header "BlueCloth Installer #$version"
+	for lib in RequiredLibraries
+		testForRequiredLibrary( *lib )
+	end
+	viewOnly = ARGV.include? '-n'
+	verbose = ARGV.include? '-v'
+	debugMsg "Sitelibdir = '#{CONFIG['sitelibdir']}'"
+	sitelibdir = CONFIG['sitelibdir']
+	debugMsg "Sitearchdir = '#{CONFIG['sitearchdir']}'"
+	sitearchdir = CONFIG['sitearchdir']
+	message "Installing\n"
+	i = Installer.new( viewOnly )
+	i.installFiles( "lib", sitelibdir, 0444, verbose )
+end

data/vendor/bluecloth/lib/bluecloth.rb ADDED

@@ -0,0 +1,1144 @@
+#!/usr/bin/ruby
+#
+# Bluecloth is a Ruby implementation of Markdown, a text-to-HTML conversion
+# tool.
+#
+# == Synopsis
+#
+#   doc = BlueCloth::new "
+#     ## Test document ##
+#
+#     Just a simple test.
+#   "
+#
+#   puts doc.to_html
+#
+# == Authors
+#
+# * Michael Granger <ged@FaerieMUD.org>
+#
+# == Contributors
+#
+# * Martin Chase <stillflame@FaerieMUD.org> - Peer review, helpful suggestions
+# * Florian Gross <flgr@ccan.de> - Filter options, suggestions
+#
+# == Copyright
+#
+# Original version:
+#   Copyright (c) 2003-2004 John Gruber
+#   <http://daringfireball.net/>
+#   All rights reserved.
+#
+# Ruby port:
+#   Copyright (c) 2004 The FaerieMUD Consortium.
+#
+# BlueCloth is free software; you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# BlueCloth is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# == To-do
+#
+# * Refactor some of the larger uglier methods that have to do their own
+#   brute-force scanning because of lack of Perl features in Ruby's Regexp
+#   class. Alternately, could add a dependency on 'pcre' and use most Perl
+#   regexps.
+#
+# * Put the StringScanner in the render state for thread-safety.
+#
+# == Version
+#
+#  $Id: bluecloth.rb 69 2004-08-25 05:27:15Z ged $
+#
+require 'digest/md5'
+require 'logger'
+require 'strscan'
+### BlueCloth is a Ruby implementation of Markdown, a text-to-HTML conversion
+### tool.
+class BlueCloth < String
+	### Exception class for formatting errors.
+	class FormatError < RuntimeError
+		### Create a new FormatError with the given source +str+ and an optional
+		### message about the +specific+ error.
+		def initialize( str, specific=nil )
+			if specific
+				msg = "Bad markdown format near %p: %s" % [ str, specific ]
+			else
+				msg = "Bad markdown format near %p" % str
+			end
+			super( msg )
+		end
+	end
+	# Release Version
+	Version = '0.0.3'
+	# SVN Revision
+	SvnRev = %q$Rev: 69 $
+	# SVN Id tag
+	SvnId = %q$Id: bluecloth.rb 69 2004-08-25 05:27:15Z ged $
+	# SVN URL
+	SvnUrl = %q$URL: svn+ssh://svn.faeriemud.org/usr/local/svn/BlueCloth/trunk/lib/bluecloth.rb $
+	# Rendering state struct. Keeps track of URLs, titles, and HTML blocks
+	# midway through a render. I prefer this to the globals of the Perl version
+	# because globals make me break out in hives. Or something.
+	RenderState = Struct::new( "RenderState", :urls, :titles, :html_blocks, :log )
+	# Tab width for #detab! if none is specified
+	TabWidth = 4
+	# The tag-closing string -- set to '>' for HTML
+	EmptyElementSuffix = "/>";
+	# Table of MD5 sums for escaped characters
+	EscapeTable = {}
+	'\\`*_{}[]()#.!'.split(//).each {|char|
+		hash = Digest::MD5::hexdigest( char )
+		EscapeTable[ char ] = {
+ 			:md5 => hash,
+			:md5re => Regexp::new( hash ),
+			:re  => Regexp::new( '\\\\' + Regexp::escape(char) ),
+		}
+	}
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+	### Create a new BlueCloth string.
+	def initialize( content="", *restrictions )
+		@log = Logger::new( $deferr )
+		@log.level = $DEBUG ?
+			Logger::DEBUG :
+			($VERBOSE ? Logger::INFO : Logger::WARN)
+		@scanner = nil
+		# Add any restrictions, and set the line-folding attribute to reflect
+		# what happens by default.
+		@filter_html = nil
+		@filter_styles = nil
+		restrictions.flatten.each {|r| __send__("#{r}=", true) }
+		@fold_lines = true
+		super( content )
+		@log.debug "String is: %p" % self
+	end
+	######
+	public
+	######
+	# Filters for controlling what gets output for untrusted input. (But really,
+	# you're filtering bad stuff out of untrusted input at submission-time via
+	# untainting, aren't you?)
+	attr_accessor :filter_html, :filter_styles
+	# RedCloth-compatibility accessor. Line-folding is part of Markdown syntax,
+	# so this isn't used by anything.
+	attr_accessor :fold_lines
+	### Render Markdown-formatted text in this string object as HTML and return
+	### it. The parameter is for compatibility with RedCloth, and is currently
+	### unused, though that may change in the future.
+	def to_html( lite=false )
+		# Create a StringScanner we can reuse for various lexing tasks
+		@scanner = StringScanner::new( '' )
+		# Make a structure to carry around stuff that gets placeholdered out of
+		# the source.
+		rs = RenderState::new( {}, {}, {} )
+		# Make a copy of the string with normalized line endings, tabs turned to
+		# spaces, and a couple of guaranteed newlines at the end
+		text = self.gsub( /\r\n?/, "\n" ).detab
+		text += "\n\n"
+		@log.debug "Normalized line-endings: %p" % text
+		# Filter HTML if we're asked to do so
+		if self.filter_html
+			text.gsub!( "<", "&lt;" )
+			text.gsub!( ">", "&gt;" )
+			@log.debug "Filtered HTML: %p" % text
+		end
+		# Simplify blank lines
+		text.gsub!( /^ +$/, '' )
+		@log.debug "Tabs -> spaces/blank lines stripped: %p" % text
+		# Replace HTML blocks with placeholders
+		text = hide_html_blocks( text, rs )
+		@log.debug "Hid HTML blocks: %p" % text
+		@log.debug "Render state: %p" % rs
+		# Strip link definitions, store in render state
+		text = strip_link_definitions( text, rs )
+		@log.debug "Stripped link definitions: %p" % text
+		@log.debug "Render state: %p" % rs
+		# Escape meta-characters
+		text = escape_special_chars( text )
+		@log.debug "Escaped special characters: %p" % text
+		# Transform block-level constructs
+		text = apply_block_transforms( text, rs )
+		@log.debug "After block-level transforms: %p" % text
+		# Now swap back in all the escaped characters
+		text = unescape_special_chars( text )
+		@log.debug "After unescaping special characters: %p" % text
+		return text
+	end
+	### Convert tabs in +str+ to spaces.
+	def detab( tabwidth=TabWidth )
+		copy = self.dup
+		copy.detab!( tabwidth )
+		return copy
+	end
+	### Convert tabs to spaces in place and return self if any were converted.
+	def detab!( tabwidth=TabWidth )
+		newstr = self.split( /\n/ ).collect {|line|
+			line.gsub( /(.*?)\t/ ) do
+				$1 + ' ' * (tabwidth - $1.length % tabwidth)
+			end
+		}.join("\n")
+		self.replace( newstr )
+	end
+	#######
+	#private
+	#######
+	### Do block-level transforms on a copy of +str+ using the specified render
+	### state +rs+ and return the results.
+	def apply_block_transforms( str, rs )
+		# Port: This was called '_runBlockGamut' in the original
+		@log.debug "Applying block transforms to:\n  %p" % str
+		text = transform_headers( str, rs )
+		text = transform_hrules( text, rs )
+		text = transform_lists( text, rs )
+		text = transform_code_blocks( text, rs )
+		text = transform_block_quotes( text, rs )
+		text = transform_auto_links( text, rs )
+		text = hide_html_blocks( text, rs )
+		text = form_paragraphs( text, rs )
+		@log.debug "Done with block transforms:\n  %p" % text
+		return text
+	end
+	### Apply Markdown span transforms to a copy of the specified +str+ with the
+	### given render state +rs+ and return it.
+	def apply_span_transforms( str, rs )
+		@log.debug "Applying span transforms to:\n  %p" % str
+		str = transform_code_spans( str, rs )
+		str = encode_html( str )
+		str = transform_images( str, rs )
+		str = transform_anchors( str, rs )
+		str = transform_italic_and_bold( str, rs )
+		# Hard breaks
+		str.gsub!( / {2,}\n/, "<br#{EmptyElementSuffix}\n" )
+		@log.debug "Done with span transforms:\n  %p" % str
+		return str
+	end
+	# The list of tags which are considered block-level constructs and an
+	# alternation pattern suitable for use in regexps made from the list
+	StrictBlockTags = %w[ p div h[1-6] blockquote pre table dl ol ul script noscript
+		form fieldset iframe math ins del ]
+	StrictTagPattern = StrictBlockTags.join('|')
+	LooseBlockTags = StrictBlockTags - %w[ins del]
+	LooseTagPattern = LooseBlockTags.join('|')
+	# Nested blocks:
+	# 	<div>
+	# 		<div>
+	# 		tags for inner block must be indented.
+	# 		</div>
+	# 	</div>
+	StrictBlockRegex = %r{
+		^						# Start of line
+		<(#{StrictTagPattern})	# Start tag: \2
+		\b						# word break
+		(.*\n)*?				# Any number of lines, minimal match
+		</\1>					# Matching end tag
+		[ ]*					# trailing spaces
+		$						# End of line or document
+	  }ix
+	# More-liberal block-matching
+	LooseBlockRegex = %r{
+		^						# Start of line
+		<(#{LooseTagPattern})	# start tag: \2
+		\b						# word break
+		(.*\n)*?				# Any number of lines, minimal match
+		.*</\1>					# Anything + Matching end tag
+		[ ]*					# trailing spaces
+		$						# End of line or document
+	  }ix
+	# Special case for <hr />.
+	HruleBlockRegex = %r{
+		(						# $1
+			\A\n?				# Start of doc + optional \n
+			|					# or
+			.*\n\n				# anything + blank line
+		)
+		(						# save in $2
+			[ ]*				# Any spaces
+			<hr					# Tag open
+			\b					# Word break
+			([^<>])*?			# Attributes
+			/?>					# Tag close
+			$					# followed by a blank line or end of document
+		)
+	  }ix
+	### Replace all blocks of HTML in +str+ that start in the left margin with
+	### tokens.
+	def hide_html_blocks( str, rs )
+		@log.debug "Hiding HTML blocks in %p" % str
+		# Tokenizer proc to pass to gsub
+		tokenize = lambda {|match|
+			key = Digest::MD5::hexdigest( match )
+			rs.html_blocks[ key ] = match
+			@log.debug "Replacing %p with %p" % [ match, key ]
+			"\n\n#{key}\n\n"
+		}
+		rval = str.dup
+		@log.debug "Finding blocks with the strict regex..."
+		rval.gsub!( StrictBlockRegex, &tokenize )
+		@log.debug "Finding blocks with the loose regex..."
+		rval.gsub!( LooseBlockRegex, &tokenize )
+		@log.debug "Finding hrules..."
+		rval.gsub!( HruleBlockRegex ) {|match| $1 + tokenize[$2] }
+		return rval
+	end
+	# Link defs are in the form: ^[id]: url "optional title"
+	LinkRegex = %r{
+		^[ ]*\[(.+)\]:		# id = $1
+		  [ ]*
+		  \n?				# maybe *one* newline
+		  [ ]*
+		<?(\S+?)>?				# url = $2
+		  [ ]*
+		  \n?				# maybe one newline
+		  [ ]*
+		(?:
+			# Titles are delimited by "quotes" or (parens).
+			["(]
+			(.+?)			# title = $3
+			[")]			# Matching ) or "
+			[ ]*
+		)?	# title is optional
+		(?:\n+|\Z)
+	  }x
+	### Strip link definitions from +str+, storing them in the given RenderState
+	### +rs+.
+	def strip_link_definitions( str, rs )
+		str.gsub( LinkRegex ) {|match|
+			id, url, title = $1, $2, $3
+			rs.urls[ id.downcase ] = encode_html( url )
+			unless title.nil?
+				rs.titles[ id.downcase ] = title.gsub( /"/, "&quot;" )
+			end
+			""
+		}
+	end
+	### Escape special characters in the given +str+
+	def escape_special_chars( str )
+		@log.debug "  Escaping special characters"
+		text = ''
+		# The original Markdown source has something called '$tags_to_skip'
+		# declared here, but it's never used, so I don't define it.
+		tokenize_html( str ) {|token, str|
+			@log.debug "   Adding %p token %p" % [ token, str ]
+			case token
+			# Within tags, encode * and _
+			when :tag
+				text += str.
+					gsub( /\*/, EscapeTable['*'][:md5] ).
+					gsub( /_/, EscapeTable['_'][:md5] )
+			# Encode backslashed stuff in regular text
+			when :text
+				text += encode_backslash_escapes( str )
+			else
+				raise TypeError, "Unknown token type %p" % token
+			end
+		}
+		@log.debug "  Text with escapes is now: %p" % text
+		return text
+	end
+	### Swap escaped special characters in a copy of the given +str+ and return
+	### it.
+	def unescape_special_chars( str )
+		EscapeTable.each {|char, hash|
+			@log.debug "Unescaping escaped %p with %p" % [ char, hash[:md5re] ]
+			str.gsub!( hash[:md5re], char )
+		}
+		return str
+	end
+	### Return a copy of the given +str+ with any backslashed special character
+	### in it replaced with MD5 placeholders.
+	def encode_backslash_escapes( str )
+		# Make a copy with any double-escaped backslashes encoded
+		text = str.gsub( /\\\\/, EscapeTable['\\'][:md5] )
+		EscapeTable.each_pair {|char, esc|
+			next if char == '\\'
+			text.gsub!( esc[:re], esc[:md5] )
+		}
+		return text
+	end
+	### Transform any Markdown-style horizontal rules in a copy of the specified
+	### +str+ and return it.
+	def transform_hrules( str, rs )
+		@log.debug " Transforming horizontal rules"
+		str.gsub( /^( ?[\-\*_] ?){3,}$/, "\n<hr#{EmptyElementSuffix}\n" )
+	end
+	# Patterns to match and transform lists
+	ListMarkerOl = %r{\d+\.}
+	ListMarkerUl = %r{[*+-]}
+	ListMarkerAny = Regexp::union( ListMarkerOl, ListMarkerUl )
+	ListRegexp = %r{
+		  (?:
+			^[ ]{0,#{TabWidth - 1}}		# Indent < tab width
+			(#{ListMarkerAny})			# unordered or ordered ($1)
+			[ ]+						# At least one space
+		  )
+		  (?m:.+?)						# item content (include newlines)
+		  (?:
+			  \z						# Either EOF
+			|							#  or
+			  \n{2,}					# Blank line...
+			  (?=\S)					# ...followed by non-space
+			  (?![ ]*					# ...but not another item
+				(#{ListMarkerAny})
+			   [ ]+)
+		  )
+	  }x
+	### Transform Markdown-style lists in a copy of the specified +str+ and
+	### return it.
+	def transform_lists( str, rs )
+		@log.debug " Transforming lists at %p" % (str[0,100] + '...')
+		str.gsub( ListRegexp ) {|list|
+			@log.debug "  Found list %p" % list
+			bullet = $1
+			list_type = (ListMarkerUl.match(bullet) ? "ul" : "ol")
+			list.gsub!( /\n{2,}/, "\n\n\n" )
+			%{<%s>\n%s</%s>\n} % [
+				list_type,
+				transform_list_items( list, rs ),
+				list_type,
+			]
+		}
+	end
+	# Pattern for transforming list items
+	ListItemRegexp = %r{
+		(\n)?							# leading line = $1
+		(^[ ]*)							# leading whitespace = $2
+		(#{ListMarkerAny}) [ ]+			# list marker = $3
+		((?m:.+?)						# list item text   = $4
+		(\n{1,2}))
+		(?= \n* (\z | \2 (#{ListMarkerAny}) [ ]+))
+	  }x
+	### Transform list items in a copy of the given +str+ and return it.
+	def transform_list_items( str, rs )
+		@log.debug " Transforming list items"
+		# Trim trailing blank lines
+		str = str.sub( /\n{2,}\z/, "\n" )
+		str.gsub( ListItemRegexp ) {|line|
+			@log.debug "  Found item line %p" % line
+			leading_line, item = $1, $4
+			if leading_line or /\n{2,}/.match( item )
+				@log.debug "   Found leading line or item has a blank"
+				item = apply_block_transforms( outdent(item), rs )
+			else
+				# Recursion for sub-lists
+				@log.debug "   Recursing for sublist"
+				item = transform_lists( outdent(item), rs ).chomp
+				item = apply_span_transforms( item, rs )
+			end
+			%{<li>%s</li>\n} % item
+		}
+	end
+	# Pattern for matching codeblocks
+	CodeBlockRegexp = %r{
+		(?:\n\n|\A)
+		(									# $1 = the code block
+		  (?:
+			(?:[ ]{#{TabWidth}} | \t)		# a tab or tab-width of spaces
+			.*\n+
+		  )+
+		)
+		(^[ ]{0,#{TabWidth - 1}}\S|\Z)		# Lookahead for non-space at
+											# line-start, or end of doc
+	  }x
+	### Transform Markdown-style codeblocks in a copy of the specified +str+ and
+	### return it.
+	def transform_code_blocks( str, rs )
+		@log.debug " Transforming code blocks"
+		str.gsub( CodeBlockRegexp ) {|block|
+			codeblock = $1
+			remainder = $2
+			# Generate the codeblock
+			%{\n\n<pre><code>%s\n</code></pre>\n\n%s} %
+				[ encode_code( outdent(codeblock), rs ).rstrip, remainder ]
+		}
+	end
+	# Pattern for matching Markdown blockquote blocks
+	BlockQuoteRegexp = %r{
+		  (?:
+			^[ ]*>[ ]?		# '>' at the start of a line
+			  .+\n			# rest of the first line
+			(?:.+\n)*		# subsequent consecutive lines
+			\n*				# blanks
+		  )+
+	  }x
+	PreChunk = %r{ ( ^ \s* <pre> .+? </pre> ) }xm
+	### Transform Markdown-style blockquotes in a copy of the specified +str+
+	### and return it.
+	def transform_block_quotes( str, rs )
+		@log.debug " Transforming block quotes"
+		str.gsub( BlockQuoteRegexp ) {|quote|
+			@log.debug "Making blockquote from %p" % quote
+			quote.gsub!( /^ *> ?/, '' ) # Trim one level of quoting
+			quote.gsub!( /^ +$/, '' )	# Trim whitespace-only lines
+			indent = " " * TabWidth
+			quoted = %{<blockquote>\n%s\n</blockquote>\n\n} %
+				apply_block_transforms( quote, rs ).
+				gsub( /^/, indent ).
+				gsub( PreChunk ) {|m| m.gsub(/^#{indent}/o, '') }
+			@log.debug "Blockquoted chunk is: %p" % quoted
+			quoted
+		}
+	end
+	AutoAnchorURLRegexp = /<((https?|ftp):[^'">\s]+)>/
+	AutoAnchorEmailRegexp = %r{
+		<
+		(
+			[-.\w]+
+			\@
+			[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
+		)
+		>
+	  }xi
+	### Transform URLs in a copy of the specified +str+ into links and return
+	### it.
+	def transform_auto_links( str, rs )
+		@log.debug " Transforming auto-links"
+		str.gsub( AutoAnchorURLRegexp, %{<a href="\\1">\\1</a>}).
+			gsub( AutoAnchorEmailRegexp ) {|addr|
+			encode_email_address( unescape_special_chars($1) )
+		}
+	end
+	# Encoder functions to turn characters of an email address into encoded
+	# entities.
+	Encoders = [
+		lambda {|char| "&#%03d;" % char},
+		lambda {|char| "&#x%X;" % char},
+		lambda {|char| char.chr },
+	]
+	### Transform a copy of the given email +addr+ into an escaped version safer
+	### for posting publicly.
+	def encode_email_address( addr )
+		rval = ''
+		("mailto:" + addr).each_byte {|b|
+			case b
+			when ?:
+				rval += ":"
+			when ?@
+				rval += Encoders[ rand(2) ][ b ]
+			else
+				r = rand(100)
+				rval += (
+					r > 90 ? Encoders[2][ b ] :
+					r < 45 ? Encoders[1][ b ] :
+							 Encoders[0][ b ]
+				)
+			end
+		}
+		return %{<a href="%s">%s</a>} % [ rval, rval.sub(/.+?:/, '') ]
+	end
+	# Regex for matching Setext-style headers
+	SetextHeaderRegexp = %r{
+		(.+)			# The title text ($1)
+		\n
+		([\-=])+		# Match a line of = or -. Save only one in $2.
+		[ ]*\n+
+	   }x
+	# Regexp for matching ATX-style headers
+	AtxHeaderRegexp = %r{
+		^(\#{1,6})	# $1 = string of #'s
+		[ ]*
+		(.+?)		# $2 = Header text
+		[ ]*
+		\#*			# optional closing #'s (not counted)
+		\n+
+	  }x
+	### Apply Markdown header transforms to a copy of the given +str+ amd render
+	### state +rs+ and return the result.
+	def transform_headers( str, rs )
+		@log.debug " Transforming headers"
+		# Setext-style headers:
+		#	  Header 1
+		#	  ========
+		#
+		#	  Header 2
+		#	  --------
+		#
+		str.
+			gsub( SetextHeaderRegexp ) {|m|
+				@log.debug "Found setext-style header"
+				title, hdrchar = $1, $2
+				title = apply_span_transforms( title, rs )
+				case hdrchar
+				when '='
+					%[<h1>#{title}</h1>\n\n]
+				when '-'
+					%[<h2>#{title}</h2>\n\n]
+				else
+					title
+				end
+			}.
+			gsub( AtxHeaderRegexp ) {|m|
+				@log.debug "Found ATX-style header"
+				hdrchars, title = $1, $2
+				title = apply_span_transforms( title, rs )
+				level = hdrchars.length
+				%{<h%d>%s</h%d>\n\n} % [ level, title, level ]
+			}
+	end
+	### Wrap all remaining paragraph-looking text in a copy of +str+ inside <p>
+	### tags and return it.
+	def form_paragraphs( str, rs )
+		@log.debug " Forming paragraphs"
+		grafs = str.
+			sub( /\A\n+/, '' ).
+			sub( /\n+\z/, '' ).
+			split( /\n{2,}/ )
+		rval = grafs.collect {|graf|
+			# Unhashify HTML blocks if this is a placeholder
+			if rs.html_blocks.key?( graf )
+				rs.html_blocks[ graf ]
+			# Otherwise, wrap in <p> tags
+			else
+				apply_span_transforms(graf, rs).
+					sub( /^[ ]*/, '<p>' ) + '</p>'
+			end
+		}.join( "\n\n" )
+		@log.debug " Formed paragraphs: %p" % rval
+		return rval
+	end
+	# Pattern to match the linkid part of an anchor tag for reference-style
+	# links.
+	RefLinkIdRegex = %r{
+		[ ]?					# Optional leading space
+		(?:\n[ ]*)?				# Optional newline + spaces
+		\[
+			(.*?)				# Id = $1
+		\]
+	  }x
+	InlineLinkRegex = %r{
+		\(						# Literal paren
+			[ ]*				# Zero or more spaces
+			<?(.+?)>?			# URI = $1
+			[ ]*				# Zero or more spaces
+			(?:					#
+				([\"\'])		# Opening quote char = $2
+				(.*?)			# Title = $3
+				\2				# Matching quote char
+			)?					# Title is optional
+		\)
+	  }x
+	### Apply Markdown anchor transforms to a copy of the specified +str+ with
+	### the given render state +rs+ and return it.
+	def transform_anchors( str, rs )
+		@log.debug " Transforming anchors"
+		@scanner.string = str.dup
+		text = ''
+		# Scan the whole string
+		until @scanner.empty?
+			if @scanner.scan( /\[/ )
+				link = ''; linkid = ''
+				depth = 1
+				startpos = @scanner.pos
+				@log.debug " Found a bracket-open at %d" % startpos
+				# Scan the rest of the tag, allowing unlimited nested []s. If
+				# the scanner runs out of text before the opening bracket is
+				# closed, append the text and return (wasn't a valid anchor).
+				while depth.nonzero?
+					linktext = @scanner.scan_until( /\]|\[/ )
+					if linktext
+						@log.debug "  Found a bracket at depth %d: %p" % [ depth, linktext ]
+						link += linktext
+						# Decrement depth for each closing bracket
+						depth += ( linktext[-1, 1] == ']' ? -1 : 1 )
+						@log.debug "  Depth is now #{depth}"
+					# If there's no more brackets, it must not be an anchor, so
+					# just abort.
+					else
+						@log.debug "  Missing closing brace, assuming non-link."
+						link += @scanner.rest
+						@scanner.terminate
+						return text + '[' + link
+					end
+				end
+				link.slice!( -1 ) # Trim final ']'
+				@log.debug " Found leading link %p" % link
+				# Look for a reference-style second part
+				if @scanner.scan( RefLinkIdRegex )
+					linkid = @scanner[1]
+					linkid = link.dup if linkid.empty?
+					linkid.downcase!
+					@log.debug "  Found a linkid: %p" % linkid
+					# If there's a matching link in the link table, build an
+					# anchor tag for it.
+					if rs.urls.key?( linkid )
+						@log.debug "   Found link key in the link table: %p" % rs.urls[linkid]
+						url = escape_md( rs.urls[linkid] )
+						text += %{<a href="#{url}"}
+						if rs.titles.key?(linkid)
+							text += %{ title="%s"} % escape_md( rs.titles[linkid] )
+						end
+						text += %{>#{link}</a>}
+					# If the link referred to doesn't exist, just append the raw
+					# source to the result
+					else
+						@log.debug "  Linkid %p not found in link table" % linkid
+						@log.debug "  Appending original string instead: "
+						@log.debug "%p" % @scanner.string[ startpos-1 .. @scanner.pos-1 ]
+						text += @scanner.string[ startpos-1 .. @scanner.pos-1 ]
+					end
+				# ...or for an inline style second part
+				elsif @scanner.scan( InlineLinkRegex )
+					url = @scanner[1]
+					title = @scanner[3]
+					@log.debug "  Found an inline link to %p" % url
+					text += %{<a href="%s"} % escape_md( url )
+					if title
+						title.gsub!( /"/, "&quot;" )
+						text += %{ title="%s"} % escape_md( title )
+					end
+					text += %{>#{link}</a>}
+				# No linkid part: just append the first part as-is.
+				else
+					@log.debug "No linkid, so no anchor. Appending literal text."
+					text += @scanner.string[ startpos-1 .. @scanner.pos-1 ]
+				end # if linkid
+			# Plain text
+			else
+				@log.debug " Scanning to the next link from %p" % @scanner.rest
+				text += @scanner.scan( /[^\[]+/ )
+			end
+		end # until @scanner.empty?
+		return text
+	end
+	# Pattern to match strong emphasis in Markdown text
+	BoldRegexp = %r{ (\*\*|__) (\S|\S.+?\S) \1 }x
+	# Pattern to match normal emphasis in Markdown text
+	ItalicRegexp = %r{ (\*|_) (\S|\S.+?\S) \1 }x
+	### Transform italic- and bold-encoded text in a copy of the specified +str+
+	### and return it.
+	def transform_italic_and_bold( str, rs )
+		@log.debug " Transforming italic and bold"
+		str.
+			gsub( BoldRegexp, %{<strong>\\2</strong>} ).
+			gsub( ItalicRegexp, %{<em>\\2</em>} )
+	end
+	### Transform backticked spans into <code> spans.
+	def transform_code_spans( str, rs )
+		@log.debug " Transforming code spans"
+		# Set up the string scanner and just return the string unless there's at
+		# least one backtick.
+		@scanner.string = str.dup
+		unless @scanner.exist?( /`/ )
+			@scanner.terminate
+			@log.debug "No backticks found for code span in %p" % str
+			return str
+		end
+		@log.debug "Transforming code spans in %p" % str
+		# Build the transformed text anew
+		text = ''
+		# Scan to the end of the string
+		until @scanner.empty?
+			# Scan up to an opening backtick
+			if pre = @scanner.scan_until( /.?(?=`)/m )
+				text += pre
+				@log.debug "Found backtick at %d after '...%s'" % [ @scanner.pos, text[-10, 10] ]
+				# Make a pattern to find the end of the span
+				opener = @scanner.scan( /`+/ )
+				len = opener.length
+				closer = Regexp::new( opener )
+				@log.debug "Scanning for end of code span with %p" % closer
+				# Scan until the end of the closing backtick sequence. Chop the
+				# backticks off the resultant string, strip leading and trailing
+				# whitespace, and encode any enitites contained in it.
+				codespan = @scanner.scan_until( closer ) or
+					raise FormatError::new( @scanner.rest[0,20],
+						"No %p found before end" % opener )
+				@log.debug "Found close of code span at %d: %p" % [ @scanner.pos - len, codespan ]
+				codespan.slice!( -len, len )
+				text += "<code>%s</code>" %
+					encode_code( codespan.strip, rs )
+			# If there's no more backticks, just append the rest of the string
+			# and move the scan pointer to the end
+			else
+				text += @scanner.rest
+				@scanner.terminate
+			end
+		end
+		return text
+	end
+	# Next, handle inline images:  ![alt text](url "optional title")
+	# Don't forget: encode * and _
+	InlineImageRegexp = %r{
+		(					# Whole match = $1
+			!\[ (.*?) \]	# alt text = $2
+		  \([ ]*
+			<?(\S+?)>?		# source url = $3
+		    [ ]*
+			(?:				#
+			  (["'])		# quote char = $4
+			  (.*?)			# title = $5
+			  \4			# matching quote
+			  [ ]*
+			)?				# title is optional
+		  \)
+		)
+	  }xs #"
+	# Reference-style images
+	ReferenceImageRegexp = %r{
+		(					# Whole match = $1
+			!\[ (.*?) \]	# Alt text = $2
+			[ ]?			# Optional space
+			(?:\n[ ]*)?		# One optional newline + spaces
+			\[ (.*?) \]		# id = $3
+		)
+	  }xs
+	### Turn image markup into image tags.
+	def transform_images( str, rs )
+		@log.debug " Transforming images" % str
+		# Handle reference-style labeled images: ![alt text][id]
+		str.
+			gsub( ReferenceImageRegexp ) {|match|
+				whole, alt, linkid = $1, $2, $3.downcase
+				@log.debug "Matched %p" % match
+				res = nil
+				alt.gsub!( /"/, '&quot;' )
+				# for shortcut links like ![this][].
+				linkid = alt.downcase if linkid.empty?
+				if rs.urls.key?( linkid )
+					url = escape_md( rs.urls[linkid] )
+					@log.debug "Found url '%s' for linkid '%s' " % [ url, linkid ]
+					# Build the tag
+					result = %{<img src="%s" alt="%s"} % [ url, alt ]
+					if rs.titles.key?( linkid )
+						result += %{ title="%s"} % escape_md( rs.titles[linkid] )
+					end
+					result += EmptyElementSuffix
+				else
+					result = whole
+				end
+				@log.debug "Replacing %p with %p" % [ match, result ]
+				result
+			}.
+			# Inline image style
+			gsub( InlineImageRegexp ) {|match|
+				@log.debug "Found inline image %p" % match
+				whole, alt, title = $1, $2, $5
+				url = escape_md( $3 )
+				alt.gsub!( /"/, '&quot;' )
+				# Build the tag
+				result = %{<img src="%s" alt="%s"} % [ url, alt ]
+				unless title.nil?
+					title.gsub!( /"/, '&quot;' )
+					result += %{ title="%s"} % escape_md( title )
+				end
+				result += EmptyElementSuffix
+				@log.debug "Replacing %p with %p" % [ match, result ]
+				result
+			}
+	end
+	# Regexp to match special characters in a code block
+	CodeEscapeRegexp = %r{( \* | _ | \{ | \} | \[ | \] | \\ )}x
+	### Escape any characters special to HTML and encode any characters special
+	### to Markdown in a copy of the given +str+ and return it.
+	def encode_code( str, rs )
+		str.gsub( %r{&}, '&amp;' ).
+			gsub( %r{<}, '&lt;' ).
+			gsub( %r{>}, '&gt;' ).
+			gsub( CodeEscapeRegexp ) {|match| EscapeTable[match][:md5]}
+	end
+	#################################################################
+	###	U T I L I T Y   F U N C T I O N S
+	#################################################################
+	### Escape any markdown characters in a copy of the given +str+ and return
+	### it.
+	def escape_md( str )
+		str.
+			gsub( /\*/, EscapeTable['*'][:md5] ).
+			gsub( /_/,  EscapeTable['_'][:md5] )
+	end
+	# Matching constructs for tokenizing X/HTML
+	HTMLCommentRegexp  = %r{ <! ( -- .*? -- \s* )+ > }mx
+	XMLProcInstRegexp  = %r{ <\? .*? \?> }mx
+	MetaTag = Regexp::union( HTMLCommentRegexp, XMLProcInstRegexp )
+	HTMLTagOpenRegexp  = %r{ < [a-z/!$] [^<>]* }imx
+	HTMLTagCloseRegexp = %r{ > }x
+	HTMLTagPart = Regexp::union( HTMLTagOpenRegexp, HTMLTagCloseRegexp )
+	### Break the HTML source in +str+ into a series of tokens and return
+	### them. The tokens are just 2-element Array tuples with a type and the
+	### actual content. If this function is called with a block, the type and
+	### text parts of each token will be yielded to it one at a time as they are
+	### extracted.
+	def tokenize_html( str )
+		depth = 0
+		tokens = []
+		@scanner.string = str.dup
+		type, token = nil, nil
+		until @scanner.empty?
+			@log.debug "Scanning from %p" % @scanner.rest
+			# Match comments and PIs without nesting
+			if (( token = @scanner.scan(MetaTag) ))
+				type = :tag
+			# Do nested matching for HTML tags
+			elsif (( token = @scanner.scan(HTMLTagOpenRegexp) ))
+				tagstart = @scanner.pos
+				@log.debug " Found the start of a plain tag at %d" % tagstart
+				# Start the token with the opening angle
+				depth = 1
+				type = :tag
+				# Scan the rest of the tag, allowing unlimited nested <>s. If
+				# the scanner runs out of text before the tag is closed, raise
+				# an error.
+				while depth.nonzero?
+					# Scan either an opener or a closer
+					chunk = @scanner.scan( HTMLTagPart ) or
+						raise "Malformed tag at character %d: %p" %
+							[ tagstart, token + @scanner.rest ]
+					@log.debug "  Found another part of the tag at depth %d: %p" % [ depth, chunk ]
+					token += chunk
+					# If the last character of the token so far is a closing
+					# angle bracket, decrement the depth. Otherwise increment
+					# it for a nested tag.
+					depth += ( token[-1, 1] == '>' ? -1 : 1 )
+					@log.debug "  Depth is now #{depth}"
+				end
+			# Match text segments
+			else
+				@log.debug " Looking for a chunk of text"
+				type = :text
+				# Scan forward, always matching at least one character to move
+				# the pointer beyond any non-tag '<'.
+				token = @scanner.scan_until( /[^<]+/m )
+			end
+			@log.debug " type: %p, token: %p" % [ type, token ]
+			# If a block is given, feed it one token at a time. Add the token to
+			# the token list to be returned regardless.
+			if block_given?
+				yield( type, token )
+			end
+			tokens << [ type, token ]
+		end
+		return tokens
+	end
+	### Return a copy of +str+ with angle brackets and ampersands HTML-encoded.
+	def encode_html( str )
+		str.gsub( /&(?!#?[x]?(?:[0-9a-f]+|\w+);)/i, "&amp;" ).
+			gsub( %r{<(?![a-z/?\$!])}i, "&lt;" )
+	end
+	### Return one level of line-leading tabs or spaces from a copy of +str+ and
+	### return it.
+	def outdent( str )
+		str.gsub( /^(\t|[ ]{1,#{TabWidth}})/, '')
+	end
+end # class BlueCloth