precedent 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+1. Fork the [master branch of the respository](https://github.com/BlackacreLabs/precedent/tree/master)
+2. Create a feature branch (`git checkout -b my-new-feature`).
+3. Add specifications and make your changes.
+4. Regenerate Treetop parsers and run specs (`rake clobber spec`).
+5. Commit your changes (`git commit -am 'Add some feature'`).
+6. Push to your feature branch (`git push origin my-new-feature`).
+7. Send a pull request via [GitHub](https://github.com).

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in precedent.gemspec
+gemspec
+
+group :development do
+  # guard-rspec does not play nice with later versions of rb-inotify
+  gem 'rb-inotify', '0.8.8', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+end

data/Guardfile

@@ -0,0 +1,13 @@
+guard :bundler do
+  watch("precedent.gemspec")
+end
+
+require './lib/precedent/treetop_patch.rb'
+guard :treetop do
+  watch('**/*.treetop')
+end
+
+guard :rspec, bundler: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})
+end

data/LICENSE.md

@@ -0,0 +1,22 @@
+# License
+
+Copyright 2013 Blackacre Labs, a Texas non-profit corporation
+
+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.md

@@ -0,0 +1,12 @@
+# Precedent
+
+Lightweight markup for legal documents, inspired by the print style of
+the United States Reports.
+
+- Mixed symbolic (*, †, ‡) and numeric, non-sequential footnotes.
+- Elegant control of paragraph indentation (flush or indented)
+- Document-level metadata
+- Elegant citation identification
+- Small capitals
+
+See `SYNTAX.md` for more details.

data/Rakefile

@@ -0,0 +1,48 @@
+require "bundler/gem_tasks"
+
+# Treetop grammars
+
+GRAMMARS = FileList.new('**/*.treetop').sub('.treetop', '.rb')
+
+desc "Generate Treetop grammars"
+task :grammars => GRAMMARS
+
+require 'rake/clean'
+CLEAN.include('tmp')
+CLOBBER.include(GRAMMARS)
+
+compiler = nil
+rule '.rb' => '.treetop' do |t|
+  unless defined? Treetop
+    require 'treetop' 
+    require './lib/precedent/treetop_patch.rb'
+  end
+  compiler ||= Treetop::Compiler::GrammarCompiler.new
+  compiler.compile(t.source, t.name)
+end
+
+# Performance
+
+desc 'Profile a program run'
+task :profile do
+  require 'ruby-prof'
+  require_relative 'lib/precedent.rb'
+  result = RubyProf.profile do
+    Precedent.new(File.read('spec/fixtures/long_opinion.pre')).to_hashes
+  end
+  printer = RubyProf::GraphPrinter.new(result)
+  printer.print(STDOUT, {})
+end
+
+# Specifications
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec => [:grammars])
+
+# Coverage
+desc 'Measure test suite code coverage'
+RSpec::Core::RakeTask.new(:coverage => [:grammars]) do
+  ENV['COVERAGE'] = 'true'
+end
+
+task :default => :spec

data/SYNTAX.md

