rattler 0.3.0 → 0.4.0

data/spec/rattler/grammar/grammar_spec.rb

@@ -3,53 +3,56 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 include Rattler::Parsers
 
 describe Rattler::Grammar::Grammar do
-  
-  let(:rules) { Rules[
+
+  let(:rules) { RuleSet[rule_a, rule_b] }
+
+  let :rule_a do
     Rule[:a, Choice[
       Match['a'],
       Apply[:b]
-    ]],
-    Rule[:b, Match['b']]
-  ] }
-  
+    ]]
+  end
+
+  let(:rule_b) { Rule[:b, Match['b']] }
+
   describe '#start_rule' do
     context 'when no start_rule option was specified' do
-      
+
       subject { Rattler::Grammar::Grammar.new(rules) }
-      
-      it 'returns the name of the first rule' do
-        subject.start_rule.should == :a
+
+      it 'returns the first rule' do
+        subject.start_rule.should == rule_a
       end
     end
-    
+
     context 'when an explicit start_rule option was specified' do
-      
+
       subject { Rattler::Grammar::Grammar.new(rules, :start_rule => :b) }
-      
+
       it 'uses the specified start_rule option' do
-        subject.start_rule.should == :b
+        subject.start_rule.should == rule_b
       end
     end
   end
-  
+
   describe '#rules' do
     context 'when no start_rule option was specified' do
-      
+
       subject { Rattler::Grammar::Grammar.new(rules) }
-      
+
       it 'returns rules with the default start_rule' do
         subject.rules.start_rule.should == :a
       end
     end
-    
+
     context 'when an explicit start_rule option was specified' do
-      
+
       subject { Rattler::Grammar::Grammar.new(rules, :start_rule => :b) }
-      
+
       it 'returns rules with the specified start_rule option' do
         subject.rules.start_rule.should == :b
       end
     end
   end
-  
+
 end

data/spec/rattler/parsers/action_code_spec.rb

@@ -2,6 +2,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Rattler::Parsers::ActionCode do
 
+  subject { ActionCode.new(code) }
+
   describe '#param_names' do
     context 'when the code has block parameters' do
 
@@ -53,15 +55,20 @@ describe Rattler::Parsers::ActionCode do
     end
 
     context 'given one argument' do
-      it 'binds "_" to the argument' do
-        subject.blank_binding(['r0']).should == { '_' => 'r0' }
+      it 'binds "_" and "*_" to the argument' do
+        subject.blank_binding(['r0']).should == {
+          /\*_\b/ => 'r0',
+          /\b_\b/ => 'r0'
+        }
       end
     end
 
     context 'given more than one argument' do
-      it 'binds "_" to the array of arguments' do
-        subject.blank_binding(['r0_0', 'r0_1']).
-          should == { '_' => '[r0_0, r0_1]' }
+      it 'binds "*_" to the arguments and "_" to the array of arguments' do
+        subject.blank_binding(['r0_0', 'r0_1']).should == {
+          /\*_\b/ => 'r0_0, r0_1',
+          /\b_\b/ => '[r0_0, r0_1]'
+        }
       end
     end
   end
@@ -73,12 +80,12 @@ describe Rattler::Parsers::ActionCode do
 
       it 'associates the parameter names with arguments' do
         subject.arg_bindings(['r0_0', 'r0_1']).
-          should == {'a' => 'r0_0', 'b' => 'r0_1'}
+          should == {/\ba\b/ => 'r0_0', /\bb\b/ => 'r0_1'}
       end
 
       it 'allows more args than param names' do
         subject.arg_bindings(['r0_0', 'r0_1', 'r0_2']).
-          should == {'a' => 'r0_0', 'b' => 'r0_1'}
+          should == {/\ba\b/ => 'r0_0', /\bb\b/ => 'r0_1'}
       end
     end
 
@@ -93,57 +100,95 @@ describe Rattler::Parsers::ActionCode do
   end
 
   describe '#bind' do
+
+    let(:scope) { {} }
+
     context 'when the code uses block parameters' do
 
-      subject { ActionCode.new('|a, b| a + b') }
+      let(:code) { '|a, b| a + b' }
 
       it 'replaces block parameter names with corresponding arguments' do
-        subject.bind(['r0_0', 'r0_1']).should == 'r0_0 + r0_1'
+        subject.bind(scope, ['r0_0', 'r0_1']).should == 'r0_0 + r0_1'
       end
     end
 
     context 'when the code refers to labels' do
 
