owlscribble 0.9.0

data/examples/markup.owl

@@ -0,0 +1,300 @@
+= Table of Contents =
+##TableOfContents##
+
+= Welcome to OWLScribble! =
+//An introduction to the ~OWLScribble markup language.//
+
+== What is OWLScribble? ==
+~OWLScribble is a wiki markup language //based on// the markup used by [hTTp://www.openwiki.org/ OpenWiki]. It was designed for use with the ~SewWiki project by GavinKistner.
+
+== Supported Markup ==
+=== Paragraphs ===
+{{{
+Paragraphs start on a line of their own
+and may be continued onto multiple
+consecutive lines.
+
+A double line break indicates the start
+of a new paragraph.
+
+  If the start of the text is indented at all,
+  however, then it is treated as preformatted
+  text.
+}}}
+
+Paragraphs start on a line of their own
+and may be continued onto multiple
+consecutive lines.
+
+A double line break indicates the start
+of a new paragraph.
+
+  If the start of the text is indented at all,
+  however, then it is treated as preformatted
+  text.
+==== Indented Paragraphs ====
+{{{
+  : An exception to the indented-paragraph rule is this.
+    : Paragraphs (on a single line)
+    : with whitespace preceding a colon
+    : are indented based on the amount of space
+  : But, as seen here, each line is its own paragraph.
+}}}
+
+  : An exception to the indented-paragraph rule is this.
+    : Paragraphs (on a single line)
+    : with whitespace preceding a colon
+    : are indented based on the amount of space
+  : But, as seen here, each line is its own paragraph.
+
+=== Preformatted Text ===
+{{{
+   {{{
+   for ( var i=0; i<10; ++i ){
+     alert( 'hi!' );
+   }
+   }}}
+}}}
+
+   {{{
+   for ( var i=0; i<10; ++i ){
+     alert( 'hi!' );
+   }
+   }}}
+
+To be clear about the start and end, you may
+specify preformatted text by wrapping it in
+@@{{{...}}}@@ over multiple lines.
+
+Such text is automatically unindented by the
+amount of indentation on the end markers.
+
+
+=== Basic Inline Styling ===
+{{{
+This text **is bold**, this //is italic//,
+and --this has been struck--.
+
+//You can start a paragraph with an inline
+style, but you cannot wrap it across lines.//
+
+This is a @@code reference@@,
+as is {{{this text}}}.
+
+A double-exclamation point is a special
+'todo' item. !!Add more examples!!
+
+You can also ^^superscript^^ and
+__subscript__ text, like H__2__O
+or e^^pi*i^^.
+}}}
+
+This text **is bold**, this //is italic//,
+and --this has been struck--.
+
+//You can start a paragraph with an inline
+style, but you cannot wrap it across lines.//
+
+This is a @@code reference@@,
+as is {{{this text}}}.
+
+A double-exclamation point is a special
+'todo' item. !!Add more examples!!
+
+You can also ^^superscript^^ and
+__subscript__ text, like H__2__O
+or e^^pi*i^^.
+
+  * //Unlike ~OpenWiki, you are not allowed to underline text. Sorry, but underlining is reserved for links in hyperlinked documents.//
+
+=== Headings ===
+{{{
+= Heading Level 1 =
+== Heading Level 2 ==
+=== Heading Level 3 ===
+==== Heading Level 4 ====
+===== Heading Level 5 =====
+====== Heading Level 6 ======
+}}}
+Headings must begin at the start of the line. Markup inside headings is ignored. (For example,
+{{{== My //Sweet// Heading ==}}} will not make the word italic, but will instead show the {{{//}}} characters in the output.)
+
+=== Linking ===
+{{{
+ * Visit SiteMap, HomePage, or WhereDoIBegin to get started.
+ * Visit the [[What is a Wiki?]] page if you're really lost.
+ * Visit hTTp://www.google.com to find stuff on the web.
+ * The [hTTp://www.microsoft.com company that shall not be named] thinks they can beat Google.
+ * This page was edited by [GavinKistner the Wiki Gardener].
+ * See [[[Foo/Bar/Jim/Jam]] the Jam page] for more deliciousness.
+}}}
+ * Visit SiteMap, HomePage, or WhereDoIBegin to get started.
+ * Visit the [[What is a Wiki?]] page if you're really lost.
+ * Visit hTTp://www.google.com to find stuff on the web.
+ * The [hTTp://www.microsoft.com company that shall not be named] thinks they can beat Google.
+ * This page was edited by [GavinKistner the Wiki Gardener].
+ * See [[[Foo/Bar/Jim/Jam]] the Jam page] for more deliciousness.
+
+~OWLScribble supports three styles of specifying a link:
+  1. Text that looks like ~URLs are automatically linked. You must use a capital 'T' and lowercase letters in the protocol to get it recognized. (It's annoying, but designed to stop spam bots.) So http://www.google.com/ will not be linked, but {{{hTTp://www.google.com}}} will yield: hTTp://www.google.com
+    * //Supported protocols are http, https, and ftp.//
+  2. **~WikiWords** are automatically treated as links to other pages in the Wiki, and expanded out. For example, typing {{{CapitalizedWordsScrunchedTogether}}} produces "CapitalizedWordsScrunchedTogether".
+    * //The ~OWLScribble class simply turns the above into the 'HTML' code: {{{<wiki_link page="CapitalizedWordsScrunchedTogether">Capitalized Words Scrunched Together</wiki_link>}}}. It is up to the consumer of ~OWLScribble to run through the {{{#wiki_links}}} collection and replace the above with something reasonable (such as an HTML anchor) after doing whatever it needs to do (such as a db lookup).//
+  3. If you want to create a wiki page whose name doesn't look like a ~WikiWord, you can wrap it in double square brackets, like {{{See the [[Table of Contents]] page}}}.
+    * //Again, ~OWLScribble turns the above into: {{{<wiki_link page="Table of Contents">Table of Contents</wiki_link>}}}, leaving it up to the consumer of ~OWLScribble to change that tag into something better.//
+    * As seen in the last example above, you can use the double-square-bracket wiki link style along with outer brackets to supply different page text. ~OWLScribble turns the last example above into: {{{<wiki_link page="Foo/Bar/Jim/Jam">the Jam page</wiki_link>}}}.//
+
+With either ~URLs or ~WikiWords, you can optionally use an alternative description for the link text. As shown above, place a single set of square brackets around what you want linked, with the URL or ~WikiWord as the first item.
+
+==== Preventing Linking ====
+{{{
+Sometimes you want to write something that looks like a
+~WikiWord (such as ~OpenWiki) but you don't want it to
+appear as a link to a page in the wiki.
+
+You can either wrap it in preformatted text delimiters
+like @@{{{OpenWiki}}}@@, or place a tilde (~) character right
+before it, as in {{{~OpenWiki}}}.
+}}}
+
+Sometimes you want to write something that looks like a
+~WikiWord (such as ~OpenWiki) but you don't want it to
+appear as a link to a page in the wiki.
+
+You can either wrap it in preformatted text delimiters
+like @@{{{OpenWiki}}}@@, or place a tilde (~) character right
+before it, as in {{{~OpenWiki}}}.
+
+
+=== Lists ===
+
+==== Bulleted Lists ====
+{{{
+         1         2         3         4         5         6     
+12345678901234567890123456789012345678901234567890123456789012345
+  * Bullet lists need **at least one space** before the asterisk.
+    * **A space** must appear after the asterisk.
+      * They may be nested to an arbitrary depth.
+  * Tabs may also be used for indentation.
+  * Mixing tabs and spaces is asking for trouble.
+}}}
+
+  * Bullet lists need **at least one space** before the asterisk.
+    * **A space** must appear after the asterisk.
+      * They may be nested to an arbitrary depth.
+  * Tabs may also be used for indentation.
+  * Mixing tabs and spaces is asking for trouble.
+
+==== Numbered Lists ====
+{{{
+         1         2         3         4         5         6     
+12345678901234567890123456789012345678901234567890123456789012345
+  1. Numbered lists must also have a space before the number.
+  1. The actual number doesn't matter...
+    3. ...but the period after the number does.
+    1. As well as the space after the period.
+  # You can also use the 'octothorp' if you like.
+    # //(A fancy name for the 'sharp' or 'pound' symbol.)
+  # Other types of numbered lists are supported beyond arabic.
+    a. For arabic lists, you can use 1, 2, 3, ... 23, etc.
+    a. but for the following, you must use the actual character.
+    a. A lowercase 'a' is for lowercase alphabetical lists.
+    A. An uppercase 'A' is for uppercase alphabetical lists.
+    i. A lowercase 'i' is for lowercase roman numeral lists.
+    I. An uppercase 'I' is for uppercase roman numeral lists.
+}}}
+
+  1. Numbered lists must also have a space before the number.
+  1. The actual number doesn't matter...
+    3. ...but the period after the number does.
+    1. As well as the space after the period.
+  # You can also use the 'octothorp' if you like.
+    # //(A fancy name for the 'sharp' or 'pound' symbol.)
+  # Other types of numbered lists are supported beyond arabic.
+    a. For arabic lists, you can use 1, 2, 3, ... 23, etc.
+    a. but for the following, you must use the actual character.
+    a. A lowercase 'a' is for lowercase alphabetical lists.
+    A. An uppercase 'A' is for uppercase alphabetical lists.
+    i. A lowercase 'i' is for lowercase roman numeral lists.
+    I. An uppercase 'I' is for uppercase roman numeral lists.
+
+
+==== Mixing Lists ====
+{{{
+         1         2         3         4         5         
+12345678901234567890123456789012345678901234567890123456789
+  * Bulleted and numbered lists may be alternately nested
+    1. And (as seen above)...
+    i. ...you can mix numbered list styles on the fly
+  * But woe unto you if you try to mix a bullet...
+  1. ...and a number in the same list.
+    * //Sorry buddy, but that doesn't fly.//
+}}}
+
+ * Bulleted and numbered lists may be alternately nested
+   1. And (as seen above)...
+   i. ...you can mix numbered list styles on the fly
+ * But woe unto you if you try to mix a bullet...
+ 1. ...and a number in the same list.
+   * //Sorry buddy, but that doesn't fly.//
+
+
+==== Definition Lists ====
+{{{
+         1         2         3         4         5         
+12345678901234567890123456789012345678901234567890123456789
+  ; Semantic : of or relating to meaning in language
+  ; Grok : to understand //completely//
+  ;      : to inherently and almost intuitively comprehend
+}}}
+
+  ; Semantic : of or relating to meaning in language
+  ; Grok : to understand //completely//
+  ;      : to inherently and almost intuitively comprehend
+
+  * //Unlike ~OpenWiki, you cannot 'nest' or indent definition lists.//
+
+=== Tables ===
+{{{
+|| **Age** || **Sex** || **Weight** ||
+|| 32      ||    M    ||        180 ||
+|| 30 || F || 150 ||
+|||| //average// || **165** ||
+}}}
+
+|| **Age** || **Sex** || **Weight** ||
+|| 32      ||    M    ||        180 ||
+|| 30 || F || 150 ||
+|||| //average// || **165** ||
+
+You don't have to line up the bars from one row to the next, but you may
+if you want the text representation to look clean. As seen above,
+you can cause a cell to span multiple columns.
+
+== Processing Directives ==
+A processing directive appears as a pair of pound symbols with a command
+inside, optionally followed by parameters to that command inside
+parentheses. For example:
+
+{{{
+##TableOfContents##
+##IncludePage(ProcessingDirectives)##
+}}}
+
+~OWLScribble currently recognizes the following directives:
+  * {{{##TableOfContents##}}} - replaces the directive with a nested list representing the hierarchy of headers in the document, with links to those headers
+  
+  * {{{##DEPRECATED##}}} - indicates that the document is no longer needed, and should be removed
+  
+  * {{{##BALETED##}}} - //same as DEPRECATED//
+  
+  * {{{##IncludePage(PageName)##}}} - indicates that the contents of the other page should be included in this location
+
+Note that ~OWLScribble only handles the {{{TableOfContents}}} directive natively. The other directives are replaced with an empty non-HTML 'wiki_command' tag, such as {{{<wiki_command do="TableOfContents" />}}} or {{{<wiki_command do="IncludePage" param="CommonFooter" />}}}. It is up to the consumer of ~OWLScribble to handle and/or replace such tags with meaningful information.
+
+  : //There are two ways to handle these tags. One way is to parse and modify the HTML produced by ~OWLScribble as a string. This is effective, but not recommended.//
+  : //The recommended mechanism for handling processing directives is to spin through the {{{#wiki_commands}}} collection of the ~OWLScribble object after initialization, processing the commands and replacing the tags as desired. Once this is done, call the {{{#to_s}}} or {{{#to_html}}} methods on the ~OWLScribble instance to get the final output.//
+  
+
+== Miscellaneous ==
+HTML entities are not needed (and do not work) inside ~OWLScribble; you can type {{{"this & that"}}} and it will produce the HTML {{{this &amp; that}}}, displaying as "this & that". Typing {{{&amp;}}} will actually show "&amp;".

data/examples/scribblify.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'owlscribble'
+
+file_name = ARGV[0] || 'markup.owl'
+
+require 'cgi'
+OWLScribble.each_wiki_link{ |tag, page_name, link_text|
+  tag.name  = 'a'
+  tag.href  = "dummylinktopage?#{CGI.escape(page_name)}"
+  tag.class = "newwikilink"
+}
+
+markup = IO.read( file_name )
+owl = OWLScribble.new( markup )
+p owl if $DEBUG
+
+html = owl.to_html
+
+require 'erb'
+File.open( file_name.gsub( /[^.]+$/, 'html' ), "w+" ){ |out|
+	File.open( 'template.rhtml', 'r' ){ |template|
+		page_title = nil
+		page_contents = html
+		out << ERB.new( template.read ).result( binding )
+	}
+}

data/examples/template.rhtml

@@ -0,0 +1,37 @@
+<html><head><title><%=page_title || 'Welcome to the Jungle'%></title>
+<style type="text/css">
+	body	{ margin:1em 2em; font-size:90%; font-family:'Trebuchet MS', serif; margin-bottom:30em }
+
+	a:link, a:visited	{ color:#009 }
+	a.newwikilink	{ color:#900 }
+	
+	h1,h2,h3,h4,h5,h6	{ margin-bottom:0.2em; margin-top:2em; border-bottom:1px solid #999; font-family:sans-serif }
+	h1	{ font-size:120% }
+	h2	{ font-size:110% }
+	h3,h4	{ font-size:100% }
+	h5,h6	{ font-size:90% }
+	h4,h5,h6 	{ font-style:italic }
+
+	ul, ol	{ margin:0; padding:0; margin-left:1.5em; margin-bottom:0.8em }
+	ul ol, ol ul, ul ul, ol ol 	{ margin-left:1.5em }
+	li	{ margin-bottom:0 }
+	p	{ margin:0; margin-bottom:0.7em }
+	pre	{ background:#ffd; padding:0.5em; border:1px solid #993 }
+	.todo	{ font-weight:bold; color:#900 }
+	.section	{ margin-left:1em }
+	table	{ border-collapse:collapse; margin-bottom:1em }
+	td	{ border:1px solid #ccc; padding:0.1em 0.5em; font-size:85% }
+	pre, code, tt	{ color:#060 }
+
+	dt	{ font-weight:bold }
+
+	.indent1	{ margin-left:2em }
+	.indent2	{ margin-left:4em }
+	.indent3	{ margin-left:6em }
+	.indent4	{ margin-left:8em }
+	.indent5	{ margin-left:10em }
+	.indent6	{ margin-left:12em }
+</style>
+</head><body>
+<%=page_contents%>
+</body></html>

data/lib/owlscribble.rb

@@ -0,0 +1,715 @@
+#--
+# *** This code is copyright 2005 by Gavin Kistner
+# *** It is covered under the license viewable at http://phrogz.net/JS/_ReuseLicense.txt
+# *** Reuse or modification is free provided you abide by the terms of that license.
+# *** (Including the first two lines above in your source code usually satisfies the conditions.)
+#++
+# This file covers the OWLScribble class, and extensions to the String class needed by it.
+# Please see the documentation on those classes for more information.
+#
+# See the link:../examples/markup.html file for details on the OWLScribble markup.
+
+require 'rubygems'
+gem 'tagtreescanner', '>=0.8'
+require 'tagtreescanner'
+
+# OWLScribble converts a specific set of text markup into HTML.
+# (The syntax used in the markup is a knockoff of the markup used by
+# OpenWiki, so the 'OWL' in OWLScribble means "OpenWiki-like".)
+#
+# See the README.txt file for more information.
+#
+# For details on the markup used by OWLScribble, please see the link:../examples/markup.html file.
+class OWLScribble < TagTreeScanner
+  VERSION = "0.9.0"
+  
+  attr_reader :list_items #:nodoc:
+  attr_reader :headers #:nodoc:
+
+  # An array of <tt><wiki_command></tt> tags representing directives to the wiki.
+  # <i>(See "Wiki Commands" above.)</i>
+  attr_reader :wiki_commands
+
+  # An array of <tt><wiki_link></tt> tags repesenting links to wiki pages.
+  # <i>(See "Wiki Links" above.)</i>
+  attr_reader :wiki_links
+
+  # A nested unordered list representing the hierarchy of the document, with links to the sections.
+  # <i>(See "Table of Contents" above.)</i>
+  attr_reader :table_of_contents
+  
+  @root_factory = TagFactory.new( :root,
+    :allowed_genre => :block,
+    :allows_text => false )
+
+  # Letters and numbers cannot be mixed with whitespace due to http:// as opener.
+  @text_match = /[a-z0-9]+|[ \t]+|./mi
+
+  @tag_genres[ :block ] = [ ]
+  @tag_genres[ :table ] = [ ]
+  @tag_genres[ :td ] = [ ]
+  @tag_genres[ :deflist ] = [ ]
+  @tag_genres[ :inline ] = [ ]
+
+  # == My Heading ==  ->  <h2>My Heading</h2>
+  @tag_genres[ :block ] << TagFactory.new( :heading,
+    :open_match => /(={1,6}) +(.+) +\1[ \t]*\n/, :open_requires_bol => true,
+    :setup => lambda{ |tag, ss, owl|
+      depth = ss[1].length
+      tag.name = "h#{depth}"
+      tag.info[ :header_depth ] = depth
+      tag << ss[2]
+      owl.headers << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  #   * This is a bullet  ->  <li>This is a bullet</li>
+  # (The private #reparent_lists method adds <ul>...</ul>)
+  @tag_genres[ :block ] << TagFactory.new( :li,
+    :open_match => /([ \t]+)\* /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.info[ :level ] = ss[1].length
+      tag.info[ :list_type ] = :ul
+      owl.list_items << tag
+    },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  #   # Make functional  ->  <li>Make functional</li>
+  # (The private #reparent_lists method adds <ol>...</ol>)
+  @tag_genres[ :block ] << TagFactory.new( :li,
+    :open_match => /([ \t]+)# /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.info[ :level ] =  ss[1].length
+      tag.info[ :list_type ] = :ol
+      owl.list_items << tag
+    },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  #   2. Add good comments  ->  <li>Add good comments</li>
+  # (The private #reparent_lists method adds <ol>...</ol>)
+  @tag_genres[ :block ] << TagFactory.new( :li,
+    :open_match => /([ \t]+)\d+\. /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.info[ :level ] =  ss[1].length
+      tag.info[ :list_type ] = :ol
+      owl.list_items << tag
+    },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  #   a. alpha 1  ->  <li type="a">alpha 1</li>
+  #   A. ALPHA 2  ->  <li type="A">ALPHA 2</li>
+  #   i. roman 3  ->  <li type="i">roman 3</li>
+  #   I. ROMAN 4  ->  <li type="I">ROMAN 4</li>
+  # (The private #reparent_lists method adds <ol>...</ol>)
+  @tag_genres[ :block ] << TagFactory.new( :li,
+    :open_match => /([ \t]+)([aAiI])\. /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.attributes[ :type ] = ss[2]
+      tag.info[ :level ] = ss[1].length
+      tag.info[ :list_type ] = :ol
+      owl.list_items << tag
+    },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  #   ; Semantic : relating to meaning  ->  <dl><dt>Semantic</dt><dd>relating to meaning</dd></dl>
+  # ( requires the :dt and :dd matches in the :deflist genre )
+  @tag_genres[ :block ] << TagFactory.new( :dl,
+    :open_match => /(?=[ \t]+; .+ : )/, :open_requires_bol => true,
+    :close_match => /(?![ \t]+; .+ : )/, :close_requires_bol => true,
+    :allowed_genre => :deflist
+  )
+
+  # {{{
+  # This is a multi-line
+  # code block
+  # }}}
+  # -> <pre>This is a multi-line
+  #    code block</pre>
+  @tag_genres[ :block ] << TagFactory.new( :pre,
+    :open_match => /^([ \t]*)\{\{\{\n(.+?)\n\1\}\}\}\n/m, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl| tag << ss[2].gsub( /^#{ss[1]}/, '' ) },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # || Age || Sex ||
+  # || 32  ||  M  ||
+  # -> <table><tr><td>Age</td><td>Sex</td></tr><tr><td>32</td><td>M</td></tr></table>
+  # ( requires the :tr factory in the :table genre, and the :td factory in the :td genre )
+  @tag_genres[ :block ] << TagFactory.new( :table,
+    :open_match => /(?=\|\|)/, :open_requires_bol => true,
+    :close_match => /(?=[^|])/, :close_requires_bol => true,
+    :allowed_genre => :table
+  )
+
+  #   : Indented Text!  ->  <p class="indent2">Indented Text!</p>
+  @tag_genres[ :block ] << TagFactory.new( :p,
+    :open_match => /((  )+) ?: /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :setup => lambda{ |tag, ss, owl| tag.attributes[ :class ] = "indent#{ss[1].length/2}" },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # ##TableOfContents##  ->  <wiki_command do="TableOfContents" />
+  @tag_genres[ :block ] << TagFactory.new( :wiki_command,
+    :open_match => /##TableOfContents##/, :open_requires_bol => true,
+    :setup => lambda{ |tag, ss, owl|
+      tag.attributes[ :do ] = "TableOfContents"
+      owl.wiki_commands << tag
+    },
+    :autoclose => true
+  )
+
+  # ##SomeCommand## or ##Command2( param1, param2 )##
+  @tag_genres[ :block ] << TagFactory.new( :wiki_command,
+    :open_match => /##(\w+)(?:\s*\(\s*(.+?)\s*\))?##/, :open_requires_bol => true,
+    :setup => lambda{ |tag, ss, owl|
+      command = ss[1]
+      params  = ss[2] ? ss[2].split( /,\s*/ ) : []
+      owl.process_wiki_command( tag, command, params )
+      owl.wiki_commands << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # ----  ->  <hr />
+  @tag_genres[ :block ] << TagFactory.new( :hr,
+    :open_match => /-{4,} *\n/, :open_requires_bol => true,
+    :autoclose => true
+  )
+
+  # All other lines that begin with non-whitespace start a paragraph
+  @tag_genres[ :block ] << TagFactory.new( :p,
+    :open_match => /(?=\S)/, :open_requires_bol => true,
+    # Stop the paragraph for a double-newline or a line that looks like a list or header start
+    :close_match => /\n(?:\n|(?=[ \t]+(?:[*aiAI#]|\d+\.) )|(?=(={1,6}) +.+ +\1[ \t]*\n))/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # All other lines that begin with whitespace and have non-whitespace
+  # content later start a preformatted block
+  @tag_genres[ :block ] << TagFactory.new( :pre,
+    :open_match => /([ \t]+)([^\n]*\S.+?)^(?=\S)/m, :open_requires_bol => true,
+    :setup => lambda{ |tag, ss, owl|
+      tag << ss[2].gsub( /^#{ss[1]}/, '' )
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+
+  # (see the :table factory in :block genre)
+  @tag_genres[ :table ] << TagFactory.new( :tr,
+    :open_match => /(?=\|\|)/, :open_requires_bol => true,
+    :close_match => /\|\|[ \t]*\n/,
+    :allowed_genre => :td
+  )
+
+
+  # (see the :table factory in :block genre)
+  @tag_genres[ :td ] << TagFactory.new( :td,
+    :open_match => /((?:\|\|)+)\s*/,
+    :close_match => /(?=\s*\|\|)/,
+    :setup => lambda{ |tag, ss, owl|
+      colspan = ss[1].length / 2
+      tag.attributes[ :colspan ] =  colspan unless colspan < 2
+    },
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+
+  # (see the :dl factory in :block genre)
+  @tag_genres[ :deflist ] << TagFactory.new( :dd,
+    :open_match => /[ \t]+;\s+: /, :open_requires_bol => true,
+    :close_match => /\n/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+  @tag_genres[ :deflist ] << TagFactory.new( :dt,
+    :open_match => /[ \t]+; /, :open_requires_bol => true,
+    :close_match => / : /,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+  @tag_genres[ :deflist ] << TagFactory.new( :dd,
+    :open_match => /(?=.)/,
+    :close_match => /\n/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+
+  # This is **bold text**  ->  This is <b>bold text</b>
+  @tag_genres[ :inline ] << TagFactory.new( :b,
+    # Close up if we see a newline to prevent a typo from propagating too far
+    :open_match => /\*\*/, :close_match => /\*\*|(?=\n)/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # This is //italic text//  ->  This is <i>italic text</i>
+  @tag_genres[ :inline ] << TagFactory.new( :i,
+    # Close up if we see a newline to prevent a typo from propagating too far
+    :open_match => /\/\//, :close_match => /\/\/|(?=\n)/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # This is @@literal text@@  ->  This is <tt>literal text</tt>
+  @tag_genres[ :inline ] << TagFactory.new( :tt,
+    :open_match => /@@([^\n]+?)@@/,
+    :setup => lambda{ |tag, ss, owl| tag << ss[1] },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # This is {{{also literal text}}}  ->  This is <tt>also literal text</tt>
+  @tag_genres[ :inline ] << TagFactory.new( :tt,
+    :open_match => /\{\{\{([^\n]+?)\}\}\}/,
+    :setup => lambda{ |tag, ss, owl| tag << ss[1] },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # hTTp://www.google.com  ->  <a href="hTTp://www.google.com">www.google.com</a>
+  # Require capital 'T' as a lame way to fight spammers
+  @tag_genres[ :inline ] << TagFactory.new( :a,
+    :open_match => /(?:hTTp|fTp|hTTps):\/\/(\S+)/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.attributes[ :href ] = ss[0]
+      tag << ss[1]
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # http://www.google.com  ->  http://www.google.com
+  # ensure that double-slash from non-link doesn't start italics
+  @tag_genres[ :inline ] << TagFactory.new( :span,
+    :open_match => /(?:http|ftp|https):\/\/(\S+)/i,
+    :setup => lambda{ |tag, ss, owl|
+      tag << ss[0]
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # [hTTp://www.google.com Google is cool!] ->  <a href="hTTp://www.google.com">Google is cool!</a>
+  # Require capital 'T' as a lame way to fight spammers
+  @tag_genres[ :inline ] << TagFactory.new( :a,
+    :open_match => /\[((?:hTTp|fTp|hTTps):\/\/\S+) +([^\]]+)\]/,
+    :setup => lambda{ |tag, ss, owl|
+      tag.attributes[ :href ] = ss[1]
+      tag << ss[2]
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # See the WhatWeShouldDo page  ->  See the <wiki_link page="WhatWeShouldDo">What We Should Do</wiki_link> page
+  # OWLScribble#wiki_links gives you a collection; use Tag#replace_with to swap in what you want before #to_html.
+  @tag_genres[ :inline ] << TagFactory.new( :wiki_link,
+    :open_match => /[A-Z]{2,}[a-z][a-zA-Z]*|[A-Z][a-z]+[A-Z][a-zA-Z]*/,
+    :setup => lambda{ |tag, ss, owl|
+      owl.process_wiki_link( tag, ss[0], ss[0].dewikiword )
+      owl.wiki_links << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # See [[[Crazy! Go Nuts!]] this cool page]  ->  See the <wiki_link page="Crazy! Go Nuts!">this cool page</wiki_link> page
+  # OWLScribble#wiki_links gives you a collection; use Tag#replace_with to swap in what you want before #to_html.
+  @tag_genres[ :inline ] << TagFactory.new( :wiki_link,
+    :open_match => /\[\[\[(.{2,}?)\]\] ([^\]]+)\]/,
+    :setup => lambda{ |tag, ss, owl|
+      owl.process_wiki_link( tag, ss[1], ss[2].dewikiword )
+      owl.wiki_links << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # See the [[Crazy! Go Nuts!]] page  ->  See the <wiki_link page="Crazy! Go Nuts!">Crazy! Go Nuts!</wiki_link> page
+  # OWLScribble#wiki_links gives you a collection; use Tag#replace_with to swap in what you want before #to_html.
+  @tag_genres[ :inline ] << TagFactory.new( :wiki_link,
+    :open_match => /\[\[(.{2,}?)\]\]/,
+    :setup => lambda{ |tag, ss, owl|
+      owl.process_wiki_link( tag, ss[1], ss[1] )
+      owl.wiki_links << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # See the [WikiInstructions help page] for more  ->  See the <wiki_link page="WikiInstructions">help page</wiki_link> for more
+  @tag_genres[ :inline ] << TagFactory.new( :wiki_link,
+    :open_match => /\[([A-Z]{2,}[a-z][a-zA-Z]*|[A-Z][a-z]+[A-Z][a-zA-Z]*) ([^\]]+)\]/,
+    :setup => lambda{ |tag, ss, owl|
+      owl.process_wiki_link( tag, ss[1], ss[2] )
+      owl.wiki_links << tag
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+  
+  # ~NotALink  ->  <span>NotALink</span>
+  @tag_genres[ :inline ] << TagFactory.new( :span,
+    :open_match => /~([A-Z]{2,}[a-z][a-zA-Z]*|[A-Z][a-z]+[A-Z][a-zA-Z]*|\[\[([^\]\n]{2,}?)\]\]|\[(?:[A-Z]{2,}[a-z][a-zA-Z]*|[A-Z][a-z]+[A-Z][a-zA-Z]*) [^\]]+\])/,
+    :setup => lambda{ |tag, ss, owl| tag << ss[1] },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # This is --strike text--  ->  This is <strike>strike text</strike>
+  @tag_genres[ :inline ] << TagFactory.new( :strike,
+    # Close up if we see a newline to prevent a typo from propagating too far
+    :open_match => /--/, :close_match => /--|(?=\n)/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # We should... !!finish this sentence!!  ->  We should... <span class="todo">TODO - finish this sentence</span>
+  @tag_genres[ :inline ] << TagFactory.new( :span,
+    :open_match => /!!([a-z].+?)!!/i,
+    :setup => lambda{ |tag, ss, owl|
+      tag << "TODO - #{ss[1]}"
+      tag.attributes[ :class ] = 'todo'
+    },
+    :allows_text => true,
+    :autoclose => true
+  )
+
+  # This is ^^superscript text^^  ->  This is <sup>superscript text</sup>
+  @tag_genres[ :inline ] << TagFactory.new( :sup,
+    # Close up if we see a newline to prevent a typo from propagating too far
+    :open_match => /\^\^/, :close_match => /\^\^|(?=\n)/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # This is __subscript text__  ->  This is <sub>subscript text</sub>
+  @tag_genres[ :inline ] << TagFactory.new( :sub,
+    # Close up if we see a newline to prevent a typo from propagating too far
+    :open_match => /__/, :close_match => /__|(?=\n)/,
+    :allows_text => true,
+    :allowed_genre => :inline
+  )
+
+  # Default handler; typically overridden by user using OWLScribble.each_wiki_link
+  @handle_wiki_link = proc{ |tag, page_name, link_text|
+    tag.name = 'wiki_link'
+    tag.text = link_text
+    tag.attributes[ :page  ] = page_name
+    tag.attributes[ :class ] = 'wiki_link'
+  }
+  
+  # Default handler; typically overridden by user using OWLScribble.each_wiki_command
+  @handle_wiki_command = proc{ |tag, command, params|
+    tag.name = 'wiki_command'
+    tag.attributes[ :do ] = command
+    if params && !params.empty?
+      tag.attributes[ :params ] = params.join(',')
+      tag.text = "###{command}( #{params.join ', '} )##"
+    else
+      tag.text = "###{command}##"
+    end
+  }
+  
+  # RDoc thinks that this stuff applies to instances, not the class
+  # :stopdoc:
+  class << self
+    attr_accessor :handle_wiki_link, :handle_wiki_command
+  end
+  # :startdoc:
+
+  # Define how to handle each wiki link instead of using the default handler.
+  # The block you supply will be passed a TagTreeScanner::Tag instance,
+  # the name of the wiki page to link to, and the text to display for the link.
+  #
+  # The Tag defaults to <tt><wiki_link>link text</wiki_link></tt>, without the page name.
+  #
+  # Example usage:
+  #  OWLScribble.each_wiki_link do |tag, page_name, link_text|
+  #    if my_application.page_exists?( page_name )
+  #      tag.name  = "a" #=> html anchor
+  #      tag.href  = "page/view/#{CGI.escape(page_name)}"
+  #      tag.title = "View #{page_name.dewikiword}"
+  #      # tag.text is set to the page_name.dewikiword already
+  #      
+  #    elsif my_application.user_can_create_pages?
+  #      tag.name  = "a" #=> html anchor
+  #      tag.href  = "page/create/#{CGI.escape(page_name)}"
+  #      tag.title = "Create #{page_name.dewikiword}"
+  #      tag.text  = page_name  # no dewikiword
+  #      
+  #    else
+  #      tag.name  = "span"
+  #      tag.class = "missing_page"
+  #      tag.text  = page_name      # no dewikiword
+  #    end
+  #  end
+  def self.each_wiki_link( &block )
+    @handle_wiki_link = block
+  end
+
+  # Define how to handle each wiki command instead of using the default handler.
+  # The block you supply will be passed a TagTreeScanner::Tag instance,
+  # the name of the command, and an array of zero or more parameter strings.
+  #
+  # The Tag defaults to <tt><wiki_command>###command( param1, param2 )##</wiki_command></tt>.
+  #
+  # Example usage:
+  #     OWLScribble.each_wiki_command do |tag, command, params|
+  #       case command
+  #
+  #         # Format is Include( page_name )
+  #         # or        Include( page_name, revision )
+  #         when 'Include'
+  #           tag.name  = 'div'
+  #           tag.class = 'sub_page'
+  #           page_name, revision = params
+  #           # All elements in the params array are strings
+  #           revision = Integer( revision ) rescue nil
+  #           tag.text = fetch_page( page_name, revision )
+  #         
+  #         when 'TitleIndex'
+  #           # ...set tag.html here
+  #         
+  #         else
+  #           tag.name  = 'span'
+  #           tag.class = 'unhandled_command'
+  #           tag.text = "###{command}( #{params.join ', '} )##"
+  #       end
+  #     end
+  def self.each_wiki_command( &block )
+    @handle_wiki_command = block
+  end
+
+  # _owl_string_ is the raw OWLScribble markup to convert.
+  #
+  # You likely want to use OWLScribble.each_wiki_link and (possibly) OWLScribble.each_wiki_command
+  # to define how to produce wiki-specific markup, prior to creating OWLScribble instances.
+  def initialize( owl_string )
+    @list_items = []
+    @headers = []
+    @wiki_commands = []
+    @wiki_links = []
+        
+    super
+
+    reparent_lists( @list_items ) unless @list_items.empty?
+    #TODO - process indented paragraphs like lists, just to calculate minimal depth from many spaces
+    add_sections
+    
+    # Must do this after add_sections has been called
+    @wiki_commands.each{ |command_tag|
+      case command_tag.attributes[ :do ]
+        when 'TableOfContents'
+          command_tag.replace_with( @table_of_contents.dup )
+      end
+    }
+  end
+
+  def process_wiki_link( tag, page_name, link_text ) #:nodoc:
+    tag.text = link_text
+    self.class.handle_wiki_link[ tag, page_name, link_text ]
+  end
+  
+  # This is not called for ##TableOfContents##, since we know
+  # how to handle that natively, and it must be handled after
+  # the full document hierarchy is created.
+  def process_wiki_command( tag, command, params ) #:nodoc:
+    if !params || params.empty?
+      tag.text = "###{command}##"
+    else
+      tag.text = "###{command}( #{params.join(', ')} )##"
+    end
+    self.class.handle_wiki_command[ tag, command, params ]
+  end
+
+  private
+    # Wrap <ul> and <ol> around tags appropriately
+    # Extra work required to handle malformed nesting reasonably
+    def reparent_lists( list_items )
+      # Gather information about the tags before we munge the tree
+      list_items.each_with_index{ |tag, i|
+        tag.info[ :index ] = i
+        tag.info[ :new_level ] = !tag.previous_sibling || ( tag.previous_sibling.name != :li )
+      }
+
+      factories = {
+        :ul => TagFactory.new( :ul ),
+        :ol => TagFactory.new( :ol )
+      }
+
+      last_item, seen_at_level = nil
+      list_items.dup.each{ |item|
+        # cached for (premature) speed optimization
+        info = item.info
+
+        # reset history if we're in a new list
+        if info[ :new_level ]
+          seen_at_level = [ ]
+          last_item = nil
+        end
+
+        # cached for (premature) speed optimization
+        level = info[ :level ]
+
+        # factory to create the <ul> or <ol>
+        factory = factories[ item.info[ :list_type ] ]
+
+        # add as child of last item, if I'm any deeper
+        if last_item && level > last_item.info[ :level ]
+          group_parent = last_item.append_child( factory.create )
+          last_item.info[ :child_grouper ] = group_parent
+
+        # at same level or higher than previous item
+        else
+          # sibling or parents (my level or higher)
+          relatives = seen_at_level[ 1..level ]
+
+          # find the most recent sibling/parent
+          if relatives && ( parent_or_sib = relatives.compact.sort_by{ |tag| tag.info[ :index ] }.last )
+
+            # same level as me? It's a sibling!
+            if parent_or_sib.info[ :level ] == level
+              group_parent = parent_or_sib.parent_tag
+
+            # must be higher, thus it'll be my parent
+            else
+              group_parent = parent_or_sib.info[ :child_grouper ]
+            end
+
+          # I'm higher than anyone else (first item or malformed input)
+          else
+            group_parent = item.parent_tag.insert_before( factory.create, item )
+          end
+
+        end
+        group_parent.append_child( item )
+
+        seen_at_level[ level ] = item
+        last_level = level
+        last_item = item
+      }
+    end
+
+    # Wrap <div class="section">...</div> around all headers
+    # and create the table of contents. Called automatically during initialization.
+    def add_sections( )
+      @table_of_contents = TagFactory.new( :div, :attributes => { :class => 'toc' } ).create
+
+      section_factory = TagFactory.new( :div, :attributes => { :class => 'section' } )
+
+      current_section = nil
+      last_header = nil
+      head_count = 0
+      header_titles = Hash.new( 0 )
+      header_at_depth = []
+      relatives = nil
+
+      # dup the array so that changes to the hierarchy
+      # don't screw up the iteration
+      @root.child_tags.dup.each{ |tag|
+        # We assume that only headers have 'header_depth' information
+        # because we're too lazy to test for h1-h6 name
+        if depth = tag.info[ :header_depth ]
+          tag.info[ :head_count ] = head_count += 1
+
+          # Create a TOC entry for this header
+          header_title = tag.inner_text.gsub( /\W/, '' )
+          header_id = header_title = tag.inner_text.gsub( /\W/, '' )
+          hits = ( header_titles[ header_title ] += 1 )
+          header_id += hits.to_s if hits > 1
+          #header_id = "heading_#{head_count}"
+          tag.attributes[ :id ] = header_id
+          toc_item = @table_of_contents.append_child( Tag.new( :li ) )
+          toc_item.info = { :level => depth, :list_type => :ul }
+          anchor = toc_item.append_child( tag.dup )
+          anchor.name = :a
+          anchor.attributes = { :href => "##{header_id}" }
+          @table_of_contents.append_child( toc_item )
+
+          # The wrapper div corresponding to this header
+          section = tag.info[ :section ] = section_factory.create
+
+          # if I'm any deeper than the last header, I'm a direct child
+          if last_header && depth > last_header.info[ :header_depth ]
+            section_parent = current_section
+
+          # See if I can find a previous sibling or parent (my level or above)
+          elsif ( relatives = header_at_depth[ 1..depth ] ) &&
+                ( parent_or_sib = relatives.compact.sort_by{ |header| header.info[ :head_count ] }.last )
+
+            if parent_or_sib.info[ :header_depth ] == depth
+              # same level as me? It's a sibling!
+              section_parent = parent_or_sib.parent_tag
+            else
+              # must be higher, thus its section will be my parent
+              section_parent = parent_or_sib.info[ :section ]
+            end
+
+          # I've got no basis for attachment, go to the 'top' level
+          else
+            section_parent = tag.parent_tag
+          end
+          section_parent.append_child( tag )
+          section_parent.append_child( section )
+
+          header_at_depth[ depth ] = tag
+          current_section = section
+          last_header = tag
+
+        # we didn't find a header, so just shove the current
+        # tag into the desired depth
+        elsif current_section
+          current_section.append_child( tag )
+        end
+      }
+
+      reparent_lists( @table_of_contents.child_tags )
+    end
+end
+
+# Extensions to the built-in String class
+class String
+  # Returns a copy of the string with spaces inserted in the 'appropriate'
+  # spots. e.g.
+  #
+  #  "WikiWord".dewikiword     #->  "Wiki Word"
+  #  "OWLScribble".dewikiword  #->  "OWL Scribble"
+  #  "ToXML".dewikiword        #->  "To XML"
+  #  "KingOfWhales".dewikiword #->  "King of Whales"
+  def dewikiword
+    self.dup.dewikiword!
+  end
+
+  # Same as #dewikiword, but modifies the string in place
+  def dewikiword!
+    gsub! /([A-Z][a-z]+)(?=[A-Z])/, '\1 \2'
+    gsub! /([A-Z])([A-Z][a-z])/, '\1 \2'
+    gsub!( /\b(?:A|Am|An|And|Are|Is|Of|The|With)\b/ ){ |s| s.downcase }
+    self
+  end
+end