@@ -0,0 +1,142 @@
+Precedent Syntax Guide
+----------------------
+
+## Headings, Paragraphs, Quotes, Footnotes, and Rules
+
+Document elements can span multiple lines, but are separated by blank
+(empty) lines.
+
+### Headings
+
+```
+# A top-level heading
+   
+## A subheading
+    
+### A sub-subheading
+```
+
+### Paragraphs
+
+The style of a paragraph is determined by the indentation of its first
+line:
+
+- 0 Spaces: Flush with the left margin (useful after block quotations)
+- 2 Spaces: Indented (most paragraphs should be indented this way)
+- 4 Spaces: Flush block quotation paragraphs
+- 6 Spaces: Indented block quotation paragraphs
+- 8 Spaces: Ragged-left (right-aligned) paragraphs
+
+```
+  This first line of this paragraph will be rendered indented. It can 
+continue on multiple lines.
+
+    This is a flush blockquote paragraph
+
+      And this is an indented blockquote paragraph.
+
+This paragraph follows the block quotation, and will be rendered without
+indentation, i.e. flush with the left margin. This is still part of the
+flush paragraph, as no blank line separates it from previous lines.
+
+        This paragraph will be set flush against the right margin, or
+ragged left.
+
+  And finally, here is another standard indented paragraph.
+```
+
+### Footnotes
+
+Footnote paragraphs are all indented paragraphs. The first paragraph in
+a footnote begins with a caret (`^`) and a marker, followed by at least
+one space before the text of the paragraph begins. The marker can be an
+integer, asterisk (`*`), dagger (`†`), or double dagger (`‡`). That
+marker should appear elsewhere within a footnote reference (discussed
+below).
+
+For example:
+
+```
+  This is a body paragraph.[[12]] It has a footnote reference referring
+to a footnote with the marker "12".
+
+^12 This is the first paragraph in footnote twelve.
+
+^ This is another paragraph in the same footnote.
+```
+
+Footnote paragraphs need not appear at the end of the document, nor must
+they appear immediately after the paragraph containing the corresponding
+reference. Footnotes can also appear in any order in the document.
+
+### Horizontal Rules
+
+Rules, written `* * *` can appear in body text or block quotations:
+
+```
+  A standard paragraph.
+
+* * *
+
+  Another standard paragraph.
+
+      A blockquote paragraph.
+
+    * * *
+
+    A flush blockquote paragrap.
+
+A flush body paragraph.
+```
+
+## Formatting Text
+
+Within a paragraph, the following can be used to format text:
+
+```
+This is a paragraph. The final word in this sentence is //emphasized//.
+Small capitals can be set with the less-than and greater-than characters
+<<like so>>. Citations can be identified with double curly brackes and
+contain other formatting. {{//Id.//}} Page breaks@@2@@can be notated
+with at-signs. Footnote references appear in double brackets.[[1]]
+
+^1 The text of the footnote.
+```
+
+## Metadata
+
+Metadata blocks permit non-content information about a document to be
+embedded within it.
+
+Metadata blocks are composed of lines containing:
+
+- a key, composed of alphabet letters and starting with a capital letter
+- a colon
+- optional spaces
+- content of any kind, running to the end of the line
+
+For example:
+
+```
+Style: Sebelius v. Auburn Regional Medical Center et al. 
+Number: 11–1231
+Argued: 2012-12-04
+Decided: 2013-01-22
+```
+
+Metadata must appear at the top of a document, before any content text.
+
+### Special Metadata Types
+
+Content composed only of digits will be interpreted as an integer
+number.
+
+```
+Opinions: 3
+```
+
+Content of the form `YYYY-MM-DD` will be interpreted as a calendar date.
+
+```
+Filed: 2013-01-01
+```

data/bin/precedent

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/precedent/cli'
+Precedent::CLI.start(ARGV)

data/lib/precedent.rb

@@ -0,0 +1,10 @@
+require 'treetop/runtime'
+
+require_relative 'precedent/version'
+require_relative 'precedent/translator'
+
+module Precedent
+  def self.new(input)
+    Translator.new(input)
+  end
+end

data/lib/precedent/cli.rb

@@ -0,0 +1,41 @@
+require 'thor'
+
+require_relative '../precedent'
+
+module Precedent
+  class CLI < Thor
+    default_task :translate
+
+    option :pretty,
+      :aliases => '-p',
+      :type => :boolean,
+      :default => false,
+      :desc => "Pretty output"
+
+    OUTPUT_FORMATS = {
+      :json => lambda { |hashes, pretty|
+        require 'json'
+        message = pretty ? :pretty_generate : :generate
+        JSON.send(message, hashes)
+      },
+      :yaml => lambda { |hashes, pretty|
+        require 'yaml'
+        hashes.to_yaml
+      }
+    }
+
+    option :format,
+      :aliases => '-f',
+      :default => OUTPUT_FORMATS.keys.first,
+      :desc => "Output format: " + OUTPUT_FORMATS.keys.join('|')
+
+    desc "translate [FILE]", "Translate Precedent markup"
+
+    def translate(file=STDIN)
+      input = file.is_a?(String) ? File.read(file) : file.read
+      parsed = Precedent.new(input).to_hashes
+      output = OUTPUT_FORMATS[options[:format].to_sym].call(parsed, options[:pretty])
+      STDOUT.write(output)
+    end
+  end
+end

data/lib/precedent/grammar/inline.rb

