rattler 0.3.0 → 0.4.0

data/spec/rattler/back_end/parser_generator/token_generator_spec.rb

@@ -1,22 +1,23 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
+include Rattler::BackEnd::ParserGenerator
 include Rattler::Parsers
 
-describe Rattler::BackEnd::ParserGenerator::TokenGenerator do
-  
+describe TokenGenerator do
+
   include ParserGeneratorSpecHelper
-  
+
   let(:token) { Token[Match[/\w+/]] }
-  
+
   describe '#gen_basic' do
-    
+
     context 'when nested' do
       it 'generates nested token matching code' do
         nested_code {|g| g.gen_basic token }.
           should == '@scanner.scan(/\w+/)'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level token matching code' do
         top_level_code {|g| g.gen_basic token }.
@@ -24,16 +25,16 @@ describe Rattler::BackEnd::ParserGenerator::TokenGenerator do
       end
     end
   end
-  
+
   describe '#gen_assert' do
-    
+
     context 'when nested' do
       it 'generates nested positive lookahead code' do
         nested_code {|g| g.gen_assert token }.
           should == '(@scanner.skip(/(?=\w+)/) && true)'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level positive lookahead code' do
         top_level_code {|g| g.gen_assert token }.
@@ -41,16 +42,16 @@ describe Rattler::BackEnd::ParserGenerator::TokenGenerator do
       end
     end
   end
-  
+
   describe '#gen_disallow' do
-    
+
     context 'when nested' do
       it 'generates nested negative lookahead code' do
         nested_code {|g| g.gen_disallow token }.
           should == '(@scanner.skip(/(?!\w+)/) && true)'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level negative lookahead code' do
         top_level_code {|g| g.gen_disallow token }.
@@ -58,12 +59,14 @@ describe Rattler::BackEnd::ParserGenerator::TokenGenerator do
       end
     end
   end
-  
+
   describe '#gen_dispatch_action' do
-    
+
+    let(:code) { NodeCode.new('Word', 'parsed') }
+
     context 'when nested' do
       it 'generates nested matching code with a dispatch action' do
-        nested_code {|g| g.gen_dispatch_action token, 'Word', 'parsed' }.
+        nested_code {|g| g.gen_dispatch_action token, code }.
           should == (<<-CODE).strip
 begin
   (r = @scanner.scan(/\\w+/)) &&
@@ -72,10 +75,10 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level matching code with a dispatch action' do
-        top_level_code {|g| g.gen_dispatch_action token, 'Word', 'parsed' }.
+        top_level_code {|g| g.gen_dispatch_action token, code }.
           should == (<<-CODE).strip
 (r = @scanner.scan(/\\w+/)) &&
 Word.parsed([r])
@@ -83,12 +86,14 @@ Word.parsed([r])
       end
     end
   end
-  
+
   describe '#gen_direct_action' do
-    
+
+    let(:code) { ActionCode.new('|_| _.to_sym') }
+
     context 'when nested' do
       it 'generates nested matching code with a direct action' do
-        nested_code {|g| g.gen_direct_action token, ActionCode.new('|_| _.to_sym') }.
+        nested_code {|g| g.gen_direct_action token, code }.
           should == (<<-CODE).strip
 begin
   (r = @scanner.scan(/\\w+/)) &&
@@ -97,10 +102,10 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level matching code with a direct action' do
-        top_level_code {|g| g.gen_direct_action token, ActionCode.new('|_| _.to_sym') }.
+        top_level_code {|g| g.gen_direct_action token, code }.
           should == (<<-CODE).strip
 (r = @scanner.scan(/\\w+/)) &&
 (r.to_sym)
@@ -108,16 +113,16 @@ end
       end
     end
   end
-  
+
   describe '#gen_token' do
-    
+
     context 'when nested' do
       it 'generates nested token matching code' do
         nested_code {|g| g.gen_token token }.
           should == '@scanner.scan(/\w+/)'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level token matching code' do
         top_level_code {|g| g.gen_token token }.
@@ -125,16 +130,16 @@ end
       end
     end
   end
-  
+
   describe '#gen_skip' do
-    
+
     context 'when nested' do
       it 'generates nested skipping code' do
         nested_code {|g| g.gen_skip token }.
           should == '(@scanner.skip(/\w+/) && true)'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level skipping code' do
         top_level_code {|g| g.gen_skip token }.
@@ -142,33 +147,33 @@ end
       end
     end
   end
