rattler 0.4.2 → 0.5.0

data/spec/rattler/parsers/direct_action_spec.rb

@@ -3,11 +3,14 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe DirectAction do
   include CombinatorParserSpecHelper
 
+  subject { DirectAction[nested, code] }
+
   describe '#parse' do
 
     context 'with a capturing parser' do
 
-      subject { DirectAction[Match[/[[:digit:]]+/], '|s| s * 2'] }
+      let(:nested) { Match[/[[:digit:]]+/] }
+      let(:code) { '|s| s * 2' }
 
       context 'when the parser matches' do
         it 'applies the action binding the captured results as arguments' do
@@ -23,7 +26,7 @@ describe DirectAction do
 
       context 'using the "_" character' do
 
-        subject { DirectAction[Match[/[[:digit:]]+/], '_ * 2'] }
+        let(:code) { '_ * 2' }
 
         it 'applies the action binding the captured result as "_"' do
           parsing('451a').should result_in('451451').at(3)
@@ -32,13 +35,13 @@ describe DirectAction do
     end
 
     context 'with a sequence parser' do
-      subject do
-        DirectAction[
-          Sequence[Match[/[[:alpha:]]+/], Skip[Match[/\=/]], Match[/[[:digit:]]+/]],
-          '|l, r| "#{r} -> #{l}"'
-        ]
+
+      let :nested do
+        Sequence[Match[/[[:alpha:]]+/], Skip[Match[/\=/]], Match[/[[:digit:]]+/]]
       end
 
+      let(:code) { '|l, r| "#{r} -> #{l}"' }
+
       context 'when the parser matches' do
         it 'applies the action binding the captured results as arguments' do
           parsing('val=42 ').should result_in('42 -> val').at(6)
@@ -46,12 +49,8 @@ describe DirectAction do
       end
 
       context 'using the "_" character' do
-        subject do
-          DirectAction[
-            Sequence[Match[/[[:alpha:]]+/], Skip[Match[/\=/]], Match[/[[:digit:]]+/]],
-            '_.join " <- "'
-          ]
-        end
+
+        let(:code) { '_.join " <- "' }
 
         it 'applies the action binding the captured result array as "_"' do
           parsing('val=42 ').should result_in('val <- 42').at(6)
@@ -61,11 +60,12 @@ describe DirectAction do
 
     context 'with an optional parser' do
 
-      subject { DirectAction[Optional[Match[/\d+/]], '|s| s'] }
+      let(:nested) { Repeat[Match[/\d/], 0, 1] }
+      let(:code) { '|s| s' }
 
       context 'when the nested parser matches' do
         it 'applies the action to an array containing the match' do
-          parsing('451a').should result_in(['451']).at(3)
+          parsing('451a').should result_in(['4']).at(1)
         end
       end
 
@@ -78,11 +78,12 @@ describe DirectAction do
 
     context 'with a zero-or-more parser' do
 
-      subject { DirectAction[ZeroOrMore[Match[/\d/]], '|s| s'] }
+      let(:nested) { Repeat[Match[/\d/], 0, nil] }
+      let(:code) { '|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
 
@@ -95,7 +96,8 @@ describe DirectAction do
 
     context 'with a one-or-more parser' do
 
-      subject { DirectAction[OneOrMore[Match[/\d/]], '|s| s * 2'] }
+      let(:nested) { Repeat[Match[/\d/], 1, nil] }
+      let(:code) { '|s| s * 2' }
 
       context 'when the nested parser matches' do
         it 'applies the action to an array containing the matches' do
@@ -110,8 +112,28 @@ describe DirectAction do
       end
     end
 
+    context 'with a list parser' do
+
+      let(:nested) { ListParser[Match[/[[:digit:]]+/], Match[/,/], 2, 4] }
+      let(:code) { '_.map {|s| s.to_i }' }
+
+      context 'when the nested parser matches' do
+        it 'applies the action to an array containing the matches' do
+          parsing('1,2,42').should result_in([1, 2, 42]).at(6)
+        end
+      end
+
+      context 'when the nested parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
+        end
+      end
+    end
+
     context 'with a token parser' do
-      subject { DirectAction[Token[Match[/[[:digit:]]+/]], '|s| s.to_i'] }
+
+      let(:nested) { Token[Match[/[[:digit:]]+/]] }
+      let(:code) { '|s| s.to_i' }
 
       context 'when the parser matches' do
         it 'applies the action to the matched string' do
@@ -122,7 +144,8 @@ describe DirectAction do
 
     context 'with a non-capturing parser' do
 
-      subject { DirectAction[Skip[Match[/\w+/]], '42'] }
+      let(:nested) { Skip[Match[/\w+/]] }
+      let(:code) { '42' }
 
       context 'when the parser matches' do
         it 'applies the action with no arguments' do
@@ -132,12 +155,10 @@ describe DirectAction do
     end
 
     context 'with a labeled parser' do
-      subject do
-        DirectAction[
-          Label[:word, Match[/[[:alpha:]]+/]],
-          "word * 2"
-        ]
-      end
+
+      let(:nested) { Label[:word, Match[/[[:alpha:]]+/]] }
+      let(:code) { 'word * 2' }
+
       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)
