rattler 0.2.2 → 0.3.0

data/spec/rattler/grammar/grammar_parser_spec.rb

@@ -4,20 +4,20 @@ include Rattler::Parsers
 
 describe Rattler::Grammar::GrammarParser do
   include Rattler::Util::ParserSpecHelper
-  
+
   let :posix_names do
     %w{alnum alpha blank cntrl digit graph lower print punct space upper xdigit word}
   end
-  
+
   it 'skips normal whitespace' do
     parsing("  \n\t foo").as(:identifier).should result_in('foo').at(8)
   end
-  
+
   it 'skips comments' do
     parsing("\n# a comment\n\t foo").as(:identifier).
     should result_in('foo').at(18)
   end
-  
+
   describe '#match(:identifier)' do
     it 'recognizes identifiers' do
       parsing(' fooBar ').as(:identifier).should result_in('fooBar').at(7)
@@ -25,30 +25,30 @@ describe Rattler::Grammar::GrammarParser do
       parsing(' EO ').as(:identifier).should result_in('EO').at(3)
       parsing(' EOFA ').as(:identifier).should result_in('EOFA').at(5)
     end
-    
+
     it 'does not recognize EOF as identifier' do
       parsing('EOF').as(:identifier).should fail
     end
   end
-  
+
   describe '#match(:eol)' do
     it 'recognizes end-of-line before end-of-file' do
       parsing("foo\nbar").from(3).as(:eol).should result_in(true).at(4)
       parsing("foobar").from(3).as(:eol).should fail
     end
-    
+
     it 'recognizes end-of-file as end-of-line' do
       parsing("foo\nbar").from(7).as(:eol).should result_in(true).at(7)
     end
   end
-  
+
   describe '#match(:var_name)' do
     it 'recognizes variable names' do
       parsing(' fooBar ').as(:var_name).should result_in('fooBar').at(7)
       parsing(' FooBar ').as(:var_name).should fail
     end
   end
-  
+
   describe '#match(:const_name)' do
     it 'recognizes constant names' do
       parsing(' FooBar ').as(:const_name).should result_in('FooBar').at(7)
@@ -56,14 +56,14 @@ describe Rattler::Grammar::GrammarParser do
       parsing(' fooBar ').as(:const_name).should fail
     end
   end
-  
+
   describe '#match(:constant)' do
     it 'recognizes constants' do
       parsing(' Foo::Bar ').as(:constant).should result_in('Foo::Bar').at(9)
       parsing(' FooBar ').as(:constant).should result_in('FooBar').at(7)
     end
   end
-  
+
   describe '#match(:literal)' do
     it 'recognizes string literals' do
       parsing(%{ "a string" }).as(:literal).should result_in(%{"a string"}).at(11)
@@ -72,38 +72,38 @@ describe Rattler::Grammar::GrammarParser do
         should result_in(%q{"a \"string\""}).at(15)
     end
   end
-  
+
   describe '#match(:word_literal)' do
     it 'recognizes word literals' do
       parsing(' `then` ').as(:word_literal).should result_in("`then`").at(7)
     end
   end
-  
+
   describe '#match(:class_char)' do
     it 'recognizes normal characters as class characters' do
       parsing('ab').as(:class_char).should result_in('a').at(1)
     end
-    
+
     it 'recognizes octal codes as class characters' do
       parsing('\\247').as(:class_char).should result_in('\\247').at(4)
       parsing('\\2474').as(:class_char).should result_in('\\247').at(4)
     end
-    
+
     it 'recognizes hex codes as class characters' do
       parsing('\\x7e').as(:class_char).should result_in('\\x7e').at(4)
       parsing('\\x7ee').as(:class_char).should result_in('\\x7e').at(4)
     end
-    
+
     it 'recognizes the "any" character as a class character' do
       parsing('.').as(:class_char).should result_in('.').at(1)
     end
-    
+
     it 'recognizes escaped characters as class characters' do
       parsing('\\]').as(:class_char).should result_in('\\]').at(2)
       parsing('\\\\').as(:class_char).should result_in('\\\\').at(2)
     end
   end
-  
+
   describe '#match(:posix_name)' do
     it 'recognizes posix names' do
       for name in posix_names
@@ -114,7 +114,7 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
   end
-  
+
   describe '#match(:range)' do
     it 'recognizes posix character classes as class ranges' do
       for name in posix_names
@@ -123,38 +123,38 @@ describe Rattler::Grammar::GrammarParser do
       end
       parsing('[:foo:]').as(:range).should result_in('[').at(1)
     end
-    
+
     it 'recognizes normal character ranges as class ranges' do
       parsing('A-Z ').as(:range).should result_in('A-Z').at(3)
     end
-    
+
     it 'recognizes class characters as class ranges' do
       parsing('ab').as(:range).should result_in('a').at(1)
     end
   end
-  
+
   describe '#match(:class)' do
     it 'recognizes character classes' do
       parsing(' [A-Za-z_] ').as(:class).should result_in('[A-Za-z_]').at(10)
     end
   end
