rattler 0.4.2 → 0.5.0

data/spec/rattler/parsers/e_symbol_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ESymbol do
+  include CombinatorParserSpecHelper
+
+  subject { ESymbol[] }
+
+  describe '#parse' do
+    it 'returns true without advancing' do
+      parsing('anything').at(4).should result_in(true).at(4)
+      parsing('        ').at(7).should result_in(true).at(7)
+    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 '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/eof_spec.rb

@@ -4,27 +4,36 @@ describe Eof do
   include CombinatorParserSpecHelper
 
   subject { Eof[] }
-  
+
   describe '#parse' do
-    
+
     context 'at the end of the source' do
       it 'returns true' do
         parsing('abc123').at(6).should result_in(true).at(6)
       end
     end
-    
+
     context 'before the end of the source' do
       it 'fails' do
         parsing('abc123').at(5).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 '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/label_spec.rb

@@ -3,7 +3,9 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Label do
   include CombinatorParserSpecHelper
 
-  subject { Label[:name, [Match[/\w+/]]] }
+  subject { Label[:name, nested] }
+
+  let(:nested) { Match[/\w+/] }
 
   describe '#parse' do
 
@@ -28,7 +30,9 @@ describe Label do
     end
 
     context 'with a non-capturing parser' do
-      subject { Label[:name, [Skip[Match[/\s+/]]]] }
+
+      let(:nested) { Skip[Match[/\s+/]] }
+
       it 'is false' do
         subject.should_not be_capturing
       end
@@ -36,4 +40,13 @@ describe Label do
 
   end
 
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+
+    it 'applies #with_ws to the nested parser' do
+      subject.with_ws(ws).should == Label[:name, Sequence[Skip[ws], nested]]
+    end
+  end
+
 end

