rattler 0.4.2 → 0.5.0

data/spec/rattler/back_end/semantic_assert_compiler_examples.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+shared_examples_for 'a compiled parser with a positive semantic predicate' do
+  include CompilerSpecHelper
+
+  subject { compiled_parser }
+
+  let(:reference_parser) { combinator_parser grammar }
+
+  context 'with a nested match rule' do
+    let(:grammar) { define_grammar do
+      rule(:num) { semantic_assert(/\d+/, '_.to_i > 200') }
+    end }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('123a').failing.like reference_parser }
+
+    context 'with a label' do
+      let(:grammar) { define_grammar do
+        rule(:digits) { semantic_assert(label(:num, /\d+/), 'num.to_i > 200') }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+      it { should parse('123a').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested apply rule' do
+    let(:grammar) { define_grammar do
+      rule(:foo) { semantic_assert :digit, '_.to_i > 200' }
+      rule(:digit) { match(/\d+/) }
+    end }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('123a').failing.like reference_parser }
+
+    context 'with a label' do
+      let(:grammar) { define_grammar do
+        rule(:num) { semantic_assert(label(:num, :digits), 'num.to_i > 200') }
+        rule(:digits) { match(/\d+/) }
+      end }
+      it { should parse('451a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+      it { should parse('123a').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested choice rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_assert(
+          match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
+          '_.size > 2'
+        )
+      end
+    end }
+
+    it { should parse('abc123').succeeding.like reference_parser }
+    it { should parse('12abc').failing.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
+        semantic_assert(
+          match(/\w+/) & match('=') & match(/\w+/),
+          '|l,_,r| l == r'
+        )
+      end
+    end }
+    it { should parse('451a=451a ').succeeding.like reference_parser }
+    it { should parse('451a=123a ').failing.like reference_parser }
+
+    context 'with labels' do
+      let(:grammar) { define_grammar do
+        rule :assignment do
+          semantic_assert(
+            label(:lt, /\w+/) & match('=') & label(:rt, /\w+/),
+            'lt == rt'
+          )
+        end
+      end }
+      it { should parse('451a=451a ').succeeding.like reference_parser }
+      it { should parse('451a=123a ').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested optional rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_assert(optional(/\w+/), '|_| _.empty?')
+      end
+    end }
+    it { should parse('foo ').failing.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
+        semantic_assert(zero_or_more(/\w/), '|_| _.size < 4')
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('food').failing.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
+        semantic_assert(one_or_more(/\w/), '|_| _.size < 4')
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('food').failing.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'with a nested list rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_assert(list(/\w+/, /,/, 1, nil), '|_| _.size < 4')
+      end
+    end }
+    it { should parse('a,bc,d ').succeeding.like reference_parser }
+    it { should parse('a,b,c,d').failing.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) { semantic_assert :digit, '_.to_i > 200' }
+      rule(:digit) { match /\d+/ }
+    end }
+    it { should parse('451a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('123a').failing.like reference_parser }
+  end
+
+  context 'with a nested token rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_assert(token(/\w+/), '_.size > 5')
+      end
+    end }
+    it { should parse('abc123').succeeding.like reference_parser }
+    it { should parse('      ').failing.like reference_parser }
+    it { should parse('abc12 ').failing.like reference_parser }
+  end
+end

data/spec/rattler/back_end/semantic_disallow_compiler_examples.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+shared_examples_for 'a compiled parser with a negative semantic predicate' do
+  include CompilerSpecHelper
+
+  subject { compiled_parser }
+
+  let(:reference_parser) { combinator_parser grammar }
+
+  context 'with a nested match rule' do
+    let(:grammar) { define_grammar do
+      rule(:num) { semantic_disallow(/\d+/, '_.to_i > 200') }
+    end }
+    it { should parse('123a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('451a').failing.like reference_parser }
+
+    context 'with a label' do
+      let(:grammar) { define_grammar do
+        rule(:digits) { semantic_disallow(label(:num, /\d+/), 'num.to_i > 200') }
+      end }
+      it { should parse('123a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+      it { should parse('451a').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested apply rule' do
+    let(:grammar) { define_grammar do
+      rule(:foo) { semantic_disallow :digit, '_.to_i > 200' }
+      rule(:digit) { match(/\d+/) }
+    end }
+    it { should parse('123a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('451a').failing.like reference_parser }
+
+    context 'with a label' do
+      let(:grammar) { define_grammar do
+        rule(:num) { semantic_disallow(label(:num, :digits), 'num.to_i > 200') }
+        rule(:digits) { match(/\d+/) }
+      end }
+      it { should parse('123a').succeeding.like reference_parser }
+      it { should parse('    ').failing.like reference_parser }
+      it { should parse('451a').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested choice rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_disallow(
+          match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
+          '_.size > 2'
+        )
+      end
+    end }
+
+    it { should parse('12abc').succeeding.like reference_parser }
+    it { should parse('abc123').failing.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
+        semantic_disallow(
+          match(/\w+/) & match('=') & match(/\w+/),
+          '|l,_,r| l == r'
+        )
+      end
+    end }
+    it { should parse('451a=123a ').succeeding.like reference_parser }
+    it { should parse('451a=451a ').failing.like reference_parser }
+
+    context 'with labels' do
+      let(:grammar) { define_grammar do
+        rule :assignment do
+          semantic_disallow(
+            label(:lt, /\w+/) & match('=') & label(:rt, /\w+/),
+            'lt == rt'
+          )
+        end
+      end }
+      it { should parse('451a=123a ').succeeding.like reference_parser }
+      it { should parse('451a=451a ').failing.like reference_parser }
+    end
+  end
+
+  context 'with a nested optional rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_disallow(optional(/\w+/), '|_| _.empty?')
+      end
+    end }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('foo ').succeeding.like reference_parser }
+  end
+
+  context 'with a nested zero-or-more rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_disallow(zero_or_more(/\w/), '|_| _.size > 3')
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('food').failing.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
+        semantic_disallow(one_or_more(/\w/), '|_| _.size > 3')
+      end
+    end }
+    it { should parse('foo ').succeeding.like reference_parser }
+    it { should parse('food').failing.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+  end
+
+  context 'with a nested list rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_disallow(list(/\w+/, /,/, 1, nil), '|_| _.size > 3')
+      end
+    end }
+    it { should parse('a,bc,d ').succeeding.like reference_parser }
+    it { should parse('a,b,c,d').failing.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) { semantic_disallow :digit, '_.to_i > 200' }
+      rule(:digit) { match /\d+/ }
+    end }
+    it { should parse('123a').succeeding.like reference_parser }
+    it { should parse('    ').failing.like reference_parser }
+    it { should parse('451a').failing.like reference_parser }
+  end
+
+  context 'with a nested token rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        semantic_disallow(token(/\w+/), '_.size > 5')
+      end
+    end }
+    it { should parse('abc12 ').succeeding.like reference_parser }
+    it { should parse('      ').failing.like reference_parser }
+    it { should parse('abc123').failing.like reference_parser }
+  end
+end

data/spec/rattler/back_end/shared_compiler_examples.rb

@@ -1,6 +1,27 @@
+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('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
 
+  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 token'
+  it_behaves_like 'a compiled parser with a skip'
+
   subject { compiled_parser }
 
   let(:reference_parser) { combinator_parser grammar }
@@ -23,6 +44,16 @@ shared_examples_for 'a compiled parser' do
     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 }
+      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
@@ -169,711 +200,135 @@ shared_examples_for 'a compiled parser' do
     end
   end
 
-  ########## list ##########
-  context 'given a list rule' do
+  ########## repeat ##########
+  context 'with a repeat rule' do
     let(:grammar) { define_grammar do
       rule :foo do
-        list(/\w+/, /[,;]/)
+        repeat(/\w/, 2, 4)
       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
+    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 a nested zero-or-more rule' do
+    context 'with no upper bound' do
       let(:grammar) { define_grammar do
         rule :foo do
-          dispatch_action(zero_or_more(/\w/))
+          repeat(/\w/, 2, nil)
         end
       end }
       it { should parse('foo ').succeeding.like reference_parser }
-      it { should parse('    ').succeeding.like reference_parser }
+      it { should parse('abcde ').succeeding.like reference_parser }
+      it { should parse('a ').failing.like reference_parser }
     end
 
-    context 'with a nested one-or-more rule' do
+    context 'with a non-capturing parser' do
       let(:grammar) { define_grammar do
         rule :foo do
-          dispatch_action(one_or_more(/\w/))
+          repeat(skip(/\w/), 2, 4)
         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 }
+      it { should parse('abcde ').succeeding.like reference_parser }
+      it { should parse('a ').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 }
+  ########## list ##########
+  context 'given a list rule' do
+    let(:grammar) { define_grammar do
+      rule :foo do
+        list(/\w+/, /[,;]/, 2, nil)
       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
+    end }
+    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 a nested skip rule' do
+    context 'with an upper bound' 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:]]+/))
+          list(/\w+/, /[,;]/, 2, 4)
         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