-      subject { ActionCode.new('l + r') }
+      let(:scope) { {:l => 'r0_3', :r => 'r0_5'} }
+
+      let(:code) { 'l + r' }
 
       it 'replaces label names with associated arguments' do
-        subject.bind({:l => 'r0_3', :r => 'r0_5'}).should == 'r0_3 + r0_5'
+        subject.bind(scope, []).should == 'r0_3 + r0_5'
       end
     end
 
     context 'when the code uses block parameters and label names' do
 
-      subject { ActionCode.new('|a, b| a * c + b * d') }
+      let(:scope) { {:c => 'r0_3', :d => 'r0_5'} }
+
+      let(:code) { '|a, b| a * c + b * d' }
 
       it 'replaces both block parameter names and label names' do
-        subject.bind(['r0_0', 'r0_1'], {:c => 'r0_3', :d => 'r0_5'}).
+        subject.bind(scope, ['r0_0', 'r0_1']).
           should == 'r0_0 * r0_3 + r0_1 * r0_5'
       end
     end
 
+    context 'when the code uses block parameters that are label names' do
+
+      let(:scope) { {:b => 'r0_3', :c => 'r0_5'} }
+
+      let(:code) { '|a, b| a * c + b' }
+
+      it 'the block parameters shadow the label names' do
+        subject.bind(scope, ['r0_0', 'r0_1']).
+          should == 'r0_0 * r0_5 + r0_1'
+      end
+    end
+
     context 'when the code uses "_"' do
 
-      subject { ActionCode.new('_.to_s') }
+      let(:code) { '_.to_s' }
 
       context 'given one argument' do
         it 'replaces "_" with the argument' do
-          subject.bind(['r0']).should == 'r0.to_s'
+          subject.bind(scope, ['r0']).should == 'r0.to_s'
         end
       end
 
       context 'given multiple arguments' do
         it 'replaces "_" with the array of arguments' do
-          subject.bind(['r0_0', 'r0_1']).should == '[r0_0, r0_1].to_s'
+          subject.bind(scope, ['r0_0', 'r0_1']).
+            should == '[r0_0, r0_1].to_s'
         end
       end
     end
 
     context 'when the code uses "_" as a block parameter' do
 
-      subject { ActionCode.new('|_| _.to_f') }
+      let(:code) { '|_| _.to_f' }
+
+      it 'the block parameter shadows the default "_" binding' do
+        subject.bind(scope, ['r0_0', 'r0_1']).should == 'r0_0.to_f'
+      end
+    end
+
+    context 'when the code uses "*_"' do
+
+      let(:code) { 'do_stuff *_' }
 
-      it 'shadows the default "_" binding' do
-        subject.bind(['r0_0', 'r0_1']).should == 'r0_0.to_f'
+      context 'given one argument' do
+        it 'replaces "*_" with the argument' do
+          subject.bind(scope, ['r0']).should == 'do_stuff r0'
+        end
+      end
+
+      context 'given multiple arguments' do
+        it 'replaces "*_" with the arguments' do
+          subject.bind(scope, ['r0_0', 'r0_1']).
+            should == 'do_stuff r0_0, r0_1'
+        end
       end
     end
   end

data/spec/rattler/parsers/apply_spec.rb

@@ -2,31 +2,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Apply do
   include CombinatorParserSpecHelper
-  
+
   subject { Apply[:word] }
-  
-  let(:rules) { Rules[Rule[:word, Match[/\w+/]]] }
-  
+
+  let(:rules) { RuleSet[Rule[:word, Match[/\w+/]]] }
+
   describe '#parse' do
-    
+
     context 'when the referenced rule matches' do
       it 'succeeds returns the result' do
         parsing('abc123  ').should result_in('abc123').at(6)
       end
     end
-    
+
     context 'when the referenced rule fails' do
       it 'fails' do
         parsing('==').should fail
       end
     end
-    
+
   end
-  
+
   describe '#capturing?' do
     it 'is true' do
       subject.should be_capturing
     end
   end
-  
+
 end

data/spec/rattler/parsers/back_reference_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rattler::Parsers::BackReference do
+  include CombinatorParserSpecHelper
+
+  subject { BackReference[:a] }
+
+  describe '#parse' do
+
+    let(:scope) { {:a => 'foo'} }
+
+    context 'when the referenced parse result is next in the input' do
+      it 'succeeds returning the matched string' do
+        parsing('foobar  ').should result_in('foo').at(3)
+      end
+    end
+
+    context 'when the referenced parse result is not next in the input' do
+      it 'fails' do
+        parsing('abc').should fail
+      end
+    end
+
+  end
+
+  describe '#capturing?' do
+    it 'is true' do
+      subject.should be_capturing
+    end
+  end
+
+  describe '#re_source' do
+    it 'returns the source for a Regexp that will match the referenced result' do
+      subject.re_source(:a => 'r0').should == '#{r0}'
+    end
+  end
+
+end