@@ -0,0 +1,762 @@
+# encoding: UTF-8
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+
+module Precedent
+  module Inline
+    include Treetop::Runtime
+
+    def root
+      @root ||= :inline
+    end
+
+    module Inline0
+      def inline_element
+        elements[1]
+      end
+    end
+
+    module Inline1
+      def first
+        elements[0]
+      end
+
+      def subsequent
+        elements[1]
+      end
+    end
+
+    module Inline2
+      def build
+        elems = subsequent.elements.map(&:build).flatten
+        # Members of `subsequent` come in [nil, Node] lists when there
+        # is no preceding line break. The car values can't be ignored,
+        # as we need to convert newlines to spaces when they occur.
+        ret = elems.reduce([first.build]) do |mem, e|
+          last = mem.last
+          # Start the output list with the first element
+          if e.nil?
+            mem
+          # Concatenate contiguous strings
+          elsif last.is_a?(String) && e.is_a?(String)
+            mem + [mem.pop + e]
+          else # Hash
+            mem + [e]
+          end
+        end
+        # If there is just one content element, give the element
+        # rather than a one-element list.
+        ret.count == 1 ? ret.first : ret
+      end
+    end
+
+    def _nt_inline
+      start_index = index
+      if node_cache[:inline].has_key?(index)
+        cached = node_cache[:inline][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_inline_element
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_single_newline
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s3 << r4
+          if r4
+            r6 = _nt_inline_element
+            s3 << r6
+          end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Inline0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Inline1)
+        r0.extend(Inline2)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:inline][start_index] = r0
+
+      r0
+    end
+
+    def _nt_inline_element
+      start_index = index
+      if node_cache[:inline_element].has_key?(index)
+        cached = node_cache[:inline_element][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_citation
+      if r1
+        r0 = r1
+      else
+        r2 = _nt_emphasis
+        if r2
+          r0 = r2
+        else
+          r3 = _nt_smallcaps
+          if r3
+            r0 = r3
+          else
+            r4 = _nt_reference
+            if r4
+              r0 = r4
+            else
+              r5 = _nt_page_break
+              if r5
+                r0 = r5
+              else
+                r6 = _nt_space
+                if r6
+                  r0 = r6
+                else
+                  r7 = _nt_word
+                  if r7
+                    r0 = r7
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      node_cache[:inline_element][start_index] = r0
+
+      r0
+    end
+
+    module Smallcaps0
+      def content
+        elements[1]
+      end
+
+    end
+
+    module Smallcaps1
+      def build
+        { :type => :smallcaps,
+          :content => content.build }
+      end
+    end
+
+    def _nt_smallcaps
+      start_index = index
+      if node_cache[:smallcaps].has_key?(index)
+        cached = node_cache[:smallcaps][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('<<', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('<<')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        r2 = _nt_inline
+        s0 << r2
+        if r2
+          if has_terminal?('>>', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('>>')
+            r3 = nil
+          end
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Smallcaps0)
+        r0.extend(Smallcaps1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:smallcaps][start_index] = r0
+
+      r0
+    end
+
+    module Emphasis0
+      def content
+        elements[1]
+      end
+
+    end
+
+    module Emphasis1
+      def build
+        { :type => :emphasis,
+          :content => content.build }
+      end
+    end
+
+    def _nt_emphasis
+      start_index = index
+      if node_cache[:emphasis].has_key?(index)
+        cached = node_cache[:emphasis][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('\\\\', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('\\\\')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        r2 = _nt_inline
+        s0 << r2
+        if r2
+          if has_terminal?('\\\\', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('\\\\')
+            r3 = nil
+          end
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Emphasis0)
+        r0.extend(Emphasis1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:emphasis][start_index] = r0
+
+      r0
+    end
+
+    module Citation0
+      def content
+        elements[1]
+      end
+
+    end
+
+    module Citation1
+      def build
+        { :type => :citation,
+          :content => content.build }
+      end
+    end
+
+    def _nt_citation
+      start_index = index
+      if node_cache[:citation].has_key?(index)
+        cached = node_cache[:citation][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('{{', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('{{')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        r2 = _nt_inline
+        s0 << r2
+        if r2
+          if has_terminal?('}}', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('}}')
+            r3 = nil
+          end
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Citation0)
+        r0.extend(Citation1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:citation][start_index] = r0
+
+      r0
+    end
+
+    module PageBreak0
+      def page
+        elements[1]
+      end
+
+    end
+
+    module PageBreak1
+      def build
+        { :type => :break,
+          :page => page.text_value.to_i }
+      end
+    end
+
+    def _nt_page_break
+      start_index = index
+      if node_cache[:page_break].has_key?(index)
+        cached = node_cache[:page_break][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('@@', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('@@')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          if has_terminal?('\G[0-9]', true, index)
+            r3 = true
+            @index += 1
+          else
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        if s2.empty?
+          @index = i2
+          r2 = nil
+        else
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        end
+        s0 << r2
+        if r2
+          if has_terminal?('@@', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('@@')
+            r4 = nil
+          end
+          s0 << r4
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(PageBreak0)
+        r0.extend(PageBreak1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:page_break][start_index] = r0
+
+      r0
+    end
+
+    module Reference0
+      def marker
+        elements[1]
+      end
+
+    end
+
+    module Reference1
+      def build
+        { :type => :reference,
+          :marker => marker.text_value }
+      end
+    end
+
+    def _nt_reference
+      start_index = index
+      if node_cache[:reference].has_key?(index)
+        cached = node_cache[:reference][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?('[[', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        @index += 2
+      else
+        terminal_parse_failure('[[')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          if has_terminal?('\G[0-9*†‡]', true, index)
+            r3 = true
+            @index += 1
+          else
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        if s2.empty?
+          @index = i2
+          r2 = nil
+        else
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        end
+        s0 << r2
+        if r2
+          if has_terminal?(']]', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure(']]')
+            r4 = nil
+          end
+          s0 << r4
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Reference0)
+        r0.extend(Reference1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:reference][start_index] = r0
+
+      r0
+    end
+
+    module SingleNewline0
+      def build
+        ' '
+      end
+    end
+
+    def _nt_single_newline
+      start_index = index
+      if node_cache[:single_newline].has_key?(index)
+        cached = node_cache[:single_newline][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      if has_terminal?("\n", false, index)
+        r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r0.extend(SingleNewline0)
+        @index += 1
+      else
+        terminal_parse_failure("\n")
+        r0 = nil
+      end
+
+      node_cache[:single_newline][start_index] = r0
+
+      r0
+    end
+
+    module Word0
+      def char
+        elements[1]
+      end
+    end
+
+    module Word1
+      def build
+        text_value
+      end
+    end
+
+    def _nt_word
+      start_index = index
+      if node_cache[:word].has_key?(index)
+        cached = node_cache[:word][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        i1, s1 = index, []
+        i2 = index
+        i3 = index
+        if has_terminal?('{{', false, index)
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+          @index += 2
+        else
+          terminal_parse_failure('{{')
+          r4 = nil
+        end
+        if r4
+          r3 = r4
+        else
+          if has_terminal?('}}', false, index)
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('}}')
+            r5 = nil
+          end
+          if r5
+            r3 = r5
+          else
+            if has_terminal?('<<', false, index)
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
+            else
+              terminal_parse_failure('<<')
+              r6 = nil
+            end
+            if r6
+              r3 = r6
+            else
+              if has_terminal?('>>', false, index)
+                r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                @index += 2
+              else
+                terminal_parse_failure('>>')
+                r7 = nil
+              end
+              if r7
+                r3 = r7
+              else
+                if has_terminal?('[[', false, index)
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                  @index += 2
+                else
+                  terminal_parse_failure('[[')
+                  r8 = nil
+                end
+                if r8
+                  r3 = r8
+                else
+                  if has_terminal?(']]', false, index)
+                    r9 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                    @index += 2
+                  else
+                    terminal_parse_failure(']]')
+                    r9 = nil
+                  end
+                  if r9
+                    r3 = r9
+                  else
+                    if has_terminal?('\\\\', false, index)
+                      r10 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                      @index += 2
+                    else
+                      terminal_parse_failure('\\\\')
+                      r10 = nil
+                    end
+                    if r10
+                      r3 = r10
+                    else
+                      if has_terminal?('@@', false, index)
+                        r11 = instantiate_node(SyntaxNode,input, index...(index + 2))
+                        @index += 2
+                      else
+                        terminal_parse_failure('@@')
+                        r11 = nil
+                      end
+                      if r11
+                        r3 = r11
+                      else
+                        @index = i3
+                        r3 = nil
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        if r3
+          r2 = nil
+        else
+          @index = i2
+          r2 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r2
+        if r2
+          r12 = _nt_char
+          s1 << r12
+        end
+        if s1.last
+          r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+          r1.extend(Word0)
+        else
+          @index = i1
+          r1 = nil
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Word1)
+      end
+
+      node_cache[:word][start_index] = r0
+
+      r0
+    end
+
+    module Space0
+      def build
+        ' '
+      end
+    end
+
+    def _nt_space
+      start_index = index
+      if node_cache[:space].has_key?(index)
+        cached = node_cache[:space][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      if has_terminal?(' ', false, index)
+        r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r0.extend(Space0)
+        @index += 1
+      else
+        terminal_parse_failure(' ')
+        r0 = nil
+      end
+
+      node_cache[:space][start_index] = r0
+
+      r0
+    end
+
+    def _nt_char
+      start_index = index
+      if node_cache[:char].has_key?(index)
+        cached = node_cache[:char][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      if has_terminal?('\G[\\S]', true, index)
+        r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        r0 = nil
+      end
+
+      node_cache[:char][start_index] = r0
+
+      r0
+    end
+
+  end
+
+  class InlineParser < Treetop::Runtime::CompiledParser
+    include Inline
+  end
+
+end