rattler 0.4.2 → 0.5.0

data/spec/rattler/parsers/repeat_spec.rb

@@ -0,0 +1,233 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Repeat do
+  include CombinatorParserSpecHelper
+
+  let(:capturing_child) { Match[/\w/] }
+  let(:skipping_child) { Skip[capturing_child] }
+  let(:child) { capturing_child }
+
+  describe '#parse' do
+
+    context 'with a capturing parser' do
+
+      let(:child) { Match[/\w/] }
+
+      context 'with no upper bound' do
+
+        subject { Repeat[child, 2, nil] }
+
+        context 'when the parser matches enough times' do
+          it 'matches returning the results in an array' do
+            parsing('foo').should result_in(['f', 'o', 'o']).at(3)
+          end
+        end
+
+        context 'when the parser matches too few times' do
+          it 'fails' do
+            parsing('f  ').should fail
+          end
+        end
+      end
+
+      context 'with an upper bound' do
+
+        subject { Repeat[child, 2, 4] }
+
+        context 'when the parser would match more times than the upper bound' do
+          it 'stops matching at the upper bound' do
+            parsing('abcde').should result_in(['a', 'b', 'c', 'd']).at(4)
+          end
+        end
+      end
+
+      context 'with a zero lower bound' do
+
+        subject { Repeat[child, 0, nil] }
+
+        context 'when the parser never matches' do
+          it 'matches returning an empty array' do
+            parsing('   ').should result_in([]).at(0)
+          end
+        end
+      end
+    end
+
+    context 'with a non-capturing parser' do
+
+      let(:child) { skipping_child }
+
+      context 'with no upper bound' do
+
+        subject { Repeat[child, 2, nil] }
+
+        context 'when the parser matches enough times' do
+          it 'matches returning true' do
+            parsing('foo').should result_in(true).at(3)
+          end
+        end
+
+        context 'when the parser matches too few times' do
+          it 'fails' do
+            parsing('f  ').should fail
+          end
+        end
+      end
+
+      context 'with an upper bound' do
+
+        subject { Repeat[child, 2, 4] }
+
+        context 'when the parser would match more times than the upper bound' do
+          it 'stops matching at the upper bound' do
+            parsing('abcde').should result_in(true).at(4)
+          end
+        end
+      end
+
+      context 'with a zero lower bound' do
+
+        subject { Repeat[child, 0, nil] }
+
+        context 'when the parser never matches' do
+          it 'matches returning true' do
+            parsing('   ').should result_in(true).at(0)
+          end
+        end
+      end
+    end
+
+  end
+
+  describe '#capturing?' do
+
+    context 'with a capturing parser' do
+
+      subject { Repeat[capturing_child, 0, nil] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+
+    context 'with a non-capturing parser' do
+
+      subject { Repeat[skipping_child, 0, nil] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+
+  end
+
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    subject { Repeat[child, 2, 4] }
+
+    it 'applies #with_ws to the nested parser' do
+      subject.with_ws(ws).
+        should == Repeat[Sequence[Skip[ws], child], 2, 4]
+    end
+  end
+
+  describe '#zero_or_more?' do
+
+    context 'with zero-or-more bounds' do
+
+      subject { Repeat[child, 0, nil] }
+
+      it 'is true' do
+        subject.should be_zero_or_more
+      end
+    end
+
+    context 'with an upper bound' do
+
+      subject { Repeat[child, 0, 10] }
+
+      it 'is false' do
+        subject.should_not be_zero_or_more
+      end
+    end
+
+    context 'with non-zero lower bound' do
+
+      subject { Repeat[child, 1, nil] }
+
+      it 'is false' do
+        subject.should_not be_zero_or_more
+      end
+    end
+  end
+
+  describe '#one_or_more?' do
+
+    context 'with one-or-more bounds' do
+
+      subject { Repeat[child, 1, nil] }
+
+      it 'is true' do
+        subject.should be_one_or_more
+      end
+    end
+
+    context 'with an upper bound' do
+
+      subject { Repeat[child, 1, 10] }
+
+      it 'is false' do
+        subject.should_not be_one_or_more
+      end
+    end
+
+    context 'with non-one lower bound' do
+
+      subject { Repeat[child, 0, nil] }
+
+      it 'is false' do
+        subject.should_not be_one_or_more
+      end
+    end
+  end
+
+  describe '#optional?' do
+
+    context 'with optional bounds' do
+
+      subject { Repeat[child, 0, 1] }
+
+      it 'is true' do
+        subject.should be_optional
+      end
+    end
+
+    context 'with no upper bound' do
+
+      subject { Repeat[child, 0, nil] }
+
+      it 'is false' do
+        subject.should_not be_optional
+      end
+    end
+
+    context 'with non-one upper bound' do
+
+      subject { Repeat[child, 0, 2] }
+
+      it 'is false' do
+        subject.should_not be_optional
+      end
+    end
+
+    context 'with non-zero lower bound' do
+
+      subject { Repeat[child, 1, 1] }
+
+      it 'is false' do
+        subject.should_not be_optional
+      end
+    end
+  end
+end

data/spec/rattler/parsers/semantic_assert_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe SemanticAssert do
+  include CombinatorParserSpecHelper
+
+  subject { SemanticAssert[nested, code] }
+
+  describe '#parse' do
+
+    context 'with a capturing parser' do
+
+      let(:nested) { Match[/[[:digit:]]+/] }
+      let(:code) { '|s| s == "451"' }
+
+      context 'when the parser matches' do
+
+        context 'if the semantic action results in a true value' do
+          it 'succeeds' do
+            parsing('451a').should result_in('451').at(3)
+          end
+        end
+
+        context 'if the semantic action results in a false value' do
+          it 'fails' do
+            parsing('321a').should fail
+          end
+        end
+      end
+
+      context 'when the parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
+        end
+      end
+
+      context 'using the "_" character' do
+
+        let(:code) { '_ == "451"' }
+
+        it 'evaluates the predicate binding the captured result as "_"' do
+          parsing('451a').should result_in('451').at(3)
+          parsing('321a').should fail
+        end
+      end
+    end
+  end
+
+  describe '#capturing?' do
+
+    let(:code) { '' }
+
+    context 'with a capturing parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+
+    context 'with a non-capturing parser' do
+
+      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 == SemanticAssert[Sequence[Skip[ws], nested], code]
+    end
+  end
+
+end

data/spec/rattler/parsers/semantic_disallow_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe SemanticDisallow do
+  include CombinatorParserSpecHelper
+
+  subject { SemanticDisallow[nested, code] }
+
+  describe '#parse' do
+
+    context 'with a capturing parser' do
+
+      let(:nested) { Match[/[[:digit:]]+/] }
+      let(:code) { '|s| s == "451"' }
+
+      context 'when the parser matches' do
+
+        context 'if the semantic action results in a true value' do
+          it 'fails' do
+            parsing('451a').should fail
+          end
+        end
+
+        context 'if the semantic action results in a false value' do
+          it 'succeeds' do
+            parsing('321a').should result_in('321').at(3)
+          end
+        end
+      end
+
+      context 'when the parser fails' do
+        it 'fails' do
+          parsing('foo').should fail
+        end
+      end
+
+      context 'using the "_" character' do
+
+        let(:code) { '_ == "451"' }
+
+        it 'evaluates the predicate binding the captured result as "_"' do
+          parsing('451a').should fail
+          parsing('321a').should result_in('321').at(3)
+        end
+      end
+    end
+  end
+
+  describe '#capturing?' do
+
+    let(:code) { '' }
+
+    context 'with a capturing parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+
+    context 'with a non-capturing parser' do
+
+      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 == SemanticDisallow[Sequence[Skip[ws], nested], code]
+    end
+  end
+
+end

data/spec/rattler/parsers/sequence_spec.rb

@@ -3,11 +3,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Sequence do
   include CombinatorParserSpecHelper
 
+  subject { Sequence[*nested] }
+
   describe '#parse' do
 
-    subject do
-      Sequence[Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]]
-    end
+    let(:nested) { [Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]] }
 
     context 'when all of the parsers match in sequence' do
       it 'matches returning the results in an array' do