+      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 }
+      it { should parse('foo,bar,  ').succeeding.like reference_parser }
     end
 
-    context 'with a nested optional rule' do
+    context 'with a non-capturing parser' do
       let(:grammar) { define_grammar do
         rule :foo do
-          token(optional(/\w+/))
+          list(skip(/\w+/), /[,;]/, 2, nil)
         end
       end }
+      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 }
 
-      it { should parse('foo ').succeeding.like reference_parser }
-      it { should parse('    ').succeeding.like reference_parser }
-
-      context 'with a non-capturing rule' do
+      context 'with an upper bound' do
         let(:grammar) { define_grammar do
           rule :foo do
-            token(optional(skip(/\w+/)))
+            list(skip(/\w+/), /[,;]/, 2, 4)
           end
         end }
-        it { should parse('foo ').succeeding.like reference_parser }
-        it { should parse('    ').succeeding.like reference_parser }
+        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 }
+        it { should parse('foo,bar,  ').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
+      context 'with "zero-or-more" bounds' do
         let(:grammar) { define_grammar do
           rule :foo do
-            token(zero_or_more(skip(/\w/)))
+            list(skip(/\w+/), /[,;]/, 0, nil)
           end
         end }
-        it { should parse('foo ').succeeding.like reference_parser }
-        it { should parse('    ').succeeding.like reference_parser }
+        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
-    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
+      context 'with "one-or-more" bounds' do
         let(:grammar) { define_grammar do
           rule :foo do
-            token(one_or_more(skip(/\w/)))
+            list(skip(/\w+/), /[,;]/, 1, nil)
           end
         end }
-        it { should parse('foo ').succeeding.like reference_parser }
-        it { should parse('    ').failing.like reference_parser }
+        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 }
       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
+  ########## 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
 
-    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
+  ########## eof ##########
+  context 'given eof' do
+    let(:grammar) { define_grammar do
+      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 }
   end
 
+  ########## E ##########
+  context 'given "E" symbol' do
+    let(:grammar) { define_grammar do
+      rule(:foo) { e }
+    end }
+    it { should parse('').succeeding.like reference_parser }
+    it { should parse('foo').succeeding.like reference_parser }
+  end
 end