rattler 0.5.0 → 0.6.0

data/spec/rattler/compiler_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/compiler/shared_compiler_examples')
+
+describe Rattler::Compiler do
+  include CompilerSpecHelper
+  include RuntimeParserSpecHelper
+
+  describe '.compile_parser result' do
+
+    let :compiled_parser do
+      described_class.compile_parser compiled_parser_base, grammar, :no_optimize => true
+    end
+
+    let(:compiled_parser_base) { Rattler::Runtime::RecursiveDescentParser }
+
+    it_behaves_like 'a compiled parser'
+  end
+
+  describe '.compile_parser' do
+
+    let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
+    context 'given parse rules' do
+
+      let(:rules) { [
+        rule(:word) { match(/\w+/) },
+        rule(:space) { match(/\s*/) }
+      ] }
+
+      let(:parser_base) { Rattler::Runtime::RecursiveDescentParser }
+
+      let(:result) { described_class.compile_parser(parser_base, grammar) }
+
+      it 'compiles a match_xxx method for each rule' do
+        result.should have_method(:match_word)
+        result.should have_method(:match_space)
+      end
+    end
+  end
+
+  describe '.compile' do
+
+    let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
+    context 'given parse rules' do
+
+      let(:rules) { [
+        rule(:word) { match(/\w+/) },
+        rule(:space) { match(/\s*/) }
+      ] }
+
+      let(:target_module) { Module.new }
+
+      before { described_class.compile(target_module, grammar) }
+
+      it 'compiles a match_xxx method for each rule' do
+        target_module.should have_method(:match_word)
+        target_module.should have_method(:match_space)
+      end
+    end
+  end
+
+  def have_method(rule_name)
+    be_method_defined(rule_name)
+  end
+
+end

data/spec/rattler/parsers/action_code_spec.rb

@@ -72,49 +72,53 @@ describe Rattler::Parsers::ActionCode do
 
   describe '#bind' do
 
-    let(:scope) { {} }
+    let(:scope) { ParserScope.new(bindings, captures) }
+    let(:bindings) { {} }
+    let(:captures) { [] }
 
     context 'when the code uses block parameters' do
 
+      let(:captures) { ['r0_0', 'r0_1'] }
+
       let(:code) { '|a, b| a + b' }
 
-      it 'replaces block parameter names with corresponding arguments' do
-        subject.bind(scope, ['r0_0', 'r0_1']).should == 'r0_0 + r0_1'
+      it 'replaces block parameter names with corresponding captures' do
+        subject.bind(scope).should == 'r0_0 + r0_1'
       end
     end
 
     context 'when the code refers to labels' do
 
-      let(:scope) { {:l => 'r0_3', :r => 'r0_5'} }
+      let(:bindings) { {:l => 'r0_3', :r => 'r0_5'} }
 
       let(:code) { 'l + r' }
 
       it 'replaces label names with associated arguments' do
-        subject.bind(scope, []).should == 'r0_3 + r0_5'
+        subject.bind(scope).should == 'r0_3 + r0_5'
       end
     end
 
     context 'when the code uses block parameters and label names' do
 
-      let(:scope) { {:c => 'r0_3', :d => 'r0_5'} }
+      let(:bindings) { {:c => 'r0_3', :d => 'r0_5'} }
+      let(:captures) { ['r0_0', 'r0_1'] }
 
       let(:code) { '|a, b| a * c + b * d' }
 
       it 'replaces both block parameter names and label names' do
-        subject.bind(scope, ['r0_0', 'r0_1']).
-          should == 'r0_0 * r0_3 + r0_1 * r0_5'
+        subject.bind(scope).should == 'r0_0 * r0_3 + r0_1 * r0_5'
       end
     end
 
     context 'when the code uses block parameters that are label names' do
 
-      let(:scope) { {:b => 'r0_3', :c => 'r0_5'} }
+      let(:bindings) { {:b => 'r0_3', :c => 'r0_5'} }
+      let(:captures) { ['r0_0', 'r0_1'] }
 
       let(:code) { '|a, b| a * c + b' }
 
       it 'the block parameters shadow the label names' do
-        subject.bind(scope, ['r0_0', 'r0_1']).
-          should == 'r0_0 * r0_5 + r0_1'
+        subject.bind(scope).should == 'r0_0 * r0_5 + r0_1'
       end
     end
 
@@ -123,25 +127,32 @@ describe Rattler::Parsers::ActionCode do
       let(:code) { '_.to_s' }
 
       context 'given one argument' do
+
+        let(:captures) { ['r0'] }
+
         it 'replaces "_" with the argument' do
-          subject.bind(scope, ['r0']).should == 'r0.to_s'
+          subject.bind(scope).should == 'r0.to_s'
         end
       end
 
       context 'given multiple arguments' do
