rattler 0.5.0 → 0.6.0

data/spec/rattler/parsers/parser_scope_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Rattler::Parsers::ParserScope do
+
+  describe '.empty' do
+
+    subject { described_class.empty }
+
+    it 'has no bindings' do
+      subject.bindings.should be_empty
+    end
+
+    it 'has no captures' do
+      subject.captures.should be_empty
+    end
+  end
+
+  describe '#bind' do
+
+    subject { described_class.empty }
+
+    it 'returns a new scope with the given bindings' do
+      scope = subject.bind(:a => 'foo', :b => 'bar')
+      scope.bindings[:a].should == 'foo'
+      scope.bindings[:b].should == 'bar'
+    end
+
+    context 'given a binding with an already bound name' do
+
+      subject { described_class.new(:a => 'foo') }
+
+      it 'shadows the existing binding with the new binding' do
+        subject.bind(:a => 'bar').bindings[:a].should == 'bar'
+      end
+    end
+
+    context 'with existing captures' do
+
+      subject { described_class.new({}, ['foo', 'bar']) }
+
+      it 'includes the captures in the new scope' do
+        subject.bind(:a => 'foo').captures.should == ['foo', 'bar']
+      end
+    end
+  end
+
+  describe '#capture' do
+
+    subject { described_class.empty }
+
+    it 'returns a new scope with the given captures' do
+      subject.capture('foo', 'bar').captures.should == ['foo', 'bar']
+    end
+
+    context 'with existing captures' do
+
+      subject { described_class.new({}, ['foo', 'bar']) }
+
+      it 'returns a new scope with the given captures appended' do
+        subject.capture('baz').captures.should == ['foo', 'bar', 'baz']
+      end
+    end
+
+    context 'with existing bindings' do
+
+      subject { described_class.new(:a => 'foo') }
+
+      it 'includes the bindings in the new scope' do
+        subject.capture('baz').bindings[:a].should == 'foo'
+      end
+    end
+  end
+
+  describe '#nest' do
+
+    subject { described_class.new({:a => 'baz'}, ['foo', 'bar']) }
+
+    it 'returns a new scope with the same bindings but no captures' do
+      subject.nest.bindings[:a].should == 'baz'
+      subject.nest.captures.should be_empty
+    end
+  end
+
+  describe '#merge' do
+
+    subject { described_class.new({:a => 'baz'}, ['foo', 'bar']) }
+    let(:other) { described_class.new({:b => 'fez'}, ['boo'] ) }
+
+    it 'returns a new scope with bindings from the other scope' do
+      merged = subject.merge(other)
+      merged.bindings[:a].should == 'baz'
+      merged.bindings[:b].should == 'fez'
+      merged.captures.should == ['foo', 'bar']
+    end
+  end
+
+  describe '#[]' do
+
+    subject { described_class.new(:a => 'foo') }
+
+    it 'returns bindings' do
+      subject[:a].should == 'foo'
+    end
+  end
+end

data/spec/rattler/parsers/repeat_spec.rb

@@ -97,6 +97,32 @@ describe Repeat do
       end
     end
 
+    context 'with a choice of capturing or non-capturing parsers' do
+
+      subject { Repeat[child, 0, nil] }
+
+      let(:child) { Choice[
+        Match[/a/],
+        Skip[Match[/b/]]
+      ] }
+
+      it 'returns only the capturing results' do
+        parsing('aba').should result_in(['a', 'a']).at(3)
+      end
+    end
+
+    context 'with an attributed sequence with a semantic action returning true' do
+
+      subject { Repeat[child, 0, nil] }
+
+      let(:child) do
+        AttributedSequence[Match[/\w/], SemanticAction['true']]
+      end
+
+      it 'returns an empty array' do
+        parsing('foo ').should result_in([]).at(3)
+      end
+    end
   end
 
   describe '#capturing?' do
@@ -121,6 +147,36 @@ describe Repeat do
 
   end
 
