rattler 0.5.0 → 0.6.0

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

@@ -2,148 +2,151 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 shared_examples_for 'a compiled parser with a skip' do
   include CompilerSpecHelper
+  include RuntimeParserSpecHelper
 
   subject { compiled_parser }
 
   let(:reference_parser) { combinator_parser grammar }
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   context 'with a nested match rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       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 apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:spaces) { match(/\s+/) }
+    let(:rules) { [
+      rule(:spaces) { match(/\s+/) },
       rule(:ws) { skip(:spaces) }
-    end }
+    ] }
     it { should parse('   foo').succeeding.like reference_parser }
     it { should parse('hi').failing.like reference_parser }
   end
 
   context 'with a nested assert rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { skip(assert(/\d/)) }
-    end }
+    ] }
     it { should parse('451a').succeeding.like reference_parser }
     it { should parse('    ').failing.like reference_parser }
   end
 
   context 'with a nested disallow rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { skip(disallow(/\d/)) }
-    end }
+    ] }
     it { should parse('    ').succeeding.like reference_parser }
     it { should parse('451a').failing.like reference_parser }
   end
 
   context 'with a nested EOF rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { skip(eof) }
-    end }
+    ] }
     it { should parse('foo').failing.like reference_parser }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').from(3).succeeding.like reference_parser }
   end
 
   context 'with a nested "E" symbol rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { skip(e) }
-    end }
+    ] }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').succeeding.like reference_parser }
   end
 
   context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       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
+    let(:rules) { [
+      rule(:foo) {
         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 }
+    let(:rules) { [
+      rule(:foo) {
+        skip(match(/\w+/).optional)
+      }
+    ] }
     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 }
+    let(:rules) { [
+      rule(:foo) {
+        skip(match(/\w/).zero_or_more)
+      }
+    ] }
     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 }
+    let(:rules) { [
+      rule(:foo) {
+        skip(match(/\w/).one_or_more)
+      }
+    ] }
     it { should parse('foo ').succeeding.like reference_parser }
     it { should parse('    ').failing.like reference_parser }
   end
 
   context 'with a nested repeat rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        skip(repeat(/\w/, 2, 4))
-      end
-    end }
+    let(:rules) { [
+      rule(:foo) {
+        skip(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 optional bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          skip(repeat(/\w+/, 0, 1))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          skip(match(/\w+/).repeat(0, 1))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').succeeding.like reference_parser }
     end
 
     context 'with zero-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          skip(repeat(/\w/, 0, 4))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          skip(match(/\w/).repeat(0, 4))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('abcde ').succeeding.like reference_parser }
       it { should parse('  ').succeeding.like reference_parser }
     end
 
     context 'with one-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          skip(repeat(/\w/, 1, 4))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          skip(match(/\w/).repeat(1, 4))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('abcde ').succeeding.like reference_parser }
       it { should parse('  ').failing.like reference_parser }
@@ -151,10 +154,10 @@ shared_examples_for 'a compiled parser with a skip' do
   end
 
   context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:digits) { match(/\d+/) }
+    let(:rules) { [
+      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

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

@@ -2,223 +2,226 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 shared_examples_for 'a compiled parser with a token' do
   include CompilerSpecHelper
+  include RuntimeParserSpecHelper
 
   subject { compiled_parser }
 
   let(:reference_parser) { combinator_parser grammar }
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   context 'with a nested match rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       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 apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:digit) { match(/\d/) }
-      rule(:foo) { token :digit }
-    end }
+    let(:rules) { [
+      rule(:digit) { match(/\d/) },
+      rule(:foo) { token(:digit) }
+    ] }
     it { should parse('451 ').twice.succeeding.like reference_parser }
     it { should parse('hi').failing.like reference_parser }
 
     context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:digits) { match(/\d+/) }
+      let(:rules) { [
+        rule(:digits) { match(/\d+/) },
         rule(:num) { token(label(:num, :digits)) }
-      end }
+      ] }
       it { should parse('451a').succeeding.like reference_parser }
       it { should parse('    ').failing.like reference_parser }
     end
   end
 
   context 'with a nested assert rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { token(assert(/\d/)) }
-    end }
+    ] }
     it { should parse('451a').succeeding.like reference_parser }
     it { should parse('    ').failing.like reference_parser }
   end
 
   context 'with a nested disallow rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { token(disallow(/\d/)) }
-    end }
+    ] }
     it { should parse('    ').succeeding.like reference_parser }
     it { should parse('451a').failing.like reference_parser }
   end
 
   context 'with a nested EOF rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { token(eof) }
-    end }
+    ] }
     it { should parse('foo').failing.like reference_parser }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').from(3).succeeding.like reference_parser }
   end
 
   context 'with a nested "E" symbol rule' do
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:foo) { token(e) }
-    end }
+    ] }
     it { should parse('').succeeding.like reference_parser }
     it { should parse('foo').succeeding.like reference_parser }
   end
 
   context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
-      rule(:atom) do
+    let(:rules) { [
+      rule(:atom) {
         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
+      let(:rules) { [
+        rule(:atom) {
           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
+    let(:rules) { [
+      rule(:atom) {
         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
+      let(:rules) { [
+        rule(:foo) {
           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 }
+    let(:rules) { [
+      rule(:foo) {
+        token(match(/\w+/).optional)
+      }
+    ] }
 
     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 }
+      let(:rules) { [
+        rule(:foo) {
+          token(skip(/\w+/).optional)
+        }
+      ] }
       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 }
+    let(:rules) { [
+      rule(:foo) {
+        token(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 rule' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(zero_or_more(skip(/\w/)))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(skip(/\w/).zero_or_more)
+        }
+      ] }
       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 }
+    let(:rules) { [
+      rule(:foo) {
+        token(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 rule' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(one_or_more(skip(/\w/)))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(skip(/\w/).one_or_more)
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').failing.like reference_parser }
     end
   end
 
   context 'with a nested repeat' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        token(repeat(/\w/, 2, 4))
-      end
-    end }
+    let(:rules) { [
+      rule(:foo) {
+        token(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 a non-capturing rule' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(repeat(skip(/\w/), 2, 4))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(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 optional bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(repeat(/\w+/, 0, 1))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(match(/\w+/).repeat(0, 1))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('    ').succeeding.like reference_parser }
     end
 
     context 'with zero-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(repeat(skip(/\w/), 0, nil))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(skip(/\w/).repeat(0, nil))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('  ').succeeding.like reference_parser }
     end
 
     context 'with one-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          token(repeat(skip(/\w/), 1, nil))
-        end
-      end }
+      let(:rules) { [
+        rule(:foo) {
+          token(skip(/\w/).repeat(1, nil))
+        }
+      ] }
       it { should parse('foo ').succeeding.like reference_parser }
       it { should parse('a ').succeeding.like reference_parser }
       it { should parse('  ').failing.like reference_parser }
@@ -226,36 +229,28 @@ shared_examples_for 'a compiled parser with a token' do
   end
 
   context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { token(match(:digits)) }
+    let(:rules) { [
+      rule(:foo) { token(: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)) }
+      let(:rules) { [
+        rule(:foo) { token(: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
+    let(:rules) { [
       rule(:foo) { token(skip(/\w+/)) }
-    end }
+    ] }
     it { should parse('abc123').succeeding.like reference_parser }
     it { should parse('  ').failing.like reference_parser }
   end