@@ -146,16 +167,17 @@ describe DirectAction do
     end
 
     context 'with a sequence of labeled parsers' do
-      subject do
-        DirectAction[
-          Sequence[
-            Label[:left, Match[/[[:alpha:]]+/]],
-            Match[/\=/],
-            Label[:right, Match[/[[:digit:]]+/]]
-          ],
-          '"#{right} -> #{left}"'
+
+      let :nested do
+        Sequence[
+          Label[:left, Match[/[[:alpha:]]+/]],
+          Match[/\=/],
+          Label[:right, Match[/[[:digit:]]+/]]
         ]
       end
+
+      let(:code) { '"#{right} -> #{left}"' }
+
       context 'when the parser matches' do
         it 'applies the action binding the labels to the results' do
           parsing('val=42 ').should result_in('42 -> val').at(6)
@@ -166,19 +188,37 @@ describe DirectAction do
 
   describe '#capturing?' do
 
+    let(:code) { '' }
+
     context 'with a capturing parser' do
-      subject { DirectAction[Match[/\w+/], ''] }
+
+      let(:nested) { Match[/\w+/] }
+
       it 'is true' do
         subject.should be_capturing
       end
     end
 
     context 'with a non-capturing parser' do
-      subject { DirectAction[Skip[Match[/\s*/]], ''] }
+
+      let(:nested) { Skip[Match[/\s*/]] }
+
       it 'is false' do
         subject.should_not be_capturing
       end
     end
   end
 
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    let(:nested) { Match[/\w+/] }
+    let(:code) { '' }
+
+    it 'applies #with_ws to the nested parser' do
+      subject.with_ws(ws).
+        should == DirectAction[Sequence[Skip[ws], nested], code]
+    end
+  end
+
 end

data/spec/rattler/parsers/disallow_spec.rb

@@ -3,28 +3,39 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Disallow do
   include CombinatorParserSpecHelper
 
-  subject { Disallow[Match[/\w+/]] }
-  
+  subject { Disallow[nested] }
+
+  let(:nested) { Match[/\w+/] }
+
   describe '#parse' do
-    
+
     context 'when the parser matches' do
       it 'fails' do
         parsing('abc123').should fail
       end
     end
-    
+
     context 'when the parser fails' do
       it 'returns true without advancing' do
         parsing('   ').should result_in(true).at(0)
       end
     end
-    
+
   end
-  
+
   describe '#capturing?' do
     it 'is false' do
       subject.should_not be_capturing
     end
   end
-  
+
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+
+    it 'applies #with_ws to the nested parser' do
+      subject.with_ws(ws).should == Disallow[Sequence[Skip[ws], nested]]
+    end
+  end
+
 end

data/spec/rattler/parsers/dispatch_action_spec.rb

@@ -3,13 +3,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe DispatchAction do
   include CombinatorParserSpecHelper
 
-  subject { DispatchAction[nested_parser] }
+  subject { DispatchAction[nested] }
 
   describe '#parse' do
 
     context 'with a capturing parser' do
 
-      let (:nested_parser) { Sequence[
+      let(:nested) { Match[/[[:digit:]]+/] }
+
+      context 'when the parser matches' do
+        it 'applies the action to the result' do
+          parsing('451a').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['451'])).at(3)
+        end
+      end
+
+      context 'when the parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
+        end
+      end
+    end
+
+    context 'with a sequence parser' do
+
+      let(:nested) { Sequence[
         Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]
       ] }
 
@@ -27,21 +45,83 @@ describe DispatchAction do
       end
     end
 
-    context 'with a non-capturing parser' do
+    context 'with an optional parser' do
 