+  describe '#capturing_decidable?' do
+
+    context 'with a decidably capturing parser' do
+
+      subject { Repeat[capturing_child, 0, nil] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a decidably non-capturing parser' do
+
+      subject { Repeat[skipping_child, 0, nil] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a non-capturing_decidable parser' do
+
+      subject { Repeat[Apply[:foo], 0, nil] }
+
+      it 'is false' do
+        subject.should_not be_capturing_decidable
+      end
+    end
+  end
+
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }

data/spec/rattler/parsers/rule_set_spec.rb

@@ -9,10 +9,52 @@ describe Rattler::Parsers::RuleSet do
   let(:rule_b) { Rule[:b, Match[/b/]] }
 
   describe '#rule' do
+
     it 'returns rules by name' do
       subject.rule(:a).should == rule_a
       subject.rule(:b).should == rule_b
     end
+
+    context 'with included rules' do
+
+      subject { RuleSet[rule_a, rule_b, {:includes => [RuleSet[rule_c]]}] }
+
+      let(:rule_c) { Rule[:c, Match[/c/]] }
+
+      context 'given a name only in the included rules' do
+        it 'returns the rule from the included rules' do
+          subject.inherited_rule(:c).should == rule_c
+        end
+      end
+    end
+  end
+
+  describe '#inherited_rule' do
+
+    context 'with no includes' do
+      it 'returns nil' do
+        subject.inherited_rule(:foo).should be_nil
+      end
+    end
+
+    context 'with included rules' do
+
+      subject { RuleSet[rule_a, rule_b, {:includes => [RuleSet[old_rule_a]]}] }
+
+      let(:old_rule_a) { Rule[:a, Match[/A/]] }
+
+      context 'given a name not in the rule set or the included rules' do
+        it 'returns nil' do
+          subject.inherited_rule(:foo).should be_nil
+        end
+      end
+
+      context 'given a name in the included rules' do
+        it 'returns the rule from the included rules' do
+          subject.inherited_rule(:a).should == old_rule_a
+        end
+      end
+    end
   end
 
   describe '#[]' do

data/spec/rattler/parsers/semantic_action_spec.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe SemanticAction do
+  include CombinatorParserSpecHelper
+
+  describe '#parse' do
+
+    let(:scope) { ParserScope.new(bindings, captures) }
+
+    let(:bindings) { {} }
+    let(:captures) { [] }
+
+    context 'when the expression has no parameters' do
+
+      subject { SemanticAction['42'] }
+
+      it 'returns the evaluation of the expression without advancing' do
+        parsing('anything').at(4).should result_in(42).at(4)
+      end
+    end
+
+    context 'when the expression has parameters' do
+
+      subject { SemanticAction['|a,b| a * b'] }
+      let(:captures) { [2, 3] }
+
+      it 'returns the evaluation of the expression using captures' do
+        parsing('anything').at(4).should result_in(6).at(4)
+      end
+    end
+
+    context 'when the expression uses "_"' do
+
+      context 'given a single capture' do
+
+        subject { SemanticAction['_ * 4'] }
+        let(:captures) { [3] }
+
+        it 'returns the evaluation of the expression using the capture' do
+          parsing('anything').at(4).should result_in(12).at(4)
+        end
+      end
+
+      context 'given multiple captures' do
+
+        subject { SemanticAction['_ * 2'] }
+        let(:captures) { [3, 2] }
+
+        it 'returns the evaluation of the expression using the array of captures' do
+          parsing('anything').at(4).should result_in([3, 2, 3, 2]).at(4)
+        end
+      end
+    end
+
+    context 'when the expression uses labels' do
+
+      subject { SemanticAction['x * y'] }
+      let(:bindings) { {:x => 3, :y => 5 } }
+
+      it 'returns the evaluation of the expression using bindings' do
+        parsing('anything').at(4).should result_in(15).at(4)
+      end
+    end
+  end
+
+  describe '#capturing?' do
+    it 'is true' do
+      SemanticAction['@foo'].should be_capturing
+    end
+  end
+
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      SemanticAction['@foo'].should be_capturing_decidable
+    end
+  end
+
+  describe '#with_ws' do
+
+    subject { SemanticAction['@foo'] }
+
+    let(:ws) { Match[/\s*/] }
+
+    it 'returns the action unchanged' do
+      subject.with_ws(ws).should == subject
+    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] }
+  subject { Sequence[*children] }
 
   describe '#parse' do
 
-    let(:nested) { [Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]] }
+    let(:children) { [Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]] }
 
     context 'when all of the parsers match in sequence' do
       it 'matches returning the results in an array' do
@@ -23,7 +23,7 @@ describe Sequence do
 
     context 'with non-capturing parsers' do
 
-      let :nested do
+      let :children do
         [Match[/[[:alpha:]]+/], Skip[Match[/\s+/]], Match[/[[:digit:]]+/]]
       end
 
@@ -36,7 +36,7 @@ describe Sequence do
 
     context 'with only one capturing parser' do
 
-      let(:nested) { [Skip[Match[/\s+/]], Match[/\w+/]] }
+      let(:children) { [Skip[Match[/\s+/]], Match[/\w+/]] }
 
       context 'when all of the parsers match in sequence' do
         it 'returns the result of the capturing parser' do
@@ -47,7 +47,7 @@ describe Sequence do
 
     context 'with no capturing parsers' do
 
-      let(:nested) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
+      let(:children) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
 
       context 'when all of the parsers match in sequence' do
         it 'returns true' do
@@ -58,7 +58,7 @@ describe Sequence do
 
     context 'with an apply parser referencing a non-capturing rule' do
 
-      let(:nested) { [Match[/[[:alpha:]]+/], Apply[:ws], Match[/[[:digit:]]+/]] }
+      let(:children) { [Match[/[[:alpha:]]+/], Apply[:ws], Match[/[[:digit:]]+/]] }
 
       let(:rules) { RuleSet[Rule[:ws, Skip[Match[/\s+/]]]] }
 
@@ -68,13 +68,77 @@ describe Sequence do
         end
       end
     end