+
+        let(:captures) { ['r0_0', 'r0_1'] }
+
         it 'replaces "_" with the array of arguments' do
-          subject.bind(scope, ['r0_0', 'r0_1']).
-            should == '[r0_0, r0_1].to_s'
+          subject.bind(scope).should == '[r0_0, r0_1].to_s'
         end
       end
     end
 
     context 'when the code uses "_" as a block parameter' do
 
+      let(:captures) { ['r0_0', 'r0_1'] }
+
       let(:code) { '|_| _.to_f' }
 
       it 'the block parameter shadows the default "_" binding' do
-        subject.bind(scope, ['r0_0', 'r0_1']).should == 'r0_0.to_f'
+        subject.bind(scope).should == 'r0_0.to_f'
       end
     end
 
@@ -150,15 +161,20 @@ describe Rattler::Parsers::ActionCode do
       let(:code) { 'do_stuff *_' }
 
       context 'given one argument' do
+
+        let(:captures) { ['r0'] }
+
         it 'replaces "*_" with the argument' do
-          subject.bind(scope, ['r0']).should == 'do_stuff r0'
+          subject.bind(scope).should == 'do_stuff r0'
         end
       end
 
       context 'given multiple arguments' do
+
+        let(:captures) { ['r0_0', 'r0_1'] }
+
         it 'replaces "*_" with the arguments' do
-          subject.bind(scope, ['r0_0', 'r0_1']).
-            should == 'do_stuff r0_0, r0_1'
+          subject.bind(scope).should == 'do_stuff r0_0, r0_1'
         end
       end
     end

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

@@ -2,11 +2,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::Grammar::Analysis do
+describe Analysis do
 
   subject { described_class.new(grammar.rules) }
 
-  let(:grammar) { Rattler::Grammar::Grammar[rule_set] }
+  let(:grammar) { Rattler::Parsers::Grammar[rule_set] }
 
   describe '#recursive?' do
 
@@ -46,6 +46,17 @@ describe Rattler::Grammar::Analysis do
         subject.recursive?(:a).should be_false
       end
     end
+
+    context 'given a rule with a Super' do
+
+      let (:rule_set) { RuleSet[
+        Rule[:a, Sequence[Match[/a/], Super[:a]]]
+      ] }
+
+      it 'returns true' do
+        subject.recursive?(:a).should be_true
+      end
+    end
   end
 
   describe '#left_recursive?' do
@@ -99,69 +110,4 @@ describe Rattler::Grammar::Analysis do
     end
   end
 
-  describe '#referenced_from?' do
-
-    context 'with non-recursive rules' do
-
-      let(:rule_set) { RuleSet[
-        Rule[:a, Apply[:b]],
-        Rule[:b, Apply[:c]],
-        Rule[:c, Match[/a/]],
-        Rule[:d, Match[/b/]]
-      ] }
-
-      context 'given a rule name and itself' do
-        it 'returns false' do
-          subject.referenced_from?(:a, :a).should be_false
-        end
-      end
-
-      context 'given a directly referenced rule name' do
-        it 'returns true' do
-          subject.referenced_from?(:a, :b).should be_true
-        end
-      end
-
-      context 'given an indirectly referenced rule name' do
-        it 'returns true' do
-          subject.referenced_from?(:a, :c).should be_true
-        end
-      end
-
-      context 'given a non-referenced rule name' do
-        it 'returns false' do
-          subject.referenced_from?(:a, :d).should be_false
-        end
-      end
-    end
-
-    context 'with recursive rules' do
-
-      let(:rule_set) { RuleSet[
-        Rule[:a, Apply[:a]],
-        Rule[:b, Apply[:c]],
-        Rule[:c, Apply[:b]]
-      ] }
-
-      context 'given a directly recursive rule name and itself' do
-        it 'returns true' do
-          subject.referenced_from?(:a, :a).should be_true
-        end
-      end
-
-      context 'given an indirectly recursive rule name and itself' do
-        it 'returns true' do
-          subject.referenced_from?(:b, :b).should be_true
-        end
-      end
-
-      context 'given a referenced rule name' do
-        it 'returns true' do
-          subject.referenced_from?(:b, :c).should be_true
-        end
-      end
-    end
-
-  end
-
 end

data/spec/rattler/parsers/apply_spec.rb

@@ -29,6 +29,12 @@ describe Apply do
     end
   end
 
+  describe '#capturing_decidable?' do
+    it 'is false' do
+      subject.should_not be_capturing_decidable
+    end
+  end
+
   describe '#with_ws' do
     it 'returns self' do
       subject.with_ws(Match[/\s*/]).should == subject

data/spec/rattler/parsers/assert_spec.rb

