rattler 0.5.0 → 0.6.0

data/spec/rattler/compiler/parser_generator/super_generator_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Compiler::ParserGenerator
+include Rattler::Parsers
+
+describe SuperGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  let(:parser) { Super[:foo] }
+
+  describe '#gen_basic' do
+    it 'generates "super"' do
+      nested_code {|g| g.gen_basic parser }.should == 'super'
+    end
+  end
+
+  describe '#gen_assert' do
+
+    context 'when nested' do
+      it 'generates nested "assert super" code' do
+        nested_code {|g| g.gen_assert parser }.should == (<<-CODE).strip
+begin
+  p = @scanner.pos
+  r = (super && true)
+  @scanner.pos = p
+  r
+end
+        CODE
+      end
+    end
+
+    context 'when top level' do
+      it 'generates top-level "assert super" code' do
+        top_level_code {|g| g.gen_assert parser }.should == (<<-CODE).strip
+p = @scanner.pos
+r = (super && true)
+@scanner.pos = p
+r
+        CODE
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+
+    context 'when nested' do
+      it 'generates nested "disallow super" code' do
+        nested_code {|g| g.gen_disallow parser }.should == (<<-CODE).strip
+begin
+  p = @scanner.pos
+  r = !super
+  @scanner.pos = p
+  r
+end
+        CODE
+      end
+    end
+
+    context 'when top level' do
+      it 'generates top-level "disallow super" code' do
+        top_level_code {|g| g.gen_disallow parser }.should == (<<-CODE).strip
+p = @scanner.pos
+r = !super
+@scanner.pos = p
+r
+        CODE
+      end
+    end
+  end
+
+  describe '#gen_token' do
+    it 'generates "super.to_s"' do
+      nested_code {|g| g.gen_token parser }.should == 'super.to_s'
+    end
+  end
+
+  describe '#gen_skip' do
+
+    context 'when nested' do
+      it 'generates "(super && true)"' do
+        nested_code {|g| g.gen_skip parser }.should == '(super && true)'
+      end
+    end
+
+    context 'when top level' do
+      it 'generates "super && true"' do
+        top_level_code {|g| g.gen_skip parser }.should == 'super && true'
+      end
+    end
+  end
+
+end

data/spec/rattler/{back_end → compiler}/parser_generator/token_generator_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
-include Rattler::BackEnd::ParserGenerator
+include Rattler::Compiler::ParserGenerator
 include Rattler::Parsers
 
 describe TokenGenerator do
@@ -60,60 +60,6 @@ describe TokenGenerator do
     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, code }.
-          should == (<<-CODE).strip
-begin
-  (r = @scanner.scan(/\\w+/)) &&
-  Word.parsed([r])
-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, code }.
-          should == (<<-CODE).strip
-(r = @scanner.scan(/\\w+/)) &&
-Word.parsed([r])
-          CODE
-      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, code }.
-          should == (<<-CODE).strip
-begin
-  (r = @scanner.scan(/\\w+/)) &&
-  (r.to_sym)
-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, code }.
-          should == (<<-CODE).strip
-(r = @scanner.scan(/\\w+/)) &&
-(r.to_sym)
-          CODE
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     context 'when nested' do

data/spec/rattler/{back_end → compiler}/parser_generator/zero_or_more_generator_examples.rb

@@ -83,80 +83,6 @@ a
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'given a repeat with zero-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested zero-or-more matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  while r = @scanner.scan(/w+/)
-    a << r
-  end
-  Word.parsed(select_captures(a))
-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 repeat, code }.
-            should == (<<-CODE).strip
-a = []
-while r = @scanner.scan(/w+/)
-  a << r
-end
-Word.parsed(select_captures(a))
-            CODE
-        end
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { ActionCode.new('|_| _.size') }
-
-    context 'given a repeat with zero-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested zero-or-more matching code with a direct action' do
-          nested_code {|g| g.gen_direct_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  while r = @scanner.scan(/w+/)
-    a << r
-  end
-  (select_captures(a).size)
-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 repeat, code }.
-            should == (<<-CODE).strip
-a = []
-while r = @scanner.scan(/w+/)
-  a << r
-end
-(select_captures(a).size)
-            CODE
-        end
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     let(:nested) { Match[/w+/] }

data/spec/rattler/{back_end → compiler}/ruby_generator_spec.rb