-  
+
   describe '#match(:regexp)' do
     it 'recognizes regexps' do
       parsing(' /\\d+(?:\\.\\d+)?/ ').as(:regexp).
         should result_in('/\\d+(?:\\.\\d+)?/').at(16)
     end
   end
-  
+
   describe '#match(:atom)' do
     it 'recognizes EOF as an eof atom' do
       parsing(' EOF ').as(:atom).should result_in(Eof[]).at(4)
     end
-    
+
     it 'recognizes "." as a regexp atom' do
       parsing(' . ').as(:atom).should result_in(Match[/./]).at(2)
     end
-    
+
     it 'recognizes uppercase posix character class names as regexp atoms' do
       for name in posix_names.map {|_| _.upcase } - ['WORD']
         parsing(" #{name} ").as(:atom).
@@ -162,76 +162,89 @@ describe Rattler::Grammar::GrammarParser do
         at(name.length + 1)
       end
     end
-    
+
     it 'recognizes WORD as syntactic sugar for [[:alnum:]_]' do
       parsing(' WORD ').as(:atom).should result_in(Match[/[[:alnum:]_]/]).at(5)
     end
-    
+
     it 'recognizes identifiers as apply atoms' do
       parsing(' expr ').as(:atom).should result_in(Apply[:expr]).at(5)
     end
-    
+
     it 'recognizes string literals as match atoms' do
       parsing(%{ "a string" }).as(:atom).should result_in(Match[/a\ string/]).at(11)
     end
-    
+
     it 'recognizes word literals as word atoms' do
       parsing(' `then` ').as(:atom).
       should result_in(Token[Sequence[Match[/then/], Disallow[Match[/[[:alnum:]_]/]]]]).at(7)
     end
-    
+
     it 'recognizes character classes as match atoms' do
       parsing(' [A-Za-z_] ').as(:atom).should result_in(Match[/[A-Za-z_]/]).at(10)
     end
   end