data/spec/rattler/parsers/list_parser_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ListParser do
+  include CombinatorParserSpecHelper
+
+  subject { ListParser[term_parser, sep_parser, *bounds] }
+
+  let(:sep_parser) { Match[/[,;]/] }
+
+  describe '#parse' do
+
+    context 'with a capturing term parser' do
+
+      let(:term_parser) { Match[/\w+/] }
+
+      context 'with no upper bound' do
+
+        let(:bounds) { [2, nil] }
+
+        context 'when the parser matches enough terms' do
+          it 'returns an array with the results of matching the terms' do
+            parsing('foo,bar;baz ').should result_in(['foo', 'bar', 'baz']).at(11)
+          end
+        end
+
+        context 'when the parser matches too few terms' do
+          it 'fails' do
+            parsing('foo ').should fail
+          end
+        end
+
+        context 'with a separator not followed by a term' do
+          it 'matches without consuming the extra separator' do
+            parsing('foo,bar,').should result_in(['foo', 'bar']).at(7)
+          end
+        end
+      end
+
+      context 'with an upper bound' do
+
+        let(:bounds) { [2, 4] }
+
+        context 'when the parser would match too many terms' do
+          it 'stops matching at the upper bound' do
+            parsing('a,b,c,d,e').should result_in(['a', 'b', 'c', 'd']).at(7)
+          end
+        end
+      end
+
+      context 'with zero-or-more bounds' do
+
+        let(:bounds) { [0, nil] }
+
+        context 'when no terms match' do
+          it 'returns an empty array without advancing' do
+            parsing('   ').should result_in([]).at(0)
+          end
+        end
+
+        context 'when a single term matches' do
+          it 'returns an array with the result of matching the term' do
+            parsing('foo').should result_in(['foo']).at(3)
+          end
+        end
+      end
+
+      context 'with one-or-more bounds' do
+
+        let(:bounds) { [1, nil] }
+
+        context 'when no terms match' do
+          it 'fails' do
+            parsing('   ').should fail
+          end
+        end
+
+        context 'when a single term matches' do
+          it 'returns an array with the result of matching the term' do
+            parsing('foo').should result_in(['foo']).at(3)
+          end
+        end
+      end
+    end
+
+    context 'with a non-capturing term parser' do
+
+      let(:term_parser) { Skip[Match[/\w+/]] }
+      let(:bounds) { [2, nil] }
+
+      context 'when the parser matches enough terms' do
+        it 'returns true consuming the terms' do
+          parsing('foo,bar;baz ').should result_in(true).at(11)
+        end
+      end
+
+      context 'when the parser matches too few terms' do
+        it 'fails' do
+          parsing('foo ').should fail
+        end
+      end
+
+      context 'with zero-or-more bounds' do
+
+        let(:bounds) { [0, nil] }
+
+        context 'when no terms match' do
+          it 'returns true without advancing' do
+            parsing('   ').should result_in(true).at(0)
+          end
+        end
+
+        context 'when a single term matches' do
+          it 'returns true consuming the term' do
+            parsing('foo  ').should result_in(true).at(3)
+          end
+        end
+
+        context 'when multiple terms match' do
+          it 'returns true consuming the list' do
+            parsing('foo,bar;baz  ').should result_in(true).at(11)
+          end
+        end
+      end
+
+      context 'with one-or-more bounds' do
+
+        let(:bounds) { [1, nil] }
+
+        context 'when no terms match' do
+          it 'fails' do
+            parsing('   ').should fail
+          end
+        end
+
+        context 'when a single term matches' do
+          it 'returns true consuming the term' do
+            parsing('foo  ').should result_in(true).at(3)
+          end
+        end
+
+        context 'when multiple terms match' do
+          it 'returns true consuming the list' do
+            parsing('foo,bar;baz  ').should result_in(true).at(11)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#capturing?' do
+
+    let(:bounds) { [2, 4] }
+
+    context 'with a capturing term parser' do
+
+      let(:term_parser) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+
+    context 'with a non-capturing term parser' do
+
+      let(:term_parser) { Skip[Match[/\w+/]] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+  end
+
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    let(:term_parser) { Match[/\w+/] }
+    let(:bounds) { [2, 4] }
+
+    it 'applies #with_ws to the term and separator parsers' do
+      subject.with_ws(ws).should == ListParser[
+        Sequence[Skip[ws], term_parser],
+        Sequence[Skip[ws], sep_parser],
+        *bounds]
+    end
+  end
+
+end

data/spec/rattler/parsers/match_spec.rb

@@ -2,30 +2,39 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Rattler::Parsers::Match do
   include CombinatorParserSpecHelper
-  
+
   subject { Match[/\w+/] }
-  
+
   describe '#parse' do
-    
+
     context 'when the regexp matches' do
       it 'succeeds returning the matched string' do
         parsing('abc123  ').should result_in('abc123').at(6)
       end
     end
-    
+
     context 'when the regexp does not match' do
       it 'fails' do
         parsing('  abc').should fail
         parsing('==').should fail
       end
     end
-    
+
   end
-  
+
   describe '#capturing?' do
     it 'is true' do
       subject.should be_capturing
     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/parser_dsl_spec.rb

@@ -33,72 +33,80 @@ describe ParserDSL do
         subject.match(:EOF).should == Eof[]
       end
     end
+    context 'given :E' do
+      it 'creates the "E" symbol parser' do
+        subject.match(:E).should == ESymbol[]
+      end
+    end
   end
 
   describe '#optional' do
     context 'given a parser' do
-      it 'creates an optional parser' do
-        subject.optional(subject.match(/\w+/)).should == Optional[Match[/\w+/]]
+      it 'creates a repeat parser with optional bounds' do
+        subject.optional(subject.match(/\w+/)).
+          should == Repeat[Match[/\w+/], 0, 1]
       end
     end
     context 'given a match argument' do
-      it 'creates an optional match parser' do
-        subject.optional(/\w+/).should == Optional[Match[/\w+/]]
+      it 'creates a repeat parser with optional bounds' do
+        subject.optional(/\w+/).should == Repeat[Match[/\w+/], 0, 1]
       end
     end
   end
 
   describe '#zero_or_more' do
     context 'given a parser' do
-      it 'creates a zero-or-more parser' do
-        subject.zero_or_more(subject.match(/\w+/)).should == ZeroOrMore[Match[/\w+/]]
+      it 'creates a repeat parser with zero-or-more bounds' do
+        subject.zero_or_more(subject.match(/\w+/)).
+          should == Repeat[Match[/\w+/], 0, nil]
       end
     end
     context 'given a match argument' do
-      it 'creates a zero-or-more match parser' do
-        subject.zero_or_more(/\w+/).should == ZeroOrMore[Match[/\w+/]]
+      it 'creates a repeat parser with zero-or-more bounds' do
+        subject.zero_or_more(/\w+/).should == Repeat[Match[/\w+/], 0, nil]
       end
     end
   end
 
   describe '#one_or_more' do
     context 'given a parser' do
-      it 'creates a one-or-more parser' do
-        subject.one_or_more(subject.match(/\w+/)).should == OneOrMore[Match[/\w+/]]
+      it 'creates a repeat parser with one-or-more bounds' do
+        subject.one_or_more(subject.match(/\w+/)).
+          should == Repeat[Match[/\w+/], 1, nil]
       end
     end
     context 'given a match argument' do
-      it 'creates a one-or-more match parser' do
-        subject.one_or_more(/\w+/).should == OneOrMore[Match[/\w+/]]
+      it 'creates a repeat parser with one-or-more bounds' do
+        subject.one_or_more(/\w+/).should == Repeat[Match[/\w+/], 1, nil]
       end
     end
   end
 
-  describe '#list' do
+  describe '#repeat' do
     context 'given parsers' do
-      it 'creates a list parser' do
-        subject.list(subject.match(/\w+/), subject.match(/,/)).
-        should == List0[Match[/\w+/], Match[/,/]]
+      it 'creates a repeat parser' do
+        subject.repeat(subject.match(/\w+/), 2, 4).
+          should == Repeat[Match[/\w+/], 2, 4]
       end
     end
     context 'given match arguments' do
-      it 'creates a list parser' do
-        subject.list(/\w+/, ',').should == List0[Match[/\w+/], Match[/,/]]
+      it 'creates a repeat parser' do
+        subject.repeat(/\w+/, 2, 4).should == Repeat[Match[/\w+/], 2, 4]
       end
     end
   end
 
-  describe '#list1' do
+  describe '#list' do
     context 'given parsers' do
       it 'creates a list parser' do
-        subject.list1(subject.match(/\w+/), subject.match(/,/)).
-        should == List1[Match[/\w+/], Match[/,/]]
+        subject.list(subject.match(/\w+/), subject.match(/,/), 2, 4).
+        should == ListParser[Match[/\w+/], Match[/,/], 2, 4]
       end
     end
     context 'given match arguments' do
       it 'creates a list parser' do
-        subject.list1(/\w+/, ',').
-        should == List1[Match[/\w+/], Match[/,/]]
+        subject.list(/\w+/, ',', 2, 4).
+        should == ListParser[Match[/\w+/], Match[/,/], 2, 4]
       end
     end
   end
@@ -135,6 +143,12 @@ describe ParserDSL do
     end
   end
 
+  describe '#e' do
+    it 'creates the "E" symbol parser' do
+      subject.e.should == ESymbol[]
+    end
+  end
+
   describe '#dispatch_action' do
     context 'given a parser' do
       context 'given options' do
@@ -179,6 +193,51 @@ describe ParserDSL do
     end
   end
 
+  describe '#side_effect' do
+    context 'given a parser' do
+      it 'creates a side-effect parser' do
+        subject.side_effect(subject.match(/\d+/), '@i = _.to_i').
+        should == SideEffect[Match[/\d+/], '@i = _.to_i']
+      end
+    end
+    context 'given a match argument' do
+      it 'creates a side-effect match parser' do
+        subject.side_effect(/\d+/, '@i = _.to_i').
+        should == SideEffect[Match[/\d+/], '@i = _.to_i']
+      end
+    end
+  end
+
+  describe '#semantic_assert' do
+    context 'given a parser' do
+      it 'creates a positive Semantic predicate parser' do
+        subject.semantic_assert(subject.match(/\d+/), '_.to_i < 7').
+        should == SemanticAssert[Match[/\d+/], '_.to_i < 7']
+      end
+    end
+    context 'given a match argument' do
+      it 'creates a positive Semantic predicate match parser' do
+        subject.semantic_assert(/\d+/, '_.to_i < 7').
+        should == SemanticAssert[Match[/\d+/], '_.to_i < 7']
+      end
+    end
+  end
+
+  describe '#semantic_disallow' do
+    context 'given a parser' do
+      it 'creates a negative Semantic predicate parser' do
+        subject.semantic_disallow(subject.match(/\d+/), '_.to_i < 7').
+        should == SemanticDisallow[Match[/\d+/], '_.to_i < 7']
+      end
+    end
+    context 'given a match argument' do
+      it 'creates a negative Semantic match parser' do
+        subject.semantic_disallow(/\d+/, '_.to_i < 7').
+        should == SemanticDisallow[Match[/\d+/], '_.to_i < 7']
+      end
+    end
+  end
+
   describe '#token' do
     context 'given a parser' do
       it 'creates a token parser' do