@@ -1,41 +1,41 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Rattler::BackEnd::RubyGenerator do
-  
-  subject { Rattler::BackEnd::RubyGenerator.new }
-  
+describe Rattler::Compiler::RubyGenerator do
+
+  subject { Rattler::Compiler::RubyGenerator.new }
+
   describe '<<' do
     it 'concatenates code' do
       (subject << 'foo' << '(:bar)').code.should == 'foo(:bar)'
     end
   end
-  
+
   describe '#newline' do
     it 'starts new lines' do
       ((subject << 'foo').newline << 'bar').code.should == "foo\nbar"
     end
   end
-  
+
   describe '#indent' do
     it 'indents lines' do
       subject.indent { (subject << 'foo').newline << 'bar' }.code.
         should == "\n  foo\n  bar"
     end
   end
-  
+
   describe '#surround' do
     it 'surrounds code with the given prefix and suffix' do
       subject.surround('(', ')') { subject << 'foo' }.code.should == '(foo)'
     end
   end
-  
+
   describe '#block' do
     it 'generates blocks' do
       subject.block('for n in names') { subject << 'puts n' }.code.
         should == "for n in names\n  puts n\nend"
     end
   end
-  
+
   describe '#intersperse' do
     context 'given the :sep option by itself' do
       it 'intersperses the separator without newlines' do
@@ -44,7 +44,7 @@ describe Rattler::BackEnd::RubyGenerator do
         end.code.should == "aa + bb + cc"
       end
     end
-    
+
     context 'given :newline => true' do
       it 'intersperses the separator with single newlines' do
         subject.intersperse(['a', 'b', 'c'], :sep => ' +', :newline => true) do |_|
@@ -52,7 +52,7 @@ describe Rattler::BackEnd::RubyGenerator do
         end.code.should == "aa +\nbb +\ncc"
       end
     end
-    
+
     context 'given :newlines => n' do
       it 'intersperses separators with multiple newlines' do
         subject.intersperse(['a', 'b', 'c'], :sep => ' +', :newlines => 2) do |_|
@@ -60,7 +60,7 @@ describe Rattler::BackEnd::RubyGenerator do
         end.code.should == "aa +\n\nbb +\n\ncc"
       end
     end
-    
+
     context 'given :newlines => n and no :sep option' do
       it 'intersperses the newlines without any other separator' do
         subject.intersperse(['a', 'b', 'c'], :newline => true) do |_|
@@ -69,5 +69,5 @@ describe Rattler::BackEnd::RubyGenerator do
       end
     end
   end
-  
+
 end

data/spec/rattler/compiler/semantic_action_compiler_examples.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+shared_examples_for 'a compiled parser with a semantic action' do
+  include CompilerSpecHelper
+  include RuntimeParserSpecHelper
+
+  subject { compiled_parser }
+
+  let(:reference_parser) { combinator_parser grammar }
+
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
+  context 'when the expression has no parameters' do
+    let(:rules) { [
+      rule(:a) { semantic_action('42') }
+    ] }
+    it { should parse('anything').succeeding.like reference_parser }
+  end
+
+  context 'when the expression has parameters' do
+    let(:rules) { [
+      rule(:a) { match(/\d+/) >> semantic_action('|a| a.to_i * 2') }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'when the expression uses "_"' do
+
+    context 'given a single capture' do
+      let(:rules) { [
+        rule(:a) { match(/\d+/) >> semantic_action('_ * 2') }
+      ] }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+    end
+
+    context 'given multiple captures' do
+      let(:rules) { [
+        rule(:a) {
+          (match(/\d+/) & skip(/\s+/) & match(/\d+/)) >> semantic_action('_')
+        }
+      ] }
+      it { should parse('23 42').succeeding.like reference_parser }
+      it { should parse('     ').failing.like reference_parser }
+    end
+  end
+
+  context 'when the expression uses labels' do
+    let(:rules) { [
+      rule(:a) { label(:a, /\d+/) & semantic_action('a.to_i * 2') }
+    ] }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+end

data/spec/rattler/{back_end → compiler}/shared_compiler_examples.rb

@@ -1,24 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require File.expand_path('assert_compiler_examples', File.dirname(__FILE__))
 require File.expand_path('disallow_compiler_examples', File.dirname(__FILE__))
-require File.expand_path('dispatch_action_compiler_examples', File.dirname(__FILE__))
-require File.expand_path('direct_action_compiler_examples', File.dirname(__FILE__))
-require File.expand_path('side_effect_compiler_examples', File.dirname(__FILE__))
-require File.expand_path('semantic_assert_compiler_examples', File.dirname(__FILE__))
-require File.expand_path('semantic_disallow_compiler_examples', File.dirname(__FILE__))
+require File.expand_path('semantic_action_compiler_examples', File.dirname(__FILE__))
+require File.expand_path('attributed_sequence_compiler_examples', File.dirname(__FILE__))
 require File.expand_path('token_compiler_examples', File.dirname(__FILE__))
 require File.expand_path('skip_compiler_examples', File.dirname(__FILE__))
 
 shared_examples_for 'a compiled parser' do
   include CompilerSpecHelper
+  include RuntimeParserSpecHelper
 
   it_behaves_like 'a compiled parser with an assert'
   it_behaves_like 'a compiled parser with a disallow'
-  it_behaves_like 'a compiled parser with a dispatch action'
-  it_behaves_like 'a compiled parser with a direct action'
-  it_behaves_like 'a compiled parser with a side effect'
-  it_behaves_like 'a compiled parser with a positive semantic predicate'
-  it_behaves_like 'a compiled parser with a negative semantic predicate'
+  it_behaves_like 'a compiled parser with a semantic action'
+  it_behaves_like 'a compiled parser with an attributed sequence'
   it_behaves_like 'a compiled parser with a token'
   it_behaves_like 'a compiled parser with a skip'
 
@@ -26,11 +21,13 @@ shared_examples_for 'a compiled parser' do
 
   let(:reference_parser) { combinator_parser grammar }
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   ########## match ##########
   context 'with a match rule' do
-    let(:grammar) { define_grammar do
-      rule(:digit) { match /\d/ }
-    end }
+    let(:rules) { [
+      rule(:digit) { match(/\d/) }
+    ] }
     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 }
@@ -38,50 +35,46 @@ shared_examples_for 'a compiled parser' do
 
   ########## choice ##########
   context 'with a choice rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       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 non-capturing parsers' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          skip(/\s+/) | skip(/\{[^\}]*\}/)
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) { skip(/\s+/) | skip(/\{[^\}]*\}/) }
+      ] }
       it { should parse('   foo').succeeding.like reference_parser }
       it { should parse('{foo}').succeeding.like reference_parser }
     end
 
     context 'with nested choices' do
