rattler 0.3.0 → 0.4.0

data/spec/rattler/parsers/fail_spec.rb

@@ -1,20 +1,22 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Assert do
+include Rattler::Parsers
+
+describe Rattler::Parsers::Fail do
   include CombinatorParserSpecHelper
 
   subject { Fail[:expr, 'malformed expression'] }
-  
+
   describe '#parse' do
     it 'fails' do
       parsing('anything').should fail
     end
   end
-  
+
   describe '#capturing?' do
     it 'is false' do
       subject.should_not be_capturing
     end
   end
-  
+
 end

data/spec/rattler/parsers/label_spec.rb

@@ -2,56 +2,38 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Label do
   include CombinatorParserSpecHelper
-  
+
   subject { Label[:name, [Match[/\w+/]]] }
-  
+
   describe '#parse' do
+
     it 'matches identically to its parser' do
       parsing('abc123  ').should result_in('abc123').at(6)
       parsing('==').should fail
     end
-  end
-  
-  describe '#parse_labeled' do
-    
-    it 'matches the same as #parse' do
-      parsing('abc123  ').labeled.should result_in('abc123').at(6)
-      parsing('==').labeled.should fail
-    end
-    
+
     context 'on success' do
       it 'adds a mapping from its label to its result' do
-        l = {}
-        parsing('foo  ').labeled(l).should result_in('foo')
-        l.should == {:name => 'foo'}
+        parsing('foo  ').should result_in('foo').with_scope(:name => 'foo')
       end
     end
-    
-    context 'on failure' do
-      it 'does not add a label mapping' do
-        l = {}
-        parsing('==').labeled(l).should fail
-        l.should == {}
-      end
-    end
-    
   end
-  
+
   describe '#capturing?' do
-    
+
     context 'with a capturing parser' do
       it 'is true' do
         subject.should be_capturing
       end
     end
-    
+
     context 'with a non-capturing parser' do
       subject { Label[:name, [Skip[Match[/\s+/]]]] }
       it 'is false' do
         subject.should_not be_capturing
       end
     end
-    
+
   end
-  
+
 end

data/spec/rattler/parsers/node_code_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rattler::Parsers::NodeCode do
+
+  subject { described_class.new(target_name, method_name) }
+
+  let(:target_name) { 'Expr' }
+  let(:method_name) { 'parsed' }
+
+  describe '#bind' do
+
+    let(:scope) { {} }
+
+    context 'given empty bind args' do
+      it 'binds "[]"' do
+        subject.bind(scope, []).should == 'Expr.parsed([])'
+      end
+    end
+
+    context 'given a single bind arg' do
+      it 'binds the an array with the arg' do
+        subject.bind(scope, ['a']).should == 'Expr.parsed([a])'
+      end
+    end
+
+    context 'given a multiple bind args' do
+      it 'binds the an array with the arg' do
+        subject.bind(scope, ['a', 'b', 'c']).should == 'Expr.parsed([a, b, c])'
+      end
+    end
+
+    context 'given a string as bind args' do
+      it 'binds the exact string' do
+        subject.bind(scope, 'a').should == 'Expr.parsed(a)'
+      end
+    end
+
+    context 'with scope' do
+
+      let(:scope) { {:word => 'w'} }
+
+      it 'binds the scope as labeled results' do
+        subject.bind(scope, ['a', 'b']).
+          should == 'Expr.parsed([a, b], :labeled => {:word => w})'
+      end
+    end
+  end
+end

data/spec/rattler/parsers/parser_dsl_spec.rb

@@ -264,7 +264,7 @@ describe ParserDSL do
           rule(:word) { match(/\w+/) }
           rule(:number) { match(/\d+/) }
         end.