-  
+
   describe '#gen_intermediate' do
     it 'generates nested token matching code' do
       nested_code {|g| g.gen_intermediate token }.
         should == '@scanner.scan(/\w+/)'
     end
   end
-  
+
   describe '#gen_intermediate_assert' do
     it 'generates intermediate positive lookahead code' do
       nested_code {|g| g.gen_intermediate_assert token }.
         should == '@scanner.skip(/(?=\w+)/)'
     end
   end
-  
+
   describe '#gen_intermediate_disallow' do
     it 'generates intermediate negative lookahead code' do
       nested_code {|g| g.gen_intermediate_disallow token }.
         should == '@scanner.skip(/(?!\w+)/)'
     end
   end
-  
+
   describe '#gen_intermediate_skip' do
     it 'generates intermediate skipping code' do
       nested_code {|g| g.gen_intermediate_skip token }.
         should == '@scanner.skip(/\w+/)'
     end
   end
-  
+
 end

data/spec/rattler/back_end/parser_generator/zero_or_more_generator_spec.rb

@@ -1,19 +1,20 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
+include Rattler::BackEnd::ParserGenerator
 include Rattler::Parsers
 
-describe Rattler::BackEnd::ParserGenerator::ZeroOrMoreGenerator do
-  
+describe ZeroOrMoreGenerator do
+
   include ParserGeneratorSpecHelper
-  
+
   let(:zero_or_more) { ZeroOrMore[Match[/w+/]] }
-  
+
   describe '#gen_basic' do
-    
+
     let :zero_or_more do
       ZeroOrMore[Choice[Match[/[[:alpha:]]/], Match[/[[:digit:]]/]]]
     end
-    
+
     context 'when nested' do
       it 'generates nested zero-or-more matching code' do
         nested_code {|g| g.gen_basic zero_or_more }.
@@ -31,7 +32,7 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level zero-or-more matching code' do
         top_level_code {|g| g.gen_basic zero_or_more }.
@@ -48,42 +49,44 @@ a
       end
     end
   end
-  
+
   describe '#gen_assert' do
-    
+
     context 'when nested' do
       it 'generates "true"' do
         nested_code {|g| g.gen_assert zero_or_more }.should == 'true'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates "true"' do
         top_level_code {|g| g.gen_assert zero_or_more }.should == 'true'
       end
     end
   end
-  
+
   describe '#gen_disallow' do
-    
+
     context 'when nested' do
       it 'generates "false"' do
         nested_code {|g| g.gen_disallow zero_or_more }.should == 'false'
       end
     end
-    
+
     context 'when top-level' do
       it 'generates "false"' do
         top_level_code {|g| g.gen_disallow zero_or_more }.should == 'false'
       end
     end
   end
-  
+
   describe '#gen_dispatch_action' do
-    
+
+    let(:code) { NodeCode.new('Word', 'parsed') }
+
     context 'when nested' do
       it 'generates nested zero-or-more matching code with a dispatch action' do
-        nested_code {|g| g.gen_dispatch_action zero_or_more, 'Word', 'parsed' }.
+        nested_code {|g| g.gen_dispatch_action zero_or_more, code }.
           should == (<<-CODE).strip
 begin
   a = []
@@ -95,10 +98,10 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level zero-or-more matching code with a dispatch action' do
-        top_level_code {|g| g.gen_dispatch_action zero_or_more, 'Word', 'parsed' }.
+        top_level_code {|g| g.gen_dispatch_action zero_or_more, code }.
           should == (<<-CODE).strip
 a = []
 while r = @scanner.scan(/w+/)
@@ -109,12 +112,14 @@ Word.parsed(select_captures(a))
       end
     end
   end
-  
+
   describe '#gen_direct_action' do
-    
+
+    let(:code) { ActionCode.new('|_| _.size') }
+
     context 'when nested' do
       it 'generates nested zero-or-more matching code with a direct action' do
-        nested_code {|g| g.gen_direct_action zero_or_more, ActionCode.new('|_| _.size') }.
+        nested_code {|g| g.gen_direct_action zero_or_more, code }.
           should == (<<-CODE).strip
 begin
   a = []
@@ -126,10 +131,10 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level zero-or-more matching code with a direct action' do
-        top_level_code {|g| g.gen_direct_action zero_or_more, ActionCode.new('|_| _.size') }.
+        top_level_code {|g| g.gen_direct_action zero_or_more, code }.
           should == (<<-CODE).strip
 a = []
 while r = @scanner.scan(/w+/)