-  
+
+  describe '#match(:attributed)' do
+    it 'recognizes dispatch-action-attributed expressions' do
+      parsing(' expr <Expr> ').as(:attributed).
+        should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
+        at(12)
+    end
+
+    it 'recognizes direct-action-attributed expressions' do
+      parsing(' digits {|_| _.to_i} ').as(:attributed).
+        should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
+    end
+  end
+
   describe '#match(:term)' do
     it 'recognizes optional terms' do
       parsing(' expr? ').as(:term).should result_in(Optional[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes zero-or-more terms' do
       parsing(' expr* ').as(:term).should result_in(ZeroOrMore[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes one-or-more terms' do
       parsing(' expr+ ').as(:term).should result_in(OneOrMore[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes assert terms' do
       parsing(' &expr ').as(:term).should result_in(Assert[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes disallow terms' do
       parsing(' !expr ').as(:term).should result_in(Disallow[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes skip terms' do
       parsing(' ~expr ').as(:term).should result_in(Skip[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes token terms' do
       parsing(' @expr ').as(:term).should result_in(Token[Apply[:expr]]).at(6)
     end
-    
+
     it 'recognizes labeled terms' do
       parsing(' val:expr ').as(:term).should result_in(Label[:val, Apply[:expr]]).at(9)
     end
-    
+
     it 'recognizes fail expressions' do
       parsing(' fail("bad!") ').as(:term).
         should result_in(Fail[:expr, 'bad!']).at(13)
       parsing(' fail "bad!" ').as(:term).
         should result_in(Fail[:expr, 'bad!']).at(12)
     end
-    
+
     it 'recognizes fail_rule expressions' do
       parsing(' fail_rule("bad!") ').as(:term).
         should result_in(Fail[:rule, 'bad!']).at(18)
       parsing(' fail_rule "bad!" ').as(:term).
         should result_in(Fail[:rule, 'bad!']).at(17)
     end
-    
+
     it 'recognizes fail_parse expressions' do
       parsing(' fail_parse("bad!") ').as(:term).
         should result_in(Fail[:parse, 'bad!']).at(19)
@@ -239,60 +252,36 @@ describe Rattler::Grammar::GrammarParser do
         should result_in(Fail[:parse, 'bad!']).at(18)
     end
   end
-  
-  describe '#match(:attribute)' do
-    it 'recognizes dispatch-action attributes with variables as targets' do
-      parsing(' <expr> ').as(:attribute).should result_in(['expr']).at(7)
-    end
-    
-    it 'recognizes dispatch-action attributes with constants as targets' do
-      parsing(' <Foo::Bar> ').as(:attribute).should result_in(['Foo::Bar']).at(11)
-    end
-    
-    it 'recognizes dispatch-action attributes with empty targets' do
-      parsing(' <> ').as(:attribute).should result_in([]).at(3)
-    end
-  end
-  
-  describe '#match(:action)' do
-    it 'recognizes symantic actions' do
-      parsing(' {|_| _.to_f } ').as(:action).should result_in('|_| _.to_f ').at(14)
-    end
-    
-    it 'recognizes shorcut symantic attributes' do
-		  parsing(' <.expr> ').as(:action).should result_in('|_| _.expr').at(8)
-    end
-  end
-  
+
   describe '#match(:expression)' do
-    it 'recognizes dispatch-action-attributed term expressions' do
+    it 'recognizes dispatch-action-attributed expressions' do
       parsing(' expr <Expr> ').as(:expression).
         should result_in(DispatchAction[Apply[:expr], {:target => 'Expr', :method => 'parsed'}]).
         at(12)
     end
-    
-    it 'recognizes direct-action-attributed term expressions' do
+
+    it 'recognizes direct-action-attributed expressions' do
       parsing(' digits {|_| _.to_i} ').as(:expression).
         should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
     end
-    
+
     it 'recognizes sequence expressions' do
       parsing(' name "=" value ').as(:expression).
-        should result_in(Sequence[Apply[:name], Match[/=/], Apply[:value]]).at(15)
+        should result_in(Sequence[Apply[:name], Match[%r{=}], Apply[:value]]).at(15)
     end
-    
+
     it 'recognizes attributed sequence expressions' do
       parsing(' name "=" value <Assign>').as(:expression).
         should result_in(DispatchAction[
-                          Sequence[Apply[:name], Match[/=/], Apply[:value]],
+                          Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
                           {:target => 'Assign', :method => 'parsed'}]).
                 at(24)
     end
-    
+
     it 'recognizes choice expressions' do
       parsing(' string | number ').as(:expression).
         should result_in(Choice[Apply[:string], Apply[:number]]).at(16)
     end
   end
-  
+
 end

data/spec/rattler/parsers/action_code_spec.rb

@@ -1,101 +1,151 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Rattler::Parsers::ActionCode do
-  
+
   describe '#param_names' do
     context 'when the code has block parameters' do
-      
+
       subject { ActionCode.new('|a, b| a + b') }
-      
+
       it 'returns an array of the parameter names' do
         subject.param_names.should == ['a', 'b']
       end
     end
-    
+
     context 'when the code has no block paratmers' do
-      
+
       subject { ActionCode.new('l + r') }
-      
+
       it 'returns an empty array' do
         subject.param_names.should == []
       end
     end
   end
-  
+
   describe '#body' do
     context 'when the code has block parameters' do
-      
+
       subject { ActionCode.new('|a, b| a + b') }
-      
+
       it 'returns the code after the block parameters' do
         subject.body.should == 'a + b'
       end
     end
-    
+
     context 'when the code has no block paratmers' do
-      
+
       subject { ActionCode.new('l + r') }
-      
+
       it 'returns the code' do
         subject.body.should == 'l + r'
       end
     end
   end
-  
+
+  describe '#blank_binding' do
+
+    subject { ActionCode.new('') }
+
+    context 'given no arguments' do
+      it 'returns an empty hash' do
+        subject.blank_binding([]).should == {}
+      end
+    end
+
+    context 'given one argument' do
+      it 'binds "_" to the argument' do
+        subject.blank_binding(['r0']).should == { '_' => '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]' }
+      end
+    end
+  end
+
   describe '#arg_bindings' do
     context 'when the code has block parameters' do
-      
+
       subject { ActionCode.new('|a, b| a + b') }
-      
+
       it 'associates the parameter names with arguments' do
         subject.arg_bindings(['r0_0', 'r0_1']).
           should == {'a' => 'r0_0', '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'}
       end
     end
-    
+
     context 'when the code has no block paratmers' do
-      
+
       subject { ActionCode.new('l + r') }
-      
+
       it 'returns an empty hash' do
         subject.arg_bindings(['r0_0', 'r0_1']).should == {}
       end
     end
   end
-  
+
   describe '#bind' do
-    context 'given an array' do
-      
+    context 'when the code uses block parameters' do
+
       subject { ActionCode.new('|a, b| a + b') }
-      
-      it 'replaces block parameter names with names from the array' do
+
+      it 'replaces block parameter names with corresponding arguments' do
         subject.bind(['r0_0', 'r0_1']).should == 'r0_0 + r0_1'
       end
     end
-    
-    context 'given a hash' do
-      
+
+    context 'when the code refers to labels' do
+
       subject { ActionCode.new('l + r') }
-      
-      it 'replaces label names with associated names from the hash' do
+
+      it 'replaces label names with associated arguments' do
         subject.bind({:l => 'r0_3', :r => 'r0_5'}).should == 'r0_3 + r0_5'
       end
     end
-    
-    context 'given an array and a hash' do
-      
+
+    context 'when the code uses block parameters and label names' do
+
       subject { ActionCode.new('|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'}).
           should == 'r0_0 * r0_3 + r0_1 * r0_5'
       end
     end
+
+    context 'when the code uses "_"' do
+
+      subject { ActionCode.new('_.to_s') }
+
+      context 'given one argument' do
+        it 'replaces "_" with the argument' do
+          subject.bind(['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'
+        end
+      end
+    end
+
+    context 'when the code uses "_" as a block parameter' do
+
+      subject { ActionCode.new('|_| _.to_f') }
+
+      it 'shadows the default "_" binding' do
+        subject.bind(['r0_0', 'r0_1']).should == 'r0_0.to_f'
+      end
+    end
   end
-  
+
 end