-        should == Rules[
+        should == RuleSet[
           Rule[:word, Match[/\w+/]],
           Rule[:number, Match[/\d+/]]
         ]

data/spec/rattler/parsers/rule_set_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rattler::Parsers::RuleSet do
+  include CombinatorParserSpecHelper
+
+  subject { RuleSet[rule_a, rule_b] }
+
+  let(:rule_a) { Rule[:a, Match[/a/]] }
+  let(:rule_b) { Rule[:b, Match[/b/]] }
+
+  describe '#rule' do
+    it 'returns rules by name' do
+      subject.rule(:a).should == rule_a
+      subject.rule(:b).should == rule_b
+    end
+  end
+
+  describe '#[]' do
+
+    context 'given a symbol' do
+      it 'returns a rule by name' do
+        subject[:a].should == rule_a
+        subject[:b].should == rule_b
+      end
+    end
+
+    context 'given an array argument' do
+      it 'returns a rule by index' do
+        subject[0].should == rule_a
+        subject[1].should == rule_b
+      end
+    end
+  end
+
+end

data/spec/rattler/parsers/sequence_spec.rb

@@ -2,25 +2,25 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Sequence do
   include CombinatorParserSpecHelper
-  
+
   describe '#parse' do
-    
+
     subject do
       Sequence[Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]]
     end
-    
+
     context 'when all of the parsers match in sequence' do
       it 'matches returning the results in an array' do
         parsing('val=42').should result_in(['val', '=', '42']).at(6)
       end
     end
-    
+
     context 'when one of the parsers fails' do
       it 'fails and backtracks' do
         parsing('val=x').should fail
       end
     end
-    
+
     context 'with non-capturing parsers' do
       subject do
         Sequence[Match[/[[:alpha:]]+/], Skip[Match[/\s+/]], Match[/[[:digit:]]+/]]
@@ -31,7 +31,7 @@ describe Sequence do
         end
       end
     end
-    
+
     context 'with only one capturing parser' do
       subject do
         Sequence[Skip[Match[/\s+/]], Match[/\w+/]]
@@ -42,7 +42,7 @@ describe Sequence do
         end
       end
     end
-    
+
     context 'with no capturing parsers' do
       subject do
         Sequence[Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]]
@@ -53,14 +53,14 @@ describe Sequence do
         end
       end
     end
-    
+
     context 'with an apply parser referencing a non-capturing rule' do
       subject do
         Sequence[Match[/[[:alpha:]]+/], Apply[:ws], Match[/[[:digit:]]+/]]
       end
-      
-      let(:rules) { Rules[Rule[:ws, Skip[Match[/\s+/]]]] }
-      
+
+      let(:rules) { RuleSet[Rule[:ws, Skip[Match[/\s+/]]]] }
+
       context 'when all of the parsers match in sequence' do
         it 'only includes results of its capturing parsers in the result array' do
           parsing('foo 42').should result_in ['foo', '42']
@@ -68,9 +68,9 @@ describe Sequence do
       end
     end
   end
-  
+
   describe '#capturing?' do
-    
+
     context 'with any capturing parsers' do
       subject do
         Sequence[Skip[Match[/\s*/]], Match[/\w+/]]
@@ -79,7 +79,7 @@ describe Sequence do
         subject.should be_capturing
       end
     end
-    
+
     context 'with no capturing parsers' do
       subject do
         Sequence[Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]]
@@ -89,14 +89,5 @@ describe Sequence do
       end
     end
   end
