rattler 0.4.2 → 0.5.0

data/spec/rattler/grammar/grammar_parser_spec.rb

@@ -150,6 +150,12 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
 
+    context 'given the E symbol' do
+      it 'parses as ESymbol[]' do
+        matching(' E ').as(:expression).should result_in(ESymbol[]).at(2)
+      end
+    end
+
     context 'given an upper-case POSIX class name' do
       it 'parses as a Match of a POSIX character class' do
         for name in posix_names
@@ -167,6 +173,87 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
 
+    context 'given an optional expression' do
+      it 'parses as a Repeat with optional bounds' do
+        matching(' expr? ').as(:expression).
+          should result_in(Repeat[Apply[:expr], 0, 1]).at(6)
+      end
+    end
+
+    context 'given a zero-or-more expression' do
+      it 'parses as a Repeat with zero-or-more bounds' do
+        matching(' expr* ').as(:expression).
+          should result_in(Repeat[Apply[:expr], 0, nil]).at(6)
+      end
+    end
+
+    context 'given a one-or-more expression' do
+      it 'parses as a Repeat with one-or-more bounds' do
+        matching(' expr+ ').as(:expression).
+          should result_in(Repeat[Apply[:expr], 1, nil]).at(6)
+      end
+    end
+
+    context 'given a generalized repeat expression' do
+      context 'with a single count' do
+        it 'parses as a Repeat with the count as both lower and upper bounds' do
+          matching(' expr 2 ').as(:expression).
+            should result_in(Repeat[Apply[:expr], 2, 2]).at(7)
+        end
+      end
+
+      context 'with a range' do
+        it 'parses as a Repeat with lower and upper bounds' do
+          matching(' expr 2..4 ').as(:expression).
+            should result_in(Repeat[Apply[:expr], 2, 4]).at(10)
+        end
+
+        context 'with no upper bound' do
+          it 'parses as a Repeat with no upper bound' do
+            matching(' expr 2.. ').as(:expression).
+              should result_in(Repeat[Apply[:expr], 2, nil]).at(9)
+          end
+        end
+      end
+    end
+
+    context 'given a zero-or-more list expression' do
+      it 'parses as a ListParser with zero-or-more bounds' do
+        matching(' expr *, ";" ').as(:expression).
+          should result_in(ListParser[Apply[:expr], Match[/;/], 0, nil]).at(12)
+      end
+    end
+
+    context 'given a one-or-more list expression' do
+      it 'parses as a ListParser with one-or-more bounds' do
+        matching(' expr +, ";" ').as(:expression).
+          should result_in(ListParser[Apply[:expr], Match[/;/], 1, nil]).at(12)
+      end
+    end
+
+    context 'given a generalized list expression' do
+      context 'with a single count' do
+        it 'parses as a ListParser with the count as both lower and upper bounds' do
+          matching(' expr 2, ";" ').as(:expression).
+            should result_in(ListParser[Apply[:expr], Match[/;/], 2, 2]).at(12)
+        end
+      end
+
+      context 'with a range' do
+        it 'parses as a ListParser with lower and upper bounds' do
+          matching(' expr 2..4, ";" ').as(:expression).
+            should result_in(ListParser[Apply[:expr], Match[/;/], 2, 4]).at(15)
+        end
+
+        context 'with no upper bound' do
+          it 'parses as a Repeat with no upper bound' do
+            matching(' expr 2.., ";" ').as(:expression).
+              should result_in(ListParser[Apply[:expr], Match[/;/], 2, nil]).at(14)
+          end
+        end
+      end
+    end
+
     context 'given a dispatch-action-attributed expression' do
 
       context 'given an action with a class name' do
@@ -216,7 +303,7 @@ describe Rattler::Grammar::GrammarParser do
         end
       end
 