+
+    context 'with a single capture and a semantic action' do
+
+      context 'when the action uses a parameter' do
+
+        let(:children) { [Match[/\w+/], SemanticAction['|s| "<#{s}>"']] }
+
+        it 'binds the capture to the parameter' do
+          parsing('foo').should result_in ['foo', '<foo>']
+        end
+      end
+
+      context 'when the action uses "_"' do
+
+        let(:children) { [Match[/\w+/], SemanticAction['"<#{_}>"']] }
+
+        it 'binds the capture to "_"' do
+          parsing('foo').should result_in ['foo', '<foo>']
+        end
+      end
+    end
+
+    context 'with multiple captures and a semantic action' do
+
+      context 'when the action uses parameters' do
+
+        let(:children) { [Match[/[a-z]+/], Match[/\d+/], SemanticAction['|a,b| b+a']] }
+
+        it 'binds the captures to the parameters' do
+          parsing('abc123').should result_in ['abc', '123', '123abc']
+        end
+      end
+
+      context 'when the action uses "_"' do
+
+        let(:children) { [Match[/[a-z]+/], Match[/\d+/], SemanticAction['_']] }
+
+        it 'binds the array of captures to "_"' do
+          parsing('abc123').should result_in ['abc', '123', ['abc', '123']]
+        end
+      end
+    end
+
+    context 'with a single labeled capture and a semantic action' do
+
+      let(:children) { [Label[:a, Match[/\w+/]], SemanticAction['"<#{a}>"']] }
+
+      it 'binds the capture to the label name' do
+        parsing('foo').should result_in ['foo', '<foo>']
+      end
+    end
+
+    context 'with multiple labeled captures and a semantic action' do
+
+      let(:children) { [
+        Label[:a, Match[/[[:alpha:]]+/]],
+        Label[:b, Match[/[[:digit:]]+/]],
+        SemanticAction['b + a']
+      ] }
+
+      it 'binds the captures to the label names' do
+        parsing('abc123').should result_in ['abc', '123', '123abc']
+      end
+    end
   end
 
   describe '#capturing?' do
 
     context 'with any capturing parsers' do
 
-      let(:nested) { [Skip[Match[/\s*/]], Match[/\w+/]] }
+      let(:children) { [Skip[Match[/\s*/]], Match[/\w+/]] }
 
       it 'is true' do
         subject.should be_capturing
@@ -83,7 +147,7 @@ describe Sequence do
 
     context 'with no capturing parsers' do
 
-      let(:nested) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
+      let(:children) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
 
       it 'is false' do
         subject.should_not be_capturing
@@ -94,14 +158,94 @@ describe Sequence do
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }
-    let(:nested) { [Match[/[[:alpha:]]+/], Match[/[[:digit:]]+/]] }
+    let(:children) { [Match[/[[:alpha:]]+/], Match[/[[:digit:]]+/]] }
 
-    it 'applies #with_ws to the nested parsers' do
+    it 'applies #with_ws to the children parsers' do
       subject.with_ws(ws).should == Sequence[
-        Sequence[Skip[ws], nested[0]],
-        Sequence[Skip[ws], nested[1]]
+        Sequence[Skip[ws], children[0]],
+        Sequence[Skip[ws], children[1]]
       ]
     end
   end
 
+  describe '#capture_count' do
+
+    context 'with no capturing parsers' do
+
+      let(:children) { [Skip[Match[/\s*/]], Skip[Match[/#[^\n]+/]]] }
+
+      it 'is 0' do
+        subject.capture_count.should == 0
+      end
+    end
+
+    context 'with a single capturing parser' do
+
+      let(:children) { [Skip[Match[/\s*/]], Match[/\w+/]] }
+
+      it 'is 1' do
+        subject.capture_count.should == 1
+      end
+    end
+
+    context 'with a two capturing parsers' do
+
+      let(:children) { [Match[/[a-z]+/], Match[/\d+/]] }
+
+      it 'is 2' do
+        subject.capture_count.should == 2
+      end
+    end
+
+    context 'with a non-capturing parser and two capturing parsers' do
+
+      let(:children) { [Match[/\d+/], Skip[Match[/\s*/]], Match[/\d+/]] }
+
+      it 'is 2' do
+        subject.capture_count.should == 2
+      end
+    end
+  end
+
+  describe '#capturing_decidable?' do
+
+    context 'with all capturing_decidable parsers' do
+
+      let(:children) { [Match[/\w+/], Skip[Match[/\s*/]]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with any non-capturing_decidable parsers' do
+
+      let(:children) { [Match[/\w+/], Apply[:foo]] }
+
+      it 'is false' do
+        subject.should_not be_capturing_decidable
+      end
+    end
+  end
+
+  describe '#&' do
+
+    let(:children) { [Match[/[a-z]+/], Match[/\d+/]] }
+
+    it 'returns a new sequence with the given parser appended' do
+      (subject & Match[/:/]).should ==
+        Sequence[Match[/[a-z]+/], Match[/\d+/], Match[/:/]]
+    end
+  end
+
+  describe '#>>' do
+
+    let(:children) { [Match[/[a-z]+/], Match[/\d+/]] }
+
+    it 'returns an attributed sequence with the given semantic action' do
+      (subject >> SemanticAction['_']).should ==
+        AttributedSequence[Match[/[a-z]+/], Match[/\d+/], SemanticAction['_']]
+    end
+  end
+
 end