rattler 0.5.0 → 0.6.0

data/spec/rattler/parsers/back_reference_spec.rb

@@ -29,6 +29,12 @@ describe Rattler::Parsers::BackReference do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+  end
+
   describe '#re_source' do
     it 'returns the source for a Regexp that will match the referenced result' do
       subject.re_source(:a => 'r0').should == '#{r0}'

data/spec/rattler/parsers/choice_spec.rb

@@ -34,7 +34,6 @@ describe Choice do
         end
       end
     end
-
   end
 
   describe '#capturing?' do
@@ -56,7 +55,45 @@ describe Choice do
         subject.should_not be_capturing
       end
     end
+  end
+
+  describe '#capturing_decidable?' do
+
+    context 'with all decidably capturing parsers' do
+
+      let(:nested) { [Match[/a/], Match[/b/]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with all decidably non-capturing parsers' do
+
+      let(:nested) { [Skip[Match[/a/]], Skip[Match[/b/]]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with any non-capturing_decidable parsers' do
+
+      let(:nested) { [Match[/a/], Apply[:a]] }
 
+      it 'is false' do
+        subject.should_not be_capturing_decidable
+      end
+    end
+
+    context 'with both decidably capturing and decidably non-capturing parsers' do
+
+      let(:nested) { [Match[/a/], Skip[Match[/b/]]] }
+
+      it 'is false' do
+        subject.should_not be_capturing_decidable
+      end
+    end
   end
 
   describe '#with_ws' do

data/spec/rattler/parsers/combinator_parser_spec.rb

@@ -8,7 +8,8 @@ describe Rattler::Parsers::CombinatorParser do
   it_behaves_like 'a recursive descent parser'
 
   let :parser_class do
-    Rattler::Parsers::CombinatorParser.as_class(grammar.start_rule, grammar.rules)
+    Rattler::Parsers::CombinatorParser.as_class(
+      grammar.rules[grammar.start_rule], grammar.rules)
   end
 
 end

data/spec/rattler/parsers/disallow_spec.rb

@@ -24,8 +24,44 @@ describe Disallow do
   end
 
   describe '#capturing?' do
-    it 'is false' do
-      subject.should_not be_capturing
+
+    context 'with a capturing parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+
+    context 'with a non-capturing parser' do
+
+      let(:nested) { Skip[Match[/\w+/]] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+  end
+
+  describe '#capturing_decidable?' do
+
+    context 'with a decidably capturing parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a non capturing_decidable parser' do
+
+      let(:nested) { Apply[:foo] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
     end
   end
 

data/spec/rattler/parsers/e_symbol_spec.rb

@@ -18,6 +18,12 @@ describe ESymbol do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+  end
+
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }

data/spec/rattler/parsers/eof_spec.rb

@@ -27,6 +27,12 @@ describe Eof do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+  end
+
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }

data/spec/rattler/parsers/fail_spec.rb

@@ -19,4 +19,10 @@ describe Rattler::Parsers::Fail do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+  end
+
 end

data/spec/rattler/{grammar → parsers}/grammar_spec.rb

@@ -2,35 +2,30 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::Grammar::Grammar do
+describe Grammar do
 
   let(:rules) { RuleSet[rule_a, rule_b] }
 
-  let :rule_a do
-    Rule[:a, Choice[
-      Match['a'],
-      Apply[:b]
-    ]]
-  end
+  let(:rule_a) { Rule[:a, Match['a'] | Apply[:b]] }
 
   let(:rule_b) { Rule[:b, Match['b']] }
 
   describe '#start_rule' do
     context 'when no start_rule option was specified' do
 
-      subject { Rattler::Grammar::Grammar.new(rules) }
+      subject { Grammar.new(rules) }
 
-      it 'returns the first rule' do
-        subject.start_rule.should == rule_a
+      it 'returns the name of the first rule' do
+        subject.start_rule.should == :a
       end
     end
 
     context 'when an explicit start_rule option was specified' do
 
-      subject { Rattler::Grammar::Grammar.new(rules, :start_rule => :b) }
+      subject { Grammar.new(rules, :start_rule => :b) }
 
-      it 'uses the specified start_rule option' do
-        subject.start_rule.should == rule_b
+      it 'returns the specified start_rule option' do
+        subject.start_rule.should == :b
       end
     end
   end
@@ -38,7 +33,7 @@ describe Rattler::Grammar::Grammar do
   describe '#rules' do
     context 'when no start_rule option was specified' do
 
-      subject { Rattler::Grammar::Grammar.new(rules) }
+      subject { Grammar.new(rules) }
 
       it 'returns rules with the default start_rule' do
         subject.rules.start_rule.should == :a
@@ -47,7 +42,7 @@ describe Rattler::Grammar::Grammar do
 
     context 'when an explicit start_rule option was specified' do
 
-      subject { Rattler::Grammar::Grammar.new(rules, :start_rule => :b) }
+      subject { Grammar.new(rules, :start_rule => :b) }
 
       it 'returns rules with the specified start_rule option' do
         subject.rules.start_rule.should == :b

data/spec/rattler/parsers/label_spec.rb

@@ -40,6 +40,36 @@ describe Label do
 
   end
 
+  describe '#capturing_decidable?' do
+
+    context 'with a decidably capturing parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a decidably non-capturing parser' do
+
+      let(:nested) { Skip[Match[/\w+/]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a non capturing_decidable parser' do
+
+      let(:nested) { Apply[:foo] }
+
+      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/list_parser_spec.rb

@@ -6,6 +6,7 @@ describe ListParser do
   subject { ListParser[term_parser, sep_parser, *bounds] }
 
   let(:sep_parser) { Match[/[,;]/] }
+  let(:bounds) { [0, nil] }
 
   describe '#parse' do
 
@@ -149,8 +150,6 @@ describe ListParser do
 
   describe '#capturing?' do
 
-    let(:bounds) { [2, 4] }
-
     context 'with a capturing term parser' do
 
       let(:term_parser) { Match[/\w+/] }
@@ -170,6 +169,36 @@ describe ListParser do
     end
   end
 
+  describe '#capturing_decidable?' do
+
+    context 'with a decidably capturing parser' do
+
+      let(:term_parser) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a decidably non-capturing parser' do
+
+      let(:term_parser) { Skip[Match[/\w+/]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a non-capturing_decidable parser' do
+
+      let(:term_parser) { Apply[:foo] }
+
+      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/match_spec.rb

@@ -28,6 +28,12 @@ describe Rattler::Parsers::Match do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+  end
+
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }

data/spec/rattler/parsers/node_action_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include Rattler::Runtime
+
+describe NodeAction do
+  include CombinatorParserSpecHelper
+
+  describe '#parse' do
+
+    subject { NodeAction['Rattler::Runtime::ParseNode'] }
+
+    let(:scope) { ParserScope.new(bindings, captures) }
+
+    let(:bindings) { {} }
+    let(:captures) { [] }
+
+    context 'with no bindings or captures' do
+      it 'returns an empty node without advancing' do
+        parsing('anything').at(4).should result_in(ParseNode.parsed([])).at(4)
+      end
+    end
+
+    context 'with a single capture' do
+
+      let(:captures) { ['foo'] }
+
+      it 'returns a node with the capture' do
+        parsing('anything').should result_in ParseNode.parsed(['foo'])
+      end
+    end
+
+    context 'with multiple captures' do
+
+      let(:captures) { ['foo', 'bar'] }
+
+      it 'returns a node with the captures' do
+        parsing('anything').should result_in ParseNode.parsed(['foo', 'bar'])
+      end
+    end
+
+    context 'with bindings' do
+
+      let(:bindings) { {:a => 'foo', :b => 'bar'} }
+
+      it 'returns a node with the bindings as the :labeled attribute' do
+        parsing('anything').should result_in(
+          ParseNode.parsed([], :labeled => {:a => 'foo', :b => 'bar'})
+        )
+      end
+    end
+
+    context 'when the action has node attributes' do
+
+      subject { NodeAction['Rattler::Runtime::ParseNode',
+                            {:node_attrs => {:name => "FOO"}}] }
+
+      it 'returns a node with the attributes' do
+        parsing('anything').should result_in(
+          ParseNode.parsed([], :name => "FOO")
+        )
+      end
+    end
+  end
+
+  describe '#capturing?' do
+    it 'is true' do
+      NodeAction['Expr'].should be_capturing
+    end
+  end
+
+  describe '#capturing_decidable?' do
+    it 'is true' do
+      NodeAction['Expr'].should be_capturing_decidable
+    end
+  end
+
+  describe '#with_ws' do
+
+    subject { NodeAction['Expr'] }
+
+    let(:ws) { Match[/\s*/] }
+
+    it 'returns the action unchanged' do
+      subject.with_ws(ws).should == subject
+    end
+  end
+
+  describe '.parsed' do
+
+    subject { NodeAction.parsed(results, {}) }
+
+    context 'given all empty parse results' do
+
+      let(:results) { [[], []] }
+
+      it 'creates a NodeAction with the default node_type of ParseNode' do
+        subject.should == NodeAction['Rattler::Runtime::ParseNode']
+      end
+    end
+
+    context 'given a node_type result' do
+
+      let(:results) { [[['Expr', []]], []]}
+
+      it 'creates a NodeAction with the node_type' do
+        subject.should == NodeAction['Expr']
+      end
+    end
+
+    context 'given a name result' do
+
+      let(:results) { [[], ['"FOO"']] }
+
+      it 'creates a NodeAction with node_attrs for the name' do
+        subject.should == NodeAction['Rattler::Runtime::ParseNode',
+                                      {:node_attrs => {:name => 'FOO'}}]
+      end
+    end
+  end
+
+end