-      context 'given just a literal' do
+      context 'given an action with just a literal' do
         it 'parses as a default node with the literal as the name' do
           matching(' expr <"expression"> ').as(:expression).
             should result_in(DispatchAction[Apply[:expr],
@@ -228,13 +315,71 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
 
-    context 'given direct-action-attributed expression' do
+    context 'given a lone dispatch action' do
+      it 'parses as a DispatchAction on ESymbol[]' do
+        matching(' <Foo> ').as(:expression).
+          should result_in(DispatchAction[ESymbol[],
+            {:target => 'Foo', :method => 'parsed'}]).
+          at(6)
+      end
+    end
+
+    context 'given a direct-action-attributed expression' do
       it 'parses as a DirectAction' do
         matching(' digits {|_| _.to_i} ').as(:expression).
           should result_in(DirectAction[Apply[:digits], '|_| _.to_i']).at(20)
       end
     end
 
+    context 'given a lone direct action' do
+      it 'parses as a DirectAction on ESymbol[]' do
+        matching(' { :foo } ').as(:expression).
+          should result_in(DirectAction[ESymbol[], ':foo']).at(9)
+      end
+    end
+
+    context 'given a side-effect-attributed expression' do
+      it 'parses as a SideEffect' do
+        matching(' digits ~{|_| @i = _.to_i} ').as(:expression).
+          should result_in(SideEffect[Apply[:digits], '|_| @i = _.to_i']).at(26)
+      end
+    end
+
+    context 'given a lone side effect' do
+      it 'parses as a SideEffect on ESymbol[]' do
+        matching(' ~{ @i = :foo } ').as(:expression).
+          should result_in(SideEffect[ESymbol[], '@i = :foo']).at(15)
+      end
+    end
+
+    context 'given a positive semantic-predicate-attributed expression' do
+      it 'parses as a SemanticAssert' do
+        matching(' digits &{|_| _.to_i} ').as(:expression).
+          should result_in(SemanticAssert[Apply[:digits], '|_| _.to_i']).at(21)
+      end
+    end
+
+    context 'given a lone positive semantic predicate' do
+      it 'parses as a SemanticAssert on ESymbol[]' do
+        matching(' &{ @foo } ').as(:expression).
+          should result_in(SemanticAssert[ESymbol[], '@foo']).at(10)
+      end
+    end
+
+    context 'given a negative semantic-predicate-attributed expression' do
+      it 'parses as a SemanticDisallow' do
+        matching(' digits !{|_| _.to_i} ').as(:expression).
+          should result_in(SemanticDisallow[Apply[:digits], '|_| _.to_i']).at(21)
+      end
+    end
+
+    context 'given a lone negative semantic predicate' do
+      it 'parses as a SemanticDisallow on ESymbol[]' do
+        matching(' !{ @foo } ').as(:expression).
+          should result_in(SemanticDisallow[ESymbol[], '@foo']).at(10)
+      end
+    end
+
     context 'given a sequence expression' do
       it 'parses as a Sequence' do
         matching(' name "=" value ').as(:expression).
@@ -253,17 +398,163 @@ describe Rattler::Grammar::GrammarParser do
       end
     end
 
-    it 'parses attributed sequence expressions' do
-      matching(' name "=" value <Assign>').as(:expression).
-        should result_in(DispatchAction[
-                          Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
-                          {:target => 'Assign', :method => 'parsed'}]).
-                at(24)
+    context 'given a dispatch-attributed sequence expression' do
+      it 'parses as a DispatchAction with a nested Sequence' do
+        matching(' name "=" value <Assign>').as(:expression).
+          should result_in(DispatchAction[
+            Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
+            {:target => 'Assign', :method => 'parsed'}
+          ]).at(24)
+      end
+    end
+
+    context 'given a multiple-dispatch-attributed expression' do
+      it 'parses as nested DispatchActions' do
+        matching(' digits <Int> <Foo> ').as(:expression).
+          should result_in(DispatchAction[
+            DispatchAction[Apply[:digits], {:target => 'Int', :method => 'parsed'}],
+            {:target => 'Foo', :method => 'parsed'}
+          ]).at(19)
+      end
+    end
+
+    context 'given consecutive dispatch-attributed expressions' do
+      it 'parses as nested DispatchActions' do
+        matching(' digits <Int> foo <Foo> ').as(:expression).
+          should result_in(DispatchAction[
+            Sequence[
+              DispatchAction[Apply[:digits], {:target => 'Int', :method => 'parsed'}],
+              Apply[:foo]
+            ],
+            {:target => 'Foo', :method => 'parsed'}
+          ]).at(23)
+      end
+    end
+
+    context 'given a direct-attributed sequence expression' do
+      it 'parses as a DirectAction with a nested Sequence' do
+        matching(' name "=" value {|_| _.size }').as(:expression).
+          should result_in(DirectAction[
+            Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
+            '|_| _.size'
+          ]).at(29)
+      end
+    end
+
+    context 'given a multiple-direct-attirbuted expression' do
+      it 'parses as nested DirectActions' do
+        matching(' digits {|_| _.to_i } {|_| _ * 2 } ').as(:expression).
+          should result_in(DirectAction[
+            DirectAction[Apply[:digits], '|_| _.to_i'],
+            '|_| _ * 2'
+          ]).at(34)
+      end
+    end
+
+    context 'given consecutive direct-attributed expressions' do
+      it 'parses as nested DirectActions' do
+        matching(' digits {|_| _.to_i } foo {|_| _ * 2 } ').as(:expression).
+          should result_in(DirectAction[
+            Sequence[
+              DirectAction[Apply[:digits], '|_| _.to_i'],
+              Apply[:foo]
+            ],
+            '|_| _ * 2'
+          ]).at(38)
+      end
+    end
+
+    context 'given a side-effect-attributed sequence expression' do
+      it 'parses as a SideEffect with a nested Sequence' do
+        matching(' name "=" value ~{|_| @n = _.size }').as(:expression).
+          should result_in(SideEffect[
+            Sequence[Apply[:name], Match[%r{=}], Apply[:value]],
+            '|_| @n = _.size'
+          ]).at(35)
+      end
+    end
+
+    context 'given a multiple-effect-attirbuted expression' do
+      it 'parses as nested SideEffects' do
+        matching(' digits ~{|_| @i = _.to_i } ~{|_| @j = _ * 2 } ').as(:expression).
+          should result_in(SideEffect[
+            SideEffect[Apply[:digits], '|_| @i = _.to_i'],
+            '|_| @j = _ * 2'
+          ]).at(46)
+      end
+    end
+
+    context 'given consecutive side-effect-attributed expressions' do
+      it 'parses as nested SideEffects' do
+        matching(' digits ~{|_| @i = _.to_i } foo ~{|_| @j = _ * 2 } ').as(:expression).
+          should result_in(SideEffect[
+            Sequence[
+              SideEffect[Apply[:digits], '|_| @i = _.to_i'],
+              Apply[:foo]
+            ],
+            '|_| @j = _ * 2'
+          ]).at(50)
+      end
+    end
+
+    context 'given a positive predicate-attributed sequence expression' do
+      it 'parses as a SemanticAssert with a nested Sequence' do
+        matching(' digits digits &{|a, b| a.to_i > b.to_i } ').as(:expression).
+          should result_in(SemanticAssert[
+            Sequence[Apply[:digits], Apply[:digits]],
+            '|a, b| a.to_i > b.to_i'
+          ]).at(41)
+      end
     end
 
-    it 'parses ordered choice expressions' do
-      matching(' string / number ').as(:expression).
-        should result_in(Choice[Apply[:string], Apply[:number]]).at(16)
+    context 'given a multiple-predicate-attirbuted expression' do
+      it 'parses as nested SemanticAsserts' do
+        matching(' digits &{|_| _.to_i > 1 } &{|_| _.to_i < 7 } ').as(:expression).
+          should result_in(SemanticAssert[
+            SemanticAssert[Apply[:digits], '|_| _.to_i > 1'],
+            '|_| _.to_i < 7'
+          ]).at(45)
+      end
+    end
+
+    context 'given consecutive predicate-attributed expressions' do
+      it 'parses as nested SemanticAsserts' do
+        matching(' digits &{|_| _.to_i > 1 } foo &{|_| _.empty? } ').as(:expression).
+          should result_in(SemanticAssert[
+            Sequence[
+              SemanticAssert[Apply[:digits], '|_| _.to_i > 1'],
+              Apply[:foo]
+            ],
+            '|_| _.empty?'
+          ]).at(47)
+      end
+    end
+
+    context 'given a negative predicate-attributed sequence expression' do
+      it 'parses as a SemanticAssert with a nested Sequence' do
+        matching(' digits digits !{|a, b| a.to_i > b.to_i } ').as(:expression).
+          should result_in(SemanticDisallow[
+            Sequence[Apply[:digits], Apply[:digits]],
+            '|a, b| a.to_i > b.to_i'
+          ]).at(41)
+      end
+    end
+
+    context 'given an ordered choice expression' do
+      it 'parses as a Choice' do
+        matching(' string / number ').as(:expression).
+          should result_in(Choice[Apply[:string], Apply[:number]]).at(16)
+      end
+    end
+
+    context 'given an ordered choice with sequences' do
+      it 'parses as a Choice of Sequences' do
+        matching(' foo bar / boo far ').as(:expression).
+          should result_in(Choice[
+            Sequence[Apply[:foo], Apply[:bar]],
+            Sequence[Apply[:boo], Apply[:far]]
+          ]).at(18)
+      end
     end
 
     it 'skips normal whitespace' do
@@ -290,18 +581,6 @@ describe Rattler::Grammar::GrammarParser do
   end
 
   describe '#match(:term)' do
-    it 'recognizes optional terms' do
-      matching(' expr? ').as(:term).should result_in(Optional[Apply[:expr]]).at(6)
-    end
-
-    it 'recognizes zero-or-more terms' do
-      matching(' expr* ').as(:term).should result_in(ZeroOrMore[Apply[:expr]]).at(6)
-    end
-
-    it 'recognizes one-or-more terms' do
-      matching(' expr+ ').as(:term).should result_in(OneOrMore[Apply[:expr]]).at(6)
-    end
-
     it 'recognizes assert terms' do
       matching(' &expr ').as(:term).should result_in(Assert[Apply[:expr]]).at(6)
     end

data/spec/rattler/parsers/apply_spec.rb

@@ -29,4 +29,10 @@ describe Apply do
     end
   end
 
+  describe '#with_ws' do
+    it 'returns self' do
+      subject.with_ws(Match[/\s*/]).should == subject
+    end
+  end
+
 end

data/spec/rattler/parsers/assert_spec.rb

@@ -3,28 +3,39 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Assert do
   include CombinatorParserSpecHelper
 
-  subject { Assert[Match[/\w+/]] }
-  
+  subject { Assert[nested] }
+
+  let(:nested) { Match[/\w+/] }
+
   describe '#parse' do
-    
+
     context 'when the parser matches' do
       it 'returns true without advancing' do
         parsing('abc123  ').should result_in(true).at(0)
       end
     end
-    
+
     context 'when the parser fails' do
       it 'fails' do
         parsing('   ').should fail
       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 == Assert[Sequence[Skip[ws], nested]]
+    end
+  end
+
 end

data/spec/rattler/parsers/back_reference_spec.rb

@@ -35,4 +35,13 @@ describe Rattler::Parsers::BackReference do
     end
   end
 
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+
+    it 'returns a parser that skips whitespace before matching' do
+      subject.with_ws(ws).should == Sequence[Skip[ws], subject]
+    end
+  end
+
 end

data/spec/rattler/parsers/choice_spec.rb

@@ -2,29 +2,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Choice do
   include CombinatorParserSpecHelper
-  
+
+  subject { Choice[*nested] }
+
   describe '#parse' do
-    
-    subject { Choice[Match[/[[:alpha:]]+/], Match[/[[:digit:]]+/]] }
-    
+
+    let(:nested) { [Match[/[[:alpha:]]+/], Match[/[[:digit:]]+/]] }
+
     context 'when any of the parsers match' do
       it 'matches the same as the first parser that matches' do
         parsing('abc123').should result_in('abc').at(3)
         parsing('123abc').should result_in('123').at(3)
       end
     end
-    
+
     context 'when none of the parsers match' do
       it 'fails' do
         parsing('==').should fail
       end
     end
-    
+
     context 'with no capturing parsers' do
-      subject do
-        Choice[Skip[Match[/[[:alpha:]]+/]], Skip[Match[/[[:digit:]]+/]]]
+      let :nested do
+        [Skip[Match[/[[:alpha:]]+/]], Skip[Match[/[[:digit:]]+/]]]
       end
-      
+
       context 'when any of the parsers match' do
         it 'returns true' do
           parsing('abc123').should result_in(true).at(3)
@@ -32,29 +34,42 @@ describe Choice do
         end
       end
     end
-    
+
   end
-  
+
   describe '#capturing?' do
-    
+
     context 'with any capturing parsers' do
-      subject do
-        Choice[Skip[Match[/[[:space:]]*/]], Match[/[[:alpha:]]+/]]
-      end
+
+      let(:nested) { [Skip[Match[/[[:space:]]*/]], Match[/[[:alpha:]]+/]] }
+
       it 'is true' do
         subject.should be_capturing
       end
     end
-    
+
     context 'with no capturing parsers' do
-      subject do
-        Choice[Skip[Match[/[[:alpha:]]+/]], Skip[Match[/[[:digit:]]+/]]]
-      end
+
+      let(:nested) { [Skip[Match[/[[:alpha:]]+/]], Skip[Match[/[[:digit:]]+/]]] }
+
       it 'is false' do
         subject.should_not be_capturing
       end
     end
-    
+
+  end
+
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    let(:nested) { [Match[/[[:alpha:]]+/], Match[/[[:digit:]]+/]] }
+
+    it 'applies #with_ws to the nested parsers' do
+      subject.with_ws(ws).should == Choice[
+        Sequence[Skip[ws], nested[0]],
+        Sequence[Skip[ws], nested[1]]
+      ]
+    end
   end
-  
+
 end