-      let (:nested_parser) { Skip[Match[/,/]] }
+      let(:nested) { Repeat[Match[/\d/], 0, 1] }
 
-      context 'when the parser matches' do
+      context 'when the nested parser matches' do
+        it 'applies the action to an array containing the match' do
+          parsing('451a').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['4'])).at(1)
+        end
+      end
+
+      context 'when the nested parser fails' do
         it 'applies the action to an empty array' do
-          parsing(', ').
-          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(1)
+          parsing('foo').
+          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(0)
+        end
+      end
+    end
+
+    context 'with a zero-or-more parser' do
+
+      let(:nested) { Repeat[Match[/\d/], 0, nil] }
+
+      context 'when the nested parser matches' do
+        it 'applies the action to an array containing the matches' do
+          parsing('451a').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['4', '5', '1'])).at(3)
+        end
+      end
+
+      context 'when the nested parser fails' do
+        it 'applies the action to an empty array' do
+          parsing('foo').
+          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(0)
+        end
+      end
+    end
+
+    context 'with a one-or-more parser' do
+
+      let(:nested) { Repeat[Match[/\d/], 1, nil] }
+
+      context 'when the nested parser matches' do
+        it 'applies the action to an array containing the matches' do
+          parsing('451a').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['4', '5', '1'])).at(3)
+        end
+      end
+
+      context 'when the nested parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
+        end
+      end
+    end
+
+    context 'with a list parser' do
+
+      let(:nested) { ListParser[Match[/[[:digit:]]+/], Match[/,/], 2, 4] }
+
+      context 'when the nested parser matches' do
+        it 'applies the action to an array containing the matches' do
+          parsing('1,2,42').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['1', '2', '42'])).at(6)
+        end
+      end
+
+      context 'when the nested parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
         end
       end
     end
 
     context 'with a token parser' do
 
-      subject { DispatchAction[Token[Match[/\w+/]]] }
+      let(:nested) { Token[Match[/\w+/]] }
 
       context 'when the parser matches' do
         it 'applies the action to the matched string' do
@@ -53,26 +133,37 @@ describe DispatchAction do
 
     context 'with a non-capturing parser' do
 
-      subject { DispatchAction[Skip[Match[/\w+/]]] }
+      let(:nested) { Skip[Match[/,/]] }
 
       context 'when the parser matches' do
         it 'applies the action to an empty array' do
-          parsing('abc123 ').
-          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(6)
+          parsing(', ').
+          should result_in(Rattler::Runtime::ParseNode.parsed([])).at(1)
         end
       end
     end
 
-    context 'with a sequence of labeled parsers' do
-      subject do
-        DispatchAction[
-          Sequence[
-            Label[:name, Match[/[[:alpha:]]+/]],
-            Match[/\=/],
-            Label[:value, Match[/[[:digit:]]+/]]
-          ]
-        ]
+    context 'with a labeled parser' do
+
+      let(:nested) { Label[:word, Match[/[[:alpha:]]+/]] }
+
+      context 'when the parser matches' do
+        it 'applies the action binding the label to the result' do
+          parsing('foo ').
+          should result_in(Rattler::Runtime::ParseNode.parsed(['foo'],
+                                                  :labeled => {:word => 'foo'}))
+        end
       end
+    end
+
+    context 'with a sequence of labeled parsers' do
+
+      let(:nested) { Sequence[
+        Label[:name, Match[/[[:alpha:]]+/]],
+        Match[/\=/],
+        Label[:value, Match[/[[:digit:]]+/]]
+      ] }
+
       context 'when the parser matches' do
         it 'applies the action binding the labels to the results' do
           parsing('val=42 ').
@@ -86,18 +177,33 @@ describe DispatchAction do
   describe '#capturing?' do
 
     context 'with a capturing parser' do
-      subject { DispatchAction[Match[/\w+/]] }
+
+      let(:nested) { Match[/\w+/] }
+
       it 'is true' do
         subject.should be_capturing
       end
     end
 
     context 'with a non-capturing parser' do
-      subject { DispatchAction[Skip[Match[/\s*/]]] }
+
+      let(:nested) { Skip[Match[/\s*/]] }
+
       it 'is false' do
         subject.should_not be_capturing
       end
     end
   end
 
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    let(:nested) { Match[/\w+/] }
+
+    it 'applies #with_ws to the nested parser' do
+      subject.with_ws(ws).
+        should == DispatchAction[Sequence[Skip[ws], nested]]
+    end
+  end
+
 end