@@ -140,9 +145,9 @@ end
       end
     end
   end
-  
+
   describe '#gen_token' do
-    
+
     context 'when nested' do
       it 'generates nested zero-or-more matching code' do
         nested_code {|g| g.gen_token zero_or_more }.
@@ -157,7 +162,7 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level zero-or-more matching code' do
         top_level_code {|g| g.gen_token zero_or_more }.
@@ -171,9 +176,9 @@ a.join
       end
     end
   end
-  
+
   describe '#gen_skip' do
-    
+
     context 'when nested' do
       it 'generates nested zero-or-more skipping code' do
         nested_code {|g| g.gen_skip zero_or_more }.
@@ -185,7 +190,7 @@ end
           CODE
       end
     end
-    
+
     context 'when top-level' do
       it 'generates top level zero-or-more skipping code' do
         top_level_code {|g| g.gen_skip zero_or_more }.
@@ -196,7 +201,7 @@ true
       end
     end
   end
-  
+
   describe '#gen_intermediate' do
     it 'generates nested zero-or-more matching code' do
       nested_code {|g| g.gen_intermediate zero_or_more }.
@@ -211,19 +216,19 @@ end
         CODE
     end
   end
-  
+
   describe '#gen_intermediate_assert' do
     it 'generates "true"' do
       nested_code {|g| g.gen_intermediate_assert zero_or_more }.should == 'true'
     end
   end
-  
+
   describe '#gen_intermediate_disallow' do
     it 'generates "false"' do
       nested_code {|g| g.gen_intermediate_disallow zero_or_more }.should == 'false'
     end
   end
-  
+
   describe '#gen_intermediate_skip' do
     it 'generates nested zero-or-more skipping code' do
       nested_code {|g| g.gen_intermediate_skip zero_or_more }.
@@ -235,5 +240,5 @@ end
         CODE
     end
   end
-  
+
 end

data/spec/rattler/back_end/shared_compiler_examples.rb