@@ -24,8 +24,44 @@ describe Assert 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/attributed_sequence_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AttributedSequence do
+  include CombinatorParserSpecHelper
+
+  include Rattler::Runtime
+
+  subject { AttributedSequence[*children] }
+
+  describe '#parse' do
+
+    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 and returns the result' do
+          parsing('foo').should result_in '<foo>'
+        end
+      end
+
+      context 'when the action uses "_"' do
+
+        let(:children) { [Match[/\w+/], SemanticAction['"<#{_}>"']] }
+
+        it 'binds the capture to "_" and returns the result' do
+          parsing('foo').should result_in '<foo>'
+        end
+      end
+    end
+
+    context 'with a single capture and a node action' do
+
+      let(:children) { [Match[/\w+/], NodeAction[ParseNode.name]] }
+
+      it 'returns a new node with the capture' do
+        parsing('foo').should result_in ParseNode.parsed(['foo'])
+      end
+    end
+
+    context 'with multiple captures and a semantic action' do
+
+      context 'when the action uses parameters' do
+
+        let :children do
+          [Match[/[a-z]+/], Match[/\d+/], SemanticAction['|a,b| b+a']]
+        end
+
+        it 'binds the captures to the parameters and returns the result' do
+          parsing('abc123').should result_in '123abc'
+        end
+      end
+
+      context 'when the action uses "_"' do
+
+        let(:children) { [Match[/[a-z]+/], Match[/\d+/], SemanticAction['_']] }
+
+        it 'binds the array of captures to "_" and returns the result' do
+          parsing('abc123').should result_in ['abc', '123']
+        end
+      end
+    end
+
+    context 'with multiple captures and a node action' do
+
+      let(:children) { [Match[/[a-z]+/], Match[/\d+/], NodeAction[ParseNode.name]] }
+
+      it 'returns a new node with the captures' do
+        parsing('abc123').should result_in ParseNode.parsed(['abc', '123'])
+      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 and returns the result' do
+        parsing('foo').should result_in '<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 and returns the result' do
+        parsing('abc123').should result_in '123abc'
+      end
+    end
+
+    context 'with labeled captures and a node action' do
+
+      let(:children) { [
+        Label[:a, Match[/[[:alpha:]]+/]],
+        Label[:b, Match[/[[:digit:]]+/]],
+        NodeAction[ParseNode.name]
+      ] }
+
+      it 'returns a new node with the captures and :labeled attribute' do
+        parsing('abc123').should result_in(
+          ParseNode.parsed(['abc', '123'], :labeled => {:a => 'abc', :b => '123'})
+        )
+      end
+    end
+  end
+
+  describe '#capturing?' do
+
+    context 'when attributed with a semantic action' do
+
+      let(:children) { [Match[/\w+/], SemanticAction['_']] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+
+    context 'when attributed with a semantic predicate' do
+
+      let(:children) { [Match[/\w+/], Assert[SemanticAction['_ == "hi"']]] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+
+    context 'when attributed with a side effect' do
+
+      let(:children) { [Match[/\w+/], Skip[SemanticAction['@word = _']]] }
+
+      it 'is false' do
+        subject.should_not be_capturing
+      end
+    end
+
+    context 'when attributed with a node action' do
+
+      let(:children) { [Match[/\w+/], NodeAction[ParseNode]] }
+
+      it 'is true' do
+        subject.should be_capturing
+      end
+    end
+  end
+
+  describe '#with_ws' do
+
+    let(:ws) { Match[/\s*/] }
+    let(:children) { [Match[/\w+/], SemanticAction['_']] }
+
+    it 'applies #with_ws to the children parsers' do
+      subject.with_ws(ws).should ==
+        AttributedSequence[Sequence[Skip[ws], children[0]], children[1]]
+    end
+  end
+
+  describe '#capture_count' do
+
+    context 'with a single capture and a semantic action' do
+
+      let(:children) { [Match[/\w+/], SemanticAction['_']] }
+
+      it 'is 1' do
+        subject.capture_count.should == 1
+      end
+    end
+
+    context 'with two captures and a semantic predicate' do
+
+      let(:children) do
+        [Match[/\w+/], Skip[Match[/\s+/]], Match[/\w+/], SemanticAction['_']]
+      end
+
+      it 'is 2' do
+        subject.capture_count.should == 2
+      end
+    end
+  end
+
+  describe '#&' do
+
+    let(:children) { [Match[/\w+/], SemanticAction['_']] }
+
+    it 'returns a new sequence with the given parser' do
+      (subject & Match[/:/]).should == Sequence[subject, Match[/:/]]
+    end
+  end
+
+  describe '#>>' do
+
+    let(:children) { [Match[/\w+/], SemanticAction['_']] }
+
+    it 'returns a new attributed sequence with the given semantic action' do
+      (subject >> SemanticAction['_ * 2']).should ==
+        AttributedSequence[subject, SemanticAction['_ * 2']]
+    end
+  end
+
+end