tartan 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Larry Baltz & David B. Anderson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,130 @@
+== Welcome to Tartan
+
+Tartan is a general purpose text parsing engine whose main target is wiki text
+parsing. (see c2.com[http://c2.com/cgi/wiki?WikiWikiWeb] and
+Wikipedia[http://en.wikipedia.org/wiki/Wiki])  It doesn't implement one specific
+mark-up, but instead, provides a way to specify a variety of mark-ups. So,
+Tartan is a bit more "involved" than a purpose built parser like
+RedCloth[http://whytheluckystiff.net/ruby/redcloth/] or
+BlueCloth[http://www.deveiate.org/projects/BlueCloth], but provides the
+following benefits:
+
+1. separates the specific wiki syntax specification from the 
+   implementation
+2. allows layering and extension of parsing rules
+3. allows multiple output formats from the same syntax specification
+
+The current implementation of Tartan is in Ruby and includes a full Markdown
+parser (described in YAML). The format of the parsing specification has been
+created with an eye to having a language independent definition of wiki (and
+possibly other) mark-ups. That's a lofty goal, and Tartan hasn't quite gotten
+there yet, but we think there's a clear path. In any case, even if it is only
+available in Ruby it will hopefully be helpful for projects needing to do
+something more than just convert wiki text directly into HTML.
+
+== Usage
+
+So, really all you want to do is generate HTML from Markdown text.  Here's
+how you do it:
+
+  require 'tartan_markdown'
+  
+  html = TartanMarkdown.new("* howdy\n* doody").to_html
+  # => "<ul>\n<li>howdy</li>\n<li>doody</li>\n</ul>"
+
+Other parsers would have similar names and would have the same usage. In
+particular, you will need to require the parser class file and then creat a
+new instance of the parser and call <tt>to_html</tt> on that instance.
+
+You can also have other output methods, say <tt>to_xml</tt>, which would be
+called in the same way on the instance of the parser object.
+
+=== Layering Parsers
+
+You can add parsing syntax to existing parsers.  This is done by building up a set of parsers specifications that work together.
+
+In the Tartan distribution you have a specification for Markdown and you also
+have a specification for table mark-up. You can combine them by creating a new
+class that layers the tables onto the Markdown definition as follows in a file
+called <tt>tartan_markdown_tables.rb</tt>:
+
+  require 'tartan_markdown_def'
+  require 'tartan_table_def'
+  
+  class TartanMarkdownTables < Tartan
+    include TartanMarkdownDef
+    include TartanTableDef
+  end
+  
+In another file you could use this new parser:
+
+
+  require 'tartan_markdown_tables'
+  
+  html = TartanMarkdownTables.new("[|*happy*||**days**|]").to_html
+  # => "<table class=\"\">
+        <tr><td><em>happy</em></td><td><strong>days</strong></td></tr>
+        </table>"
+  
+== The Parsing Specification
+
+
+
+=== Overall Structure
+
+Each parser is made up of a parsing definition and optional helper methods.  The specification is defined in YAML and the helper methods are defined in a parser definition class.
+
+The parsing definition in YAML has the following general structure:
+
+  block:
+    - <parsing rule>
+    - <parsing rule>
+  
+  <parsing context>:
+    - <parsing rules>
+
+So the parsing rules are defined as a set of contexts and each context is an
+list of parsing rules. The base context defaults to <tt>block</tt>; that is, the parser starts with the <tt>block</tt> context which may point the parser off to other contexts to parse blocks of the parsed text.  More on this after the explanation of the parsing rules.
+
+==== Parsing Rules
+
+The following is a simple parsing rule to match paragraphs and mark them up in HTML:
+
+  title: paragraph
+  match: "/(^[^\n]+$\n)+^[^\n]+$/m"
+  html:
+    start_mark: <p>
+    end_mark:   </p>
+
+A paragraph, in this case, is any grouping of non blank lines.
+
+The parser will repetitively apply the <tt>match</tt> regular expression and if it matches, the <tt>html</tt> output sub-rule will put <tt><p></tt> and <tt></p></tt> around the text that is matched as a paragraph.
+
+If we wanted to also mark off blocks of code that are indented by say 2 or more spaces at the beginning of the line, we could use the following rule:
+
+  title: code
+  match: "/(^[ ]{2,}\S.+?$\n)+^[ ]{2,}\S.+?$/m"
+  html:
+    start_mark: <pre><code>
+    end_mark: </code></pre>
+
+When we want to add the <tt>code</tt> rule, the ordering becomes important.  If we put the <tt>paragraph</tt> rule first, it will gobble up both the paragraphs and the code blocks since it's just looking for groups of non blank lines.  To prevent this we need to put the <tt>code</tt> rule first.  So the overall definition would be:
+
+  block:
+    - title: code
+      match: "/(^[ ]{2,}\S.+?$\n)+^[ ]{2,}\S.+?$/m"
+      html:
+        start_mark: <pre><code>
+        end_mark: </code></pre>
+    - title: paragraph
+      match: "/(^[^\n]+$\n)+^[^\n]+$/m"
+      html:
+        start_mark: <p>
+        end_mark:   </p>
+  
+
+== The Name
+
+Tartan is intended to weave together different parsing elements.  It's intended
+to be an alternative of both RedCloth[http:www.redcloth.org/] and BlueCloth.  Tartan is a kind of cloth
+that weaves different colors together in an interesting pattern.

data/TODO

@@ -0,0 +1,17 @@
+To Do
+* regular expression repetition reduction
+* Markdown: > in code blocks not escaped (and perhaps other cases as well) 
+* > in code blocks not escaped (and perhaps other cases as well)
+* extended links addon for naked URLs, eg: http://www.google.com 
+* update all the files to generate ID tags
+* HTML comparator (ignore whitespace, optionally ignore class)
+* change start_mark and end_mark to start_tag and end_tag
+* strike through
+* superscript, subscript
+
+To consider
+* class name on span
+* math mark-up
+
+Done
+* get Markdown image links to work

data/lib/core_ext/array.rb

@@ -0,0 +1,12 @@
+class Array
+    alias :old_index :index
+    def index(*args, &block)
+        if not args.empty?
+            old_index(*args)
+        else
+            result = find_all(&block).map { |item| old_index(item) }
+            return nil if result.empty?
+            return result[0]
+        end
+    end
+end

data/lib/core_ext/file.rb

@@ -0,0 +1,15 @@
+# Extend the File class to add a function to check for a file in the 
+# load path.
+
+class File
+  # find a file in the load path or raise an exception if the file can
+  # not be found.
+  def File.find_file_in_path(filename)
+    $:.each do |path|
+      file_with_path = path+'/'+filename
+      return file_with_path if file?(file_with_path) 
+    end
+  
+    raise ArgumentError, "Can't find file #{filename} in Ruby library path"
+  end
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,16 @@
+class Hash
+  def deep_merge(hash)
+    target = dup
+    
+    hash.keys.each do |key| 
+      if hash[key].is_a?(Hash) and self[key].is_a?(Hash)
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      
+      target[key] = hash[key]
+    end
+    
+    target
+  end
+end

data/lib/core_ext/match_data.rb

@@ -0,0 +1,62 @@
+require 'pp'
+
+class MatchData
+    def sym2index(sym)
+      case sym
+      when '+', :last_match, :last, "last_match", "last"
+        last_match_index
+      when '&', :all, "all"
+        0
+      when /[0-9]+/
+        sym.to_i
+      when Integer
+        sym
+      else
+        nil
+      end
+    end
+    
+    def replace(replace_string)
+        replace_string.gsub(/\\([0-9+&'`\\])/) {|sub| 
+          case $1
+          when '\\'
+            '\\'
+          when '`'
+            pre_match
+          when "'"
+            post_match
+          else
+            to_a[sym2index($1)]
+          end
+        }
+    end
+    
+    def last_match_index
+      index = length - 1
+      to_a.reverse.each do |sub_match|
+        return index if ! sub_match.nil?
+        index -= 1
+      end
+    end
+    
+    def pre_sub_match(index)
+      if index.abs >= length
+        raise ArgumentError, "absolute value of index greater than length" 
+      end
+      
+      index = length + index if index < 0
+      
+      string[offset(0)[0]...offset(index)[0]]
+    end
+    
+    def post_sub_match(index)
+      if index.abs >= length
+        raise ArgumentError, "absolute value of index greater than length" 
+      end
+      
+      index = length + index if index < 0
+
+      string[offset(index)[1]...offset(0)[1]]
+    end
+end
+

data/lib/core_ext/module.rb

@@ -0,0 +1,17 @@
+class Module
+  def method_missing(method_name, *args, &block)
+    @arg_sets ||= {}
+    @arg_sets[method_name] = [args, block]
+  end
+
+  def included(klass)
+    return unless defined? @arg_sets
+    @arg_sets.each do |method, (args, block)|
+      if klass.methods.include?(method.id2name)
+        klass.send(method, *args, &block)
+      else
+        raise "method #{method} not defined in #{klass}"
+      end
+    end
+  end
+end

data/lib/core_ext/regexp.rb

@@ -0,0 +1,33 @@
+class Regexp
+  def to_regexp
+    self
+  end
+end
+
+class String
+  def chars
+    arr = []
+    scan(/./m) {|char| arr << char}
+    arr
+  end
+  def to_regexp
+    if self =~ /\A\s*\/((?:\\\/|[^\/])*)\/([imxnNeEsSuU]*)\s*\z/m
+      options = 0
+      lang = ''
+      $2.chars.each do |char|
+        case char
+        when 'i': options |= Regexp::IGNORECASE
+        when 'm': options |= Regexp::MULTILINE
+        when 'x': options |= Regexp::EXTENDED
+        when 'n', 'N': lang = 'n'
+        when 'e', 'E': lang = 'e'
+        when 's', 'S': lang = 's'
+        when 'u', 'U': lang = 'u'
+        end
+      end
+      Regexp.compile($1, options, lang)
+    else
+      nil
+    end
+  end
+end

data/lib/markdown.yml

@@ -0,0 +1,499 @@
+#$Id: markdown.rb 227 2006-06-12 16:30:08Z larry $
+
+# To resolve:
+#   How to handle (if at all) raw <h1>..<h6> tags.
+#   span parsing of headers
+#   handle return (\r) characters properly (especially in \r\n combo)
+
+span:
+  - title: backtick_2
+    shelve: true
+    match: /`` ?(.+?) ?``/
+    subparse:
+      context: back_smarties
+      match_group: 1
+    html:
+      start_mark: '<code>'
+      end_mark: '</code>'
+ 
+  - title: backtick_1
+    shelve: true
+    match: /`(.+?)`/
+    subparse:
+      context: back_smarties
+      match_group: 1
+    html:
+      start_mark: '<code>'
+      end_mark: '</code>'
+
+  - title: ref_image
+    shelve: true
+    match: /!\[(.*?)\][ ]?\[(.*?)\]/
+    html:
+      replace: '<img src="{{{\2url}}}" alt="\1"{{{\2title}}} />'
+
+  - title: ref_link_no_id
+    shelve: true
+    match: /\[(.*?)\][ ]?\[\]/
+    html: 
+      replace: '<a href="{{{\1url}}}"{{{\1title}}}>\1</a>'
+
+  - title: ref_link
+    shelve: true
+    match: /\[(.*?)\][ ]?\[(.*?)\]/
+    html:
+      replace: '<a href="{{{\2url}}}"{{{\2title}}}>\1</a>'
+
+  - title: html_span
+    shelve: true
+    match: >
+      / <\/?
+          (?:span|cite|del|em|strong|dfn|code|samp|kbd|var|abbr
+            |acronym|b|i|font|a|img|object|tt|big|small|strike|s|u
+            |sup|sub|q)
+          . *?>/x
+    html:
+      start_mark: ''
+      end_mark: ''
+
+  - title: entity_escaped
+    shelve: true
+    match: '/&[[:alnum:]-]+;/'
+    html:
+      start_mark: ''
+      end_mark: ''
+
+  - title: amp
+    match: /&/
+    html:
+      replace: '&amp;'
+
+  - title: backslash_gt
+    match: /\\>/
+    html:
+      replace: '&gt;'
+
+  - title: lt
+    match: /</
+    html:
+      replace: '&lt;'
+
+  - title: gt
+    match: '/(?:(?!^))>/'
+    html:
+      replace: '&gt;'
+
+  - title: backslash_escapes
+    shelve: true
+    match: /\\([\\\`\*\_\{\}\[\]\(\)\>\#\.\!\+\-])/
+    html:
+      replace: '\1'
+
+  - title: linebreak
+    match: /[ \t]{2,}$/
+    html:
+      replace: "<br />"
+
+  - rescan
+
+  - title: inline_image_with_title
+    shelve: true
+    match: /!\[(.+?)\]\((.+??)\s+"(.+?)"\)/
+    html:
+      replace: '<img src="\2" alt="\1" title="\3" />'
+
+  - rescan
+
+  - title: inline_image
+    shelve: true
+    match: /!\[(.+?)\]\((.*?)\)/
+    html:
+      replace: '<img src="\2" alt="\1" />'
+
+  - rescan
+
+  - title: link_with_title
+    shelve: true
+    match: /\[(.+?)\]\((.+??)\s+"(.+?)"\)/
+    html:
+      replace: '<a href="\2" title="\3">\1</a>'
+  - rescan
+
+  - title: link
+    shelve: true
+    match: /\[(.+?)\]\((.*?)\)/
+    html:
+      replace: '<a href="\2">\1</a>'
+
+  - rescan
+
+  - title: pre_emphasis
+
+  - title: strong_em
+    match: '/(?:\*{3}(.+?)\*{3})|(?:_{3}(.+?)_{3})/'
+    subparse:
+      context: span
+      match_group: last
+    html:
+      start_mark: '<strong><em>'
+      end_mark: '</em></strong>'
+  - rescan
+
+  - title: strong
+    match: '/(?:\*{2}(.+?)\*{2})|(?:_{2}(.+?)_{2})/'
+    subparse:
+      context: span
+      match_group: last
+    html:
+      start_mark: '<strong>'
+      end_mark: '</strong>' 
+  - rescan
+
+  - title: em
+    match: '/(?:\*(.+?)\*)|(?:\_(.+?)\_)/'
+    subparse:
+      context: span
+      match_group: last
+    html:
+      start_mark: '<em>'
+      end_mark: '</em>' 
+
+  - title: post_emphasis
+
+back_smarties:
+  - title: backslash_gt
+    match: /\\>/
+    html:
+      replace: '\\&gt;' 
+
+  - title: backslash_lt
+    match: /\\</
+    html:
+      replace: '\\&lt;' 
+
+  - title: amp
+    match: /&/
+    html:
+      replace: '&amp;' 
+
+  - title: backslash_gt
+    match: /\\>/
+    html:
+      replace: '&gt;' 
+
+  - title: lt
+    match: /</
+    html:
+      replace: '&lt;' 
+
+  - title: gt
+    match: '/(?:(?!^))>/'
+    html:
+      replace: '&gt;' 
+
+block:
+  - title: strip_return
+    match: /\r/
+    html:
+      replace: ''
+
+  - rescan
+
+  - title: main_block
+
+  - title: reference_title
+    match: >
+      /\n(?:[ ]{0,3})
+        \[([^\]]*)\]:\s+(?:<([^>]*)>|(\S*))\s+
+        (?:"([^"]*?)"|'([^']*?)')[ \t]*/mx
+    set:
+      '\1url': '\2\3'
+      '\1title': ' title="\4\5"' 
+    html:
+      replace: ''
+
+  - title: reference
+    match: '/\n(?: {0,3})\[([^:\n]*)\]:\s+(?:<([^>]*)>|(\S*))$/m'
+    set:
+      '\1url': '\2\3'
+      '\1title': '' 
+    html:
+      replace: ''
+
+  - title: html_comment
+    shelve: true
+    match: /(<!--.*?-->)/m
+    html:
+      replace: '\1'
+
+  - title: underline_header1
+    match: '/^([^\n\t #=-][^\n]*?)[ \t]*\n=+[ \t]*$/m'
+    subparse:
+      context: span
+      match_group: 1
+    html:
+      start_mark: '<h1>'
+      end_mark: '</h1>'
+
+  - title: underline_header2
+    match: '/^([^\n\s#=-][^\n]*?)[ \t]*\n-+[ \t]*$/m'
+    subparse:
+      context: span
+      match_group: 1
+    html:
+      start_mark: '<h2>'
+      end_mark: '</h2>'
+
+  - title: hash_header
+    match: '/^(\# {1,6})\s*([^#]*?)(?:\s*\#+\s*|\s*)$/x'
+    subparse:
+      context: span
+      match_group: 2
+    html:
+      start_mark: '<h#{len(\1)}>'
+      end_mark: '</h#{len(\1)}>'
+
+  - title: blockquote
+    match: '/^((?:>.*?$)(?:\n[^\n]+)*)/m'
+    subparse: embeddedBlock
+    strip:
+      match: /^(> |>$)/
+      replace: '' 
+    unstrip:
+      match: /^|(\n)\z/
+      replace: '\1> ' 
+    html:
+      start_mark: "<blockquote>\n"
+      end_mark: "\n</blockquote>"
+    # Needs to go before the bullet lists to ensure that
+    # spaced - and * HRs aren't interpreted as bullet lists
+
+  - title: horizontal_rule
+    match: >
+      / (?:(\n)\s*(\n)|\A|\A\s*(\n))
+        [ ]{0,3}([-_*][ ]?){3,}[ \t]*?$/xm
+    html:
+      replace: '\1\2\3<hr />'
+
+  - title: bulletListSpaced
+    match: >
+      / (?>\A(\s*)|\n(\n))
+                  (
+                    [-*+](?>[ ]+|\t)[^\n]*
+                    (?>\n(?>[ ]{4}|\t)?[^\n]+)*
+                    (?>
+                      \n\n(?>[ ]{4}|\t)[^-*+\n][^\n]*
+                      (?>\n(?>[ ]{4}|\t)?[^\n]+)*
+                    )*
+                    (?>
+                      \n\n[-*+](?:[ ]+|\t)[^\n]*
+                      (?>\n
+                        (?>[ ]{4}|\t)?
+                        [^\n]+
+                      )*
+                      (?>
+                        \n\n(?>[ ]{4}|\t)[^-*+\n][^\n]*
+                        (?>\n(?>[ ]{4}|\t)?[^\n]+)*
+                      )*
+                    )+
+                  )/xm
+    subparse:
+      context: listSpaced
+      match_group: 3
+    html:
+      start_mark: "<ul>\n"
+      end_mark: "\n</ul>" 
+
+  - title: bulletListClose
+    match: >
+      / (?:\A(\s*)|\n(\n))
+                  ([-*+](?:[ ]+|\t)[^\n]+(:?\n[ \t]*[^\s][^\n]*)*)/xm
+    subparse:
+      context: listClose
+      match_group: 3
+    html:
+      start_mark: "\\1\\2<ul>\n"
+      end_mark: "\n</ul>" 
+
+  - title: numberedListSpaced
+    match: >
+      /  (?>\A(\s*)|\n(\n))
+                   (
+                     (?>^[[:digit:]]+\.
+                       (?>[ ]+|\t)[^\n]*)
+                       (?>\n(?:[ ]{4}|\t)?
+                         [^\n]+
+                       )*
+                     (?>
+                       (?>\n\n(?:[ ]{4}|\t)[^[:digit:]\n][^\n]*)
+                       (?>\n(?:[ ]{4}|\t)?[^\n]+)*
+                     )*
+                     (?>\n\n
+                       (?>^[[:digit:]]+\.
+                         (?>[ ]+|\t)[^\n]*)
+                         (?>\n(?:[ ]{4}|\t)?
+                         [^\n]+
+                       )*
+                       (?>
+                         (?>\n\n(?:[ ]{4}|\t)[^[:digit:]\n][^\n]*)
+                         (?>\n(?:[ ]{4}|\t)?[^\n]+)*
+                       )*
+                     )+
+                    )/xm
+    subparse:
+      context: listSpaced
+      match_group: 3
+    html:
+      start_mark: "\\1\\2<ol>\n"
+      end_mark: "\n</ol>" 
+
+  - title: numberedListClose
+    match: >
+      / (?:\A(\s*)|\n(\n))
+                  ((?:^[[:digit:]]+\.(?:[ ]+|\t)[^\n]*)
+                   (?:\n(?:[[:digit:]]+\.(?:[ ]+|\t)
+                           |(?:[ ]{4}|\t)?
+                        )[^\n]+
+                   )*
+                  )/xm
+    subparse:
+      context: listClose
+      match_group: 3
+    html:
+      start_mark: "\\1\\2<ol>\n"
+      end_mark: "\n</ol>" 
+
+  - title: html_block
+    shelve: true
+    match: >
+      / ^[ ]{0,3}<(script|table|div|pre|center|blockquote|p|ul|ol|h[1-6])(?:[^>]*)?>
+        .*?
+        <\/\1>/xm
+    html: true
+
+  - title: code
+    match: >
+      / (?:\A|(\n)(?:[ ]{4}|\t)?(\n))((?:\t|[ ]{4})[^\n]*
+                  (?:\n+(?:\t|[ ]{4})[^\n]*)*)/xm
+    subparse:
+      context: codeBlock
+      match_group: 3
+    strip:
+      match: '/^(?:\t|[ ]{4})/'
+      replace: ''
+    unstrip:
+      match: /\n/
+      replace: "\n    "
+    html:
+      start_mark: '\1\2<pre><code>'
+      end_mark: "\n</code></pre>"
+
+  - title: paragraph
+    match: '/((?:^\S.*?$)(?:\n\S[^\n]*)*)/m'
+    subparse: span
+    html:
+      start_mark: '<p>'
+      end_mark: '</p>'
+
+  - title: extraReturns
+    match: '/^(?:\s*\n){3,}/'
+    html:
+      replace: "\n\n"
+
+codeBlock:
+  - title: codeContents
+    match: /(\A.+\z)/m
+    rescan: true
+    html:
+      replace: '#{untabify(\1)}'
+
+  - title: check_smarties
+    match: /(\A.+\z)/m
+    subparse: back_smarties
+
+embeddedBlock:
+  - title: emBulletListClose
+    match: >
+      / ((?:^[-*+](?:[ ]+|\t).*?$)
+                  (?:\n(?:[-*+]|(?:[ ]{4}|\t)?)[^\n]*)*
+        )/xm
+    subparse: listClose
+    html:
+      start_mark: "<ul>\n"
+      end_mark: "\n</ul>" 
+
+  - title: emNumberedListClose
+    match: >-
+      / ( (?:^[[:digit:]]+\.(?:[ ]+|\t).*?$)
+          (?:\n(?:[[:digit:]]+\.|(?:[ ]{4}|\t)?)
+          [^\n]*)*
+        )/xm
+    subparse: listClose
+    html:
+      start_mark: "<ol>\n"
+      end_mark: "\n</ol>" 
+
+  - title: embeddedPara
+    position: first
+    match: 
+      /\A (?:(?![*+-]|[[:digit:]]))
+          (?:(?:\S[^\n]*)(?:\n\S[^\n]*)*)
+          \n?\z/xm
+    subparse: span
+    html:
+      end_mark: '\1'
+
+  - title: embeddedRemainder
+    match: /.+/m
+    subparse: block
+    html: true
+
+listSpaced:
+  - title: spacedListItem
+    match: >-
+      /^(?:^(?:[-*+]|[[:digit:]]+\.)
+            (?:[ ]+|\t).*?$
+        )
+        (?:\n[^-*+[:digit:]\n][^\n]*)*
+        (?:
+          (?:\n\n(?:[ ]{4}|\t)[^-*+[:digit:]\n][^\n]*)
+          (?:\n[^-*+[:digit:]\n][^\n]*)*
+        )*/xm
+    strip:
+      match: '/^(([-*+]|[[:digit:]]\.)\s*|(?:    |\t))/'
+      replace: ''
+    subparse: block
+    html:
+      start_mark: '<li>'
+      end_mark: "</li>"
+
+  - title: listSpacedDoubleReturn
+    match: /\n\n/
+    html:
+      replace: "\n"
+
+listClose:
+  - title: closeListItem
+    match: >
+      /^(
+          (?:
+            (?:[-*+]|[[:digit:]+]\.)
+            (?:[ ]+|\t).*?$
+          )
+          (?:\n(?![-*+\n]|[[:digit:]]+\.)[^\n]*)*
+        )/xm
+    strip:
+      match: >
+        /^( (?:[-*+]|[[:digit:]]+\.)\s*
+            |(?:[ ]+|\t)
+          )/x
+      replace: ''
+    subparse: embeddedBlock
+    html:
+      start_mark: '<li>'
+      end_mark: '</li>' 
+
+  - title: listCloseDoubleReturn
+    match: /\n\n/
+    html:
+      replace: "\n"