@@ -22,9 +22,11 @@ describe Sequence do
     end
 
     context 'with non-capturing parsers' do
-      subject do
-        Sequence[Match[/[[:alpha:]]+/], Skip[Match[/\s+/]], Match[/[[:digit:]]+/]]
+
+      let :nested do
+        [Match[/[[:alpha:]]+/], Skip[Match[/\s+/]], Match[/[[:digit:]]+/]]
       end
+
       context 'when all of the parsers match in sequence' do
         it 'only includes results of its capturing parsers in the result array' do
           parsing('foo 42').should result_in ['foo', '42']
@@ -33,9 +35,9 @@ describe Sequence do
     end
 
     context 'with only one capturing parser' do
-      subject do
-        Sequence[Skip[Match[/\s+/]], Match[/\w+/]]
-      end
+
+      let(:nested) { [Skip[Match[/\s+/]], Match[/\w+/]] }
+
       context 'when all of the parsers match in sequence' do
         it 'returns the result of the capturing parser' do
           parsing('  abc123').should result_in 'abc123'
@@ -44,9 +46,9 @@ describe Sequence do
     end
 
     context 'with no capturing parsers' do
-      subject do
-        Sequence[Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]]
-      end
+
+      let(:nested) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
+
       context 'when all of the parsers match in sequence' do
         it 'returns true' do
           parsing(' # foo').should result_in true
@@ -55,9 +57,8 @@ describe Sequence do
     end
 
     context 'with an apply parser referencing a non-capturing rule' do
-      subject do
-        Sequence[Match[/[[:alpha:]]+/], Apply[:ws], Match[/[[:digit:]]+/]]
-      end
+
+      let(:nested) { [Match[/[[:alpha:]]+/], Apply[:ws], Match[/[[:digit:]]+/]] }
 
       let(:rules) { RuleSet[Rule[:ws, Skip[Match[/\s+/]]]] }
 
@@ -72,22 +73,35 @@ describe Sequence do
   describe '#capturing?' do
 
     context 'with any capturing parsers' do
-      subject do
-        Sequence[Skip[Match[/\s*/]], Match[/\w+/]]
-      end
+
+      let(:nested) { [Skip[Match[/\s*/]], Match[/\w+/]] }
+
       it 'is true' do
         subject.should be_capturing
       end
     end
 
     context 'with no capturing parsers' do
-      subject do
-        Sequence[Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]]
-      end
+
+      let(:nested) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
+
       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 == Sequence[
+        Sequence[Skip[ws], nested[0]],
+        Sequence[Skip[ws], nested[1]]
+      ]
+    end
+  end
+
 end