-  
-  describe '#optimized' do
-    context 'with all skips' do
-      it 'returns a skip' do
-        Sequence[Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]].optimized.should ==
-          Skip[Sequence[Match[/\s*/], Match[/#[^\n]+/]]].optimized
-      end
-    end
-  end
-  
+
 end

data/spec/rattler/runtime/extended_packrat_parser_spec.rb

@@ -3,33 +3,38 @@ require File.expand_path(File.dirname(__FILE__) + '/shared_parser_examples')
 
 describe Rattler::Runtime::ExtendedPackratParser do
   include RuntimeParserSpecHelper
-  
-  it_behaves_like 'a packrat parser'
-  
+
+  it_behaves_like 'a generated packrat parser'
+
+  let :parser_class do
+    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+  end
+
   describe '#match' do
 
-    it 'supports directly left-recursive rules' do
-      given_rules do
+    context 'given a directly left-recursive rule' do
+      let(:grammar) { define_grammar do
         rule :a do
           ( match(:a) & match(/\d/) \
           | match(/\d/)             )
         end
-      end.
-      parsing('12345a').as(:a).
-        should result_in([[[['1', '2'], '3'], '4'], '5']).
-        at(5)
+      end }
+
+      it 'parses correctly' do
+        parsing('12345a').should result_in([[[['1', '2'], '3'], '4'], '5']).at(5)
+      end
     end
 
-    it 'supports indirectly left-recursive rules' do
-      given_rules do
+    context 'given indirectly left-recursive rules' do
+      let(:grammar) { define_grammar do
         rule(:a) { match(:b) | match(/\d/) }
         rule(:b) { match(:a) & match(/\d/) }
-      end.
-      parsing('12345a').as(:a).
-        should result_in([[[['1', '2'], '3'], '4'], '5']).
-        at(5)
-    end
+      end }
 
+      it 'parses correctly' do
+        parsing('12345a').should result_in([[[['1', '2'], '3'], '4'], '5']).at(5)
+      end
+    end
   end
-  
+
 end

data/spec/rattler/runtime/packrat_parser_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/shared_parser_examples')
 
 describe Rattler::Runtime::PackratParser do
-  it_behaves_like 'a packrat parser'
+  it_behaves_like 'a generated packrat parser'
 end

data/spec/rattler/runtime/parse_node_spec.rb

@@ -1,11 +1,11 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Rattler::Runtime::ParseNode do
-  
+
+  let(:children) { ['foo', 'bar'] }
+
   describe '#labeled' do
-    
-    let(:children) { ['foo', 'bar'] }
-    
+
     context 'when the node has a :labeled attribute' do
       subject do
         Rattler::Runtime::ParseNode.parsed(children,
@@ -15,8 +15,8 @@ describe Rattler::Runtime::ParseNode do
         subject.labeled.should == subject.attrs[:labeled]
       end
     end
-    
-    context 'when the node as no :labeled attribute' do
+
+    context 'when the node has no :labeled attribute' do
       subject do
         Rattler::Runtime::ParseNode.parsed(children)
       end
@@ -25,54 +25,50 @@ describe Rattler::Runtime::ParseNode do
       end
     end
   end
-  
+
   describe '#[]' do
-    
-    let(:children) { ['foo', 'bar'] }
-    
+
     context 'when the node has a :labeled attribute' do
       subject do
         Rattler::Runtime::ParseNode.parsed(children,
           :labeled => {:left => children.first, :right => children.last })
       end
-      
+
       context 'given one of the labels' do
         it 'returns the child labeled by the symbol' do
           subject[:left].should == children.first
           subject[:right].should == children.last
         end
       end
-      
+
       context 'given a symbol that is not one of the labels' do
         it 'returns nil' do
           subject[:foo].should be_nil
         end
       end
     end
-    
+
     context 'when the node as no :labeled attribute' do
       subject do
         Rattler::Runtime::ParseNode.parsed(children)
       end
-      
+
       it 'returns nil' do
         subject[:foo].should be_nil
       end
     end
   end
-  
+
   describe '#method_missing' do
     subject do
       Rattler::Runtime::ParseNode.parsed(children,
         :labeled => {:left => children.first, :right => children.last })
     end
-    
-    let(:children) { ['foo', 'bar'] }
-    
+
     it 'provides accessor methods for labeled children' do
       subject.left.should == children.first
       subject.right.should == children.last
     end
   end
-  
+
 end

data/spec/rattler/runtime/recursive_descent_parser_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/shared_parser_examples')
 
 describe Rattler::Runtime::RecursiveDescentParser do
-  it_behaves_like 'a recursive descent parser'
+  it_behaves_like 'a generated recursive descent parser'
 end