@@ -0,0 +1,885 @@
+shared_examples_for 'a compiled parser' do
+  include CompilerSpecHelper
+
+  subject do
+    described_class.compile_parser(compiled_parser_base, grammar)
+  end
+
+  let :reference_parser do
+    Rattler::Parsers::CombinatorParser.as_class(grammar.rules.first, grammar.rules)
+  end
+
+  let(:compiled_parser_base) { Rattler::Runtime::RecursiveDescentParser }
+
+  ########## match ##########
+  context 'with a match rule' do
+    let(:grammar) { define_grammar do
+      rule(:digit) { match /\d/ }
+    end }
+    it { should parse('451').succeeding.twice.like reference_parser }
+    it { should parse(' 4').failing.like reference_parser }
+    it { should parse('foo').failing.like reference_parser }
+  end
+
+  ########## choice ##########
+  context 'with a choice rule' do
+    let(:grammar) { define_grammar do
+      rule(:atom) { match(/[[:alpha:]]+/) | match(/[[:digit:]]+/) }
+    end }
+    it { should parse('abc123').succeeding.twice.like reference_parser }
+    it { should parse('==').failing.like reference_parser }
+
+    context 'with nested choices' do
+      let(:grammar) { define_grammar do
+        rule(:foo) do
+          ( (match('a') | match('b')) \
+          | (match('c') | match('d')) )
+        end
+      end }
+      it { should parse('abcd').succeeding(4).times.like reference_parser }
+      it { should parse('123').failing.like reference_parser }
+    end
+
+    context 'with nested sequences' do
+      let(:grammar) { define_grammar do
+        rule(:foo) do
+          ( match('a') & match('b') \
+          | match('c') & match('d') )
+        end
+      end }
+      it { should parse('abcd').succeeding.twice.like reference_parser }
+      it { should parse('123').failing.like reference_parser }
+    end
+
+    context 'with nested optional parsers' do
+      let(:grammar) { define_grammar do
+        rule(:foo) do
+          optional('a') | optional('b')
+        end
+      end }
+      it { should parse('abcd').succeeding(3).times.like reference_parser }
+      it { should parse('123').succeeding.like reference_parser }
+    end
+  end
+
+  ########## sequence ##########
+  context 'with a sequence rule' do
+    let(:grammar) { define_grammar do
+      rule :assignment do
+        match(/[[:alpha:]]+/) & match('=') & match(/[[:digit:]]+/)
+      end
+    end }
+    it { should parse('val=42 ').succeeding.like reference_parser }
+    it { should parse('val=x ').failing.like reference_parser }
+
+    context 'with non-capturing parsers' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          match(/[[:alpha:]]+/) & skip(/\s+/) & match(/[[:digit:]]+/)
+        end
+      end }
+      it { should parse('foo 42').succeeding.like reference_parser }
+    end
+
+    context 'with only one capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(/\s+/) & match(/\w+/)
+        end
+      end }
+      it { should parse('  abc123').succeeding.like reference_parser }
+    end
+
+    context 'with no capturing parsers' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(/\s*/) & skip(/#[^\n]+/)
+        end
+      end }
+      it { should parse(' # foo').succeeding.like reference_parser }
+    end
+
+    context 'with an apply referencing a non-capturing rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          match(/[[:alpha:]]+/) & match(:ws) & match(/[[:digit:]]+/)
+        end
+        rule :ws do
+          skip(/\s+/)
+        end
+      end }
+      it { should parse('foo 42').succeeding.like reference_parser }
+    end
+  end
+
+  ########## optional ##########
+  context 'with an optional rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        optional(/\w+/)
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('    ').succeeding.like reference_parser }
+
+    context 'with a non-capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          optional(skip(/\w+/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+  end
+
+  ########## zero-or-more ##########
+  context 'with an zero-or-more rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        zero_or_more(/\w/)
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('    ').succeeding.like reference_parser }
+
+    context 'with a non-capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          zero_or_more(skip(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+  end
+
+  ########## one-or-more ##########
+  context 'with an one-or-more rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        one_or_more(/\w/)
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+
+    context 'with a non-capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          one_or_more(skip(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  ########## list ##########
+  context 'given a list rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        list(/\w+/, /[,;]/)
+      end
+    end }
+    it { should parse('  ').succeeding.like reference_parser }
+    it { should parse('foo  ').succeeding.like reference_parser }
+    it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+    it { should parse('foo,bar,  ').succeeding.like reference_parser }
+
+    context 'with a non-capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          list(skip(/\w+/), /[,;]/)
+        end
+      end }
+      it { should parse('  ').succeeding.like reference_parser }
+      it { should parse('foo  ').succeeding.like reference_parser }
+      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+      it { should parse('foo,bar,  ').succeeding.like reference_parser }
+    end
+  end
+
+  ########## list1 ##########
+  context 'given a list1 rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        list1(/\w+/, /[,;]/)
+      end
+    end }
+    it { should parse('  ').failing.like reference_parser }
+    it { should parse('foo  ').succeeding.like reference_parser }
+    it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+    it { should parse('foo,bar,  ').succeeding.like reference_parser }
+
+    context 'with a non-capturing parser' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          list1(skip(/\w+/), /[,;]/)
+        end
+      end }
+      it { should parse('  ').failing.like reference_parser }
+      it { should parse('foo  ').succeeding.like reference_parser }
+      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
+      it { should parse('foo,bar,  ').succeeding.like reference_parser }
+    end
+  end
+
+  ########## apply ##########
+  context 'given an apply rule' do
+    let(:grammar) { define_grammar do
+      rule(:digit) { match /\d/ }
+      rule(:foo) { match :digit }
+    end }
+    it { should parse('451 ').twice.succeeding.like reference_parser }
+    it { should parse('hi').failing.like reference_parser }
+  end
+
+  ########## assert ##########
+  context 'given an assert rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert /\w+/ }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(optional(/\w+/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested zero_or_more rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(zero_or_more(/\w/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested one_or_more rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(one_or_more(/\w/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested list rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(list(/\w+/, /,/)) }
+      end }
+      it { should parse('abc,123 ').succeeding.like reference_parser }
+      it { should parse('   ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested list1 rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(list1(/\w+/, /,/)) }
+      end }
+      it { should parse('abc,123 ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:foo) { match :word }
+        rule(:word) { assert /\w+/ }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested dispatch-action rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(dispatch_action(/\w+/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested token rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(token(match(/\w+/))) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+
+    context 'with a nested skip rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { assert(skip(/\w+/)) }
+      end }
+      it { should parse('abc123  ').succeeding.like reference_parser }
+      it { should parse('   ').failing.like reference_parser }
+    end
+  end
+
+  ########## disallow ##########
+  context 'given a disallow rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow /\w+/ }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(match(/[[:alpha:]]/) | match(/[[:digit:]]/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(optional(/\w+/)) }
+      end }
+      it { should parse('   ').failing.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested zero_or_more rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(zero_or_more(/\w/)) }
+      end }
+      it { should parse('   ').failing.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested one_or_more rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(one_or_more(/\w/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested list rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(list(/\w+/, /,/)) }
+      end }
+      it { should parse('   ').failing.like reference_parser }
+      it { should parse('abc,123 ').failing.like reference_parser }
+    end
+
+    context 'with a nested list1 rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(list1(/\w+/, /,/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc,123 ').failing.like reference_parser }
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:foo) { match :word }
+        rule(:word) { disallow /\w+/ }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested dispatch-action rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(dispatch_action(/\w+/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested token rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(token(match(/\w+/))) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+
+    context 'with a nested skip rule' do
+      let(:grammar) { define_grammar do
+        rule(:word) { disallow(skip(/\w+/)) }
+      end }
+      it { should parse('   ').succeeding.like reference_parser }
+      it { should parse('abc123  ').failing.like reference_parser }
+    end
+  end
+
+  ########## dispatch_action ##########
+  context 'given a dispatch-action rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:digits) { dispatch_action(/\d+/) }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule :atom do
+          dispatch_action(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
+        end
+      end }
+
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule :assignment do
+          dispatch_action(
+            match(/[[:alpha:]]+/) &
+            match('=') &
+            match(/[[:digit:]]+/)
+          )
+        end
+      end }
+
+      it { should parse('val=42 ').succeeding.like reference_parser }
+      it { should parse('val=x').failing.like reference_parser }
+
+      context 'with labels' do
+        let(:grammar) { define_grammar do
+          rule :assignment do
+            dispatch_action(
+              label(:name, /[[:alpha:]]+/) &
+              match('=') &
+              label(:value, /[[:digit:]]+/)
+            )
+          end
+        end }
+        it { should parse('val=42 ').succeeding.like reference_parser }
+      end
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          dispatch_action(optional(/\w+/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested zero-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          dispatch_action(zero_or_more(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested one-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          dispatch_action(one_or_more(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:digit) { match /\d/ }
+        rule(:foo) { dispatch_action :digit }
+      end }
+      it { should parse('451a').succeeding.twice.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested token rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          dispatch_action(token(match(/\w+/)))
+        end
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested skip rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          dispatch_action(skip(/\w+/))
+        end
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  ########## direct_action ##########
+  context 'given a direct-action rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:num) { direct_action(/\d+/, '|_| _.to_i') }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(
+            match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
+            '|_| _.size'
+          )
+        end
+      end }
+
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule :assignment do
+          direct_action(
+            match(/[[:alpha:]]+/) & match('=') & match(/[[:digit:]]+/),
+            '|l,_,r| "#{r} -> #{l}"'
+          )
+        end
+      end }
+
+      it { should parse('val=42 ').succeeding.like reference_parser }
+      it { should parse('val=x').failing.like reference_parser }
+
+      context 'with labels' do
+        let(:grammar) { define_grammar do
+          rule :assignment do
+            direct_action(
+              label(:name, /[[:alpha:]]+/) & match('=') & label(:value, /[[:digit:]]+/),
+              '"#{value} -> #{name}"'
+            )
+          end
+        end }
+        it { should parse('val=42 ').succeeding.like reference_parser }
+      end
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(optional(/\w+/), '|_| _.size')
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested zero-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(zero_or_more(/\w/), '|_| _.size')
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested one-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(one_or_more(/\w/), '|_| _.size')
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:digit) { match /\d/ }
+        rule(:foo) { direct_action :digit, '|_| _.to_i' }
+      end }
+      it { should parse('451a').succeeding.twice.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested token rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(token(/\w+/), '|_| _.size')
+        end
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested skip rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          direct_action(skip(/\w+/), '42' )
+        end
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+  end
+
+  ########## token ##########
+  context 'given a token rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:digits) { token(match(/\d+/)) }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('hi').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule(:atom) do
+          token(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
+        end
+      end }
+
+      it { should parse('abc123 ').succeeding.like reference_parser }
+      it { should parse('==').failing.like reference_parser }
+
+      context 'with non-capturing choices' do
+        let(:grammar) { define_grammar do
+          rule(:atom) do
+            token(skip(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
+          end
+        end }
+        it { should parse('abc123 ').succeeding.like reference_parser }
+        it { should parse('==').failing.like reference_parser }
+      end
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule(:atom) do
+          token(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/))
+        end
+      end }
+
+      it { should parse('foo42!').succeeding.like reference_parser }
+      it { should parse('val=x').failing.like reference_parser }
+
+      context 'with non-capturing parsers' do
+        let(:grammar) { define_grammar do
+          rule :foo do
+            token(match(/[[:alpha:]]+/) & skip(/\s+/) & match(/[[:digit:]]+/))
+          end
+        end }
+        it { should parse('foo 42').succeeding.like reference_parser }
+        it { should parse('foo bar').failing.like reference_parser }
+      end
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          token(optional(/\w+/))
+        end
+      end }
+
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+
+      context 'with a non-capturing rule' do
+        let(:grammar) { define_grammar do
+          rule :foo do
+            token(optional(skip(/\w+/)))
+          end
+        end }
+        it { should parse('foo ').succeeding.like reference_parser }
+        it { should parse('    ').succeeding.like reference_parser }
+      end
+    end
+
+    context 'with a nested zero-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          token(zero_or_more(/\w/))
+        end
+      end }
+
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+
+      context 'with a non-capturing rule' do
+        let(:grammar) { define_grammar do
+          rule :foo do
+            token(zero_or_more(skip(/\w/)))
+          end
+        end }
+        it { should parse('foo ').succeeding.like reference_parser }
+        it { should parse('    ').succeeding.like reference_parser }
+      end
+    end
+
+    context 'with a nested one-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          token(one_or_more(/\w/))
+        end
+      end }
+
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+
+      context 'with a non-capturing rule' do
+        let(:grammar) { define_grammar do
+          rule :foo do
+            token(one_or_more(skip(/\w/)))
+          end
+        end }
+        it { should parse('foo ').succeeding.like reference_parser }
+        it { should parse('    ').failing.like reference_parser }
+      end
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:foo) { token(match(:digits)) }
+        rule(:digits) { match(/\d+/) }
+      end }
+
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('hi').failing.like reference_parser }
+
+      context 'applying a non-capturing rule' do
+        let(:grammar) { define_grammar do
+          rule(:foo) { token(match(:digits)) }
+          rule(:digits) { skip(/\d+/) }
+        end }
+        it { should parse('451a').succeeding.like reference_parser }
+        it { should parse('hi').failing.like reference_parser }
+      end
+    end
+
+    context 'with a nested dispatch-action rule' do
+      let(:grammar) { define_grammar do
+        rule(:foo) { token(dispatch_action(/\w+/)) }
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('  ').failing.like reference_parser }
+    end
+
+    context 'with a nested skip rule' do
+      let(:grammar) { define_grammar do
+        rule(:foo) { token(skip(/\w+/)) }
+      end }
+      it { should parse('abc123').succeeding.like reference_parser }
+      it { should parse('  ').failing.like reference_parser }
+    end
+  end
+
+  ########## skip ##########
+  context 'given a skip rule' do
+
+    context 'with a nested match rule' do
+      let(:grammar) { define_grammar do
+        rule(:ws) { skip(/\s+/) }
+      end }
+      it { should parse('   foo').succeeding.like reference_parser }
+      it { should parse('hi').failing.like reference_parser }
+    end
+
+    context 'with a nested choice rule' do
+      let(:grammar) { define_grammar do
+        rule(:ws) do
+          skip(match(/\s+/) | match(/\#[^\n]*/))
+        end
+      end }
+      it { should parse('   # hi there ').succeeding.twice.like reference_parser }
+      it { should parse('hi').failing.like reference_parser }
+    end
+
+    context 'with a nested sequence rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/))
+        end
+      end }
+      it { should parse('foo42!').succeeding.like reference_parser }
+      it { should parse('val=x').failing.like reference_parser }
+    end
+
+    context 'with a nested optional rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(optional(/\w+/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested zero-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(zero_or_more(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').succeeding.like reference_parser }
+    end
+
+    context 'with a nested one-or-more rule' do
+      let(:grammar) { define_grammar do
+        rule :foo do
+          skip(one_or_more(/\w/))
+        end
+      end }
+      it { should parse('foo ').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'with a nested apply rule' do
+      let(:grammar) { define_grammar do
+        rule(:digits) { match(/\d+/) }
+        rule(:foo) { skip(:digits) }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('hi').failing.like reference_parser }
+    end
+  end
+
+end