-      let(:grammar) { define_grammar do
-        rule(:foo) do
+      let(:rules) { [
+        rule(:foo) {
           ( (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
+      let(:rules) { [
+        rule(:foo) {
           ( 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 }
+      let(:rules) { [
+        rule(:foo) { match('a').optional | match('b').optional }
+      ] }
       it { should parse('abcd').succeeding(3).times.like reference_parser }
       it { should parse('123').succeeding.like reference_parser }
     end
@@ -89,70 +82,60 @@ shared_examples_for 'a compiled parser' do
 
   ########## sequence ##########
   context 'with a sequence rule' do
-    let(:grammar) { define_grammar do
-      rule :assignment do
+    let(:rules) { [
+      rule(:assignment) {
         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
+      let(:rules) { [
+        rule(:foo) {
           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 }
+      let(:rules) { [
+        rule(:foo) { skip(/\s+/) & match(/\w+/) }
+      ] }
       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 }
+      let(:rules) { [
+        rule(:foo) { skip(/\s*/) & skip(/#[^\n]+/) }
+      ] }
       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
+      let(:rules) { [
+        rule(:foo) {
           match(/[[:alpha:]]+/) & match(:ws) & match(/[[:digit:]]+/)
-        end
-        rule :ws do
-          skip(/\s+/)
-        end
-      end }
+        },
+        rule(:ws) { skip(/\s+/) }
+      ] }
       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 }
+    let(:rules) { [
+      rule(:foo) { match(/\w+/).optional }
+    ] }
     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 }
+      let(:rules) { [
+        rule(:foo) { skip(/\w+/).optional }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').succeeding.like reference_parser }
     end
@@ -160,20 +143,16 @@ shared_examples_for 'a compiled parser' do
 
   ########## 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 }
+    let(:rules) { [
+      rule(:foo) { match(/\w/).zero_or_more }
+    ] }
     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 }
+      let(:rules) { [
+        rule(:foo) { skip(/\w/).zero_or_more }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').succeeding.like reference_parser }
     end
@@ -181,20 +160,16 @@ shared_examples_for 'a compiled parser' do
 
   ########## 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 }
+    let(:rules) { [
+      rule(:foo) { match(/\w/).one_or_more }
+    ] }
     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 }
+      let(:rules) { [
+        rule(:foo) { skip(/\w/).one_or_more }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').failing.like reference_parser }
     end
@@ -202,55 +177,59 @@ shared_examples_for 'a compiled parser' do
 
   ########## repeat ##########
   context 'with a repeat rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        repeat(/\w/, 2, 4)
-      end
-    end }
+    let(:rules) { [
+      rule(:foo) { match(/\w/).repeat(2, 4) }
+    ] }
     it { should parse('foo ').succeeding.like reference_parser }
     it { should parse('abcde ').succeeding.like reference_parser }
     it { should parse('a ').failing.like reference_parser }
 
     context 'with no upper bound' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          repeat(/\w/, 2, nil)
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) { match(/\w/).repeat(2, nil) }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('abcde ').succeeding.like reference_parser }
       it { should parse('a ').failing.like reference_parser }
     end
 
     context 'with a non-capturing parser' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          repeat(skip(/\w/), 2, 4)
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) { skip(/\w/).repeat(2, 4) }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('abcde ').succeeding.like reference_parser }
       it { should parse('a ').failing.like reference_parser }
     end
+
+    context 'with a choice of capturing or non-capturing parsers' do
+      let(:rules) { [
+        rule(:foo) { (match(/a/) | skip(/b/)).repeat(2, 4) }
+      ] }
+      it { should parse('abac').succeeding.like reference_parser }
+    end
+
+    context 'with an attributed sequence with an action returning true' do
+      let(:rules) { [
+        rule(:foo) { (match(/\w/) >> semantic_action('true')).repeat(2, 4) }
+      ] }
+      it { should parse('abc ').succeeding.like reference_parser }
+    end
   end
 
   ########## list ##########
   context 'given a list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        list(/\w+/, /[,;]/, 2, nil)
-      end
-    end }
+    let(:rules) { [
+      rule(:foo) { match(/\w+/).list(match(/[,;]/), 2, nil) }
+    ] }
     it { should parse('foo  ').failing.like reference_parser }
     it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
     it { should parse('foo,bar,  ').succeeding.like reference_parser }
 
     context 'with an upper bound' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          list(/\w+/, /[,;]/, 2, 4)
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) { match(/\w+/).list(match(/[,;]/), 2, 4) }
+      ] }
       it { should parse('foo  ').failing.like reference_parser }
       it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
       it { should parse('a,b,c,d,e  ').succeeding.like reference_parser }
@@ -258,21 +237,17 @@ shared_examples_for 'a compiled parser' do
     end
 
     context 'with a non-capturing parser' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          list(skip(/\w+/), /[,;]/, 2, nil)
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) { skip(/\w+/).list(match(/[,;]/), 2, nil) }
+      ] }
       it { should parse('foo  ').failing.like reference_parser }
       it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
       it { should parse('foo,bar,  ').succeeding.like reference_parser }
 
       context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule :foo do
-            list(skip(/\w+/), /[,;]/, 2, 4)
-          end
-        end }
+        let(:rules) { [
+          rule(:foo) { skip(/\w+/).list(match(/[,;]/), 2, 4) }
+        ] }
         it { should parse('foo  ').failing.like reference_parser }
         it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
         it { should parse('a,b,c,d,e  ').succeeding.like reference_parser }
@@ -280,22 +255,18 @@ shared_examples_for 'a compiled parser' do
       end
 
       context 'with "zero-or-more" bounds' do
-        let(:grammar) { define_grammar do
-          rule :foo do
-            list(skip(/\w+/), /[,;]/, 0, nil)
-          end
-        end }
+        let(:rules) { [
+          rule(:foo) { skip(/\w+/).list(match(/[,;]/), 0, nil) }
+        ] }
         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 }
       end
 
       context 'with "one-or-more" bounds' do
-        let(:grammar) { define_grammar do
-          rule :foo do
-            list(skip(/\w+/), /[,;]/, 1, nil)
-          end
-        end }
+        let(:rules) { [
+          rule(:foo) { skip(/\w+/).list(match(/[,;]/), 1, nil) }
+        ] }
         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 }
@@ -305,19 +276,19 @@ shared_examples_for 'a compiled parser' do
 
   ########## apply ##########
   context 'given an apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:digit) { match /\d/ }
+    let(:rules) { [
+      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
 
   ########## eof ##########
   context 'given eof' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { eof }
-    end }
+    ] }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').from(3).succeeding.like reference_parser }
     it { should parse('foo').failing.like reference_parser }
@@ -325,9 +296,9 @@ shared_examples_for 'a compiled parser' do
 
   ########## E ##########
   context 'given "E" symbol' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { e }
-    end }
+    ] }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').succeeding.like reference_parser }
   end