data/spec/rattler/parsers/combinator_parser_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../runtime/shared_parser_examples')
+
+describe Rattler::Parsers::CombinatorParser do
+  include Rattler::Util::ParserSpecHelper
+  include RuntimeParserSpecHelper
+
+  it_behaves_like 'a recursive descent parser'
+
+  let :parser_class do
+    Rattler::Parsers::CombinatorParser.as_class(grammar.start_rule, grammar.rules)
+  end
+
+end

data/spec/rattler/parsers/direct_action_spec.rb

@@ -95,11 +95,11 @@ describe DirectAction do
 
     context 'with a one-or-more parser' do
 
-      subject { DirectAction[OneOrMore[Match[/\d/]], '|s| s'] }
+      subject { DirectAction[OneOrMore[Match[/\d/]], '|s| s * 2'] }
 
       context 'when the nested parser matches' do
         it 'applies the action to an array containing the matches' do
-          parsing('451a').should result_in(['4', '5', '1']).at(3)
+          parsing('451a').should result_in(%w{4 5 1 4 5 1}).at(3)
         end
       end
 
@@ -131,6 +131,20 @@ describe DirectAction do
       end
     end
 
+    context 'with a labeled parser' do
+      subject do
+        DirectAction[
+          Label[:word, Match[/[[:alpha:]]+/]],
+          "word * 2"
+        ]
+      end
+      context 'when the parser matches' do
+        it 'applies the action binding the label to the result' do
+          parsing('foo ').should result_in('foofoo').at(3)
+        end
+      end
+    end
+
     context 'with a sequence of labeled parsers' do
       subject do
         DirectAction[

data/spec/rattler/parsers/dispatch_action_spec.rb

@@ -2,34 +2,34 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe DispatchAction do
   include CombinatorParserSpecHelper
-  
+
   describe '#parse' do
-    
+
     context 'with a capturing parser' do
       subject do
         DispatchAction[
           Sequence[Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]]
         ]
       end
-      
+
       context 'when the parser matches' do
         it 'applies the action to the result' do
           parsing('val=42').
           should result_in(Rattler::Runtime::ParseNode.parsed(['val','=','42'])).at(6)
         end
       end
-      
+
       context 'when the parser fails' do
         it 'fails' do
           parsing('val=x').should fail
         end
       end
     end
-    
+
     context 'with a token parser' do
-      
+
       subject { DispatchAction[Token[Match[/\w+/]]] }
-      
+
       context 'when the parser matches' do
         it 'applies the action to the matched string' do
           parsing('foo ').
@@ -37,11 +37,11 @@ describe DispatchAction do
         end
       end
     end
-    
+
     context 'with a non-capturing parser' do
-      
+
       subject { DispatchAction[Skip[Match[/\w+/]]] }
-      
+
       context 'when the parser matches' do
         it 'applies the action to an empty array' do
           parsing('abc123 ').
@@ -49,24 +49,7 @@ describe DispatchAction do
         end
       end
     end
-    
-    context 'with a choice of labeled parsers' do
-      subject do
-        DispatchAction[
-          Choice[
-            Label[:word, Match[/[[:alpha:]]+/]],
-            Label[:num, Match[/[[:digit:]]+/]]
-          ]
-        ]
-      end
-      it 'applies the action with a labeled result' do
-        parsing('foo ').should result_in(
-          Rattler::Runtime::ParseNode.parsed(['foo'], :labeled => {:word => 'foo'}))
-        parsing('42 ').should result_in(
-          Rattler::Runtime::ParseNode.parsed(['42'], :labeled => {:num => '42'}))
-      end
-    end
-    
+
     context 'with a sequence of labeled parsers' do
       subject do
         DispatchAction[
@@ -86,16 +69,16 @@ describe DispatchAction do
       end
     end
   end
-  
+
   describe '#capturing?' do
-    
+
     context 'with a capturing parser' do
       subject { DispatchAction[Match[/\w+/]] }
       it 'is true' do
         subject.should be_capturing
       end
     end
-    
+
     context 'with a non-capturing parser' do
       subject { DispatchAction[Skip[Match[/\s*/]]] }
       it 'is false' do
@@ -103,5 +86,5 @@ describe DispatchAction do
       end
     end
   end
-  
+
 end