rattler 0.5.0 → 0.6.0

data/spec/rattler/{back_end → compiler}/parser_generator/match_generator_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
-include Rattler::BackEnd::ParserGenerator
+include Rattler::Compiler::ParserGenerator
 include Rattler::Parsers
 
 describe MatchGenerator do
@@ -60,60 +60,6 @@ describe MatchGenerator do
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'when nested' do
-      it 'generates nested regex matching code with a dispatch action' do
-        nested_code {|g| g.gen_dispatch_action match, code }.
-          should == (<<-CODE).strip
-begin
-  (r = @scanner.scan(/\\w+/)) &&
-  Word.parsed([r])
-end
-          CODE
-      end
-    end
-
-    context 'when top-level' do
-      it 'generates top level regex matching code with a dispatch action' do
-        top_level_code {|g| g.gen_dispatch_action match, code }.
-          should == (<<-CODE).strip
-(r = @scanner.scan(/\\w+/)) &&
-Word.parsed([r])
-          CODE
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:code) { ActionCode.new('|_| _.to_sym') }
-
-    context 'when nested' do
-      it 'generates nested regex matching code with a direct action' do
-        nested_code {|g| g.gen_direct_action match, code }.
-          should == (<<-CODE).strip
-begin
-  (r = @scanner.scan(/\\w+/)) &&
-  (r.to_sym)
-end
-          CODE
-      end
-    end
-
-    context 'when top-level' do
-      it 'generates top level regex matching code with a direct action' do
-        top_level_code {|g| g.gen_direct_action match, code }.
-          should == (<<-CODE).strip
-(r = @scanner.scan(/\\w+/)) &&
-(r.to_sym)
-          CODE
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     context 'when nested' do

data/spec/rattler/compiler/parser_generator/node_action_generator_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Compiler::ParserGenerator
+include Rattler::Parsers
+
+describe NodeActionGenerator do
+
+  include ParserGeneratorSpecHelper
+  include Rattler::Runtime
+
+  let(:action) { NodeAction['Expr'] }
+
+  let(:scope) { ParserScope.new(bindings, captures) }
+  let(:bindings) { {} }
+  let(:captures) { [] }
+
+  describe '#gen_basic' do
+
+    context 'with no bindings or captures' do
+      it 'generates node action code' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.parsed([])'
+      end
+    end
+
+    context 'with a single capture' do
+
+      let(:captures) { ['r0_0'] }
+
+      it 'generates node action code with the capture in an array' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.parsed([r0_0])'
+      end
+    end
+
+    context 'with multiple captures' do
+
+      let(:captures) { ['r0_0', 'r0_1'] }
+
+      it 'generates node action code with the capture in an array' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.parsed([r0_0, r0_1])'
+      end
+    end
+
+    context 'with bindings' do
+
+      let(:bindings) { {:a => 'r0_1'} }
+
+      it 'generates node action code with the bindings as a :labeled attribute' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.parsed([], :labeled => {:a => r0_1})'
+      end
+    end
+
+    context 'with undecidable captures' do
+
+      let(:captures) { ['r0_0', 'r0_1'] }
+
+      it 'generates node action code that uses select_captures' do
+        top_level_code {|g| g.gen_basic action, scope.with_undecidable_captures }.
+        should == 'Expr.parsed(select_captures([r0_0, r0_1]))'
+      end
+    end
+
+    context 'when the action has an alternate factory method' do
+
+      let(:action) { NodeAction['Expr', {:method => 'create'}] }
+
+      it 'generates node action code with the factory method' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.create([])'
+      end
+    end
+
+    context 'when the action has node attributes' do
+
+      let(:action) { NodeAction['Expr', {:node_attrs => {:name => "FOO"}}] }
+
+      it 'generates node action code with the node attributes' do
+        top_level_code {|g| g.gen_basic action, scope }.
+        should == 'Expr.parsed([], :name => "FOO")'
+      end
+    end
+  end
+
+  describe '#gen_assert' do
+
+    context 'when nested' do
+      it 'generates nested node assert code' do
+        nested_code {|g| g.gen_assert action }.
+        should == '(Expr.parsed([]) && true)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level node assert code' do
+        top_level_code {|g| g.gen_assert action }.
+        should == 'Expr.parsed([]) && true'
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+    it 'generates node disallow code' do
+      top_level_code {|g| g.gen_disallow action }.
+      should == '!Expr.parsed([])'
+    end
+  end
+
+  describe '#gen_token' do
+    it 'generates node token code' do
+      top_level_code {|g| g.gen_token action }.
+      should == 'Expr.parsed([]).to_s'
+    end
+  end
+
+  describe '#gen_skip' do
+
+    context 'when nested' do
+      it 'generates nested node skipping code' do
+        nested_code {|g| g.gen_skip action }.
+        should == '(Expr.parsed([]); true)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level node skipping code' do
+        top_level_code {|g| g.gen_skip action }.
+        should == 'Expr.parsed([]); true'
+      end
+    end
+  end
+
+end

data/spec/rattler/{back_end → compiler}/parser_generator/one_or_more_generator_examples.rb

@@ -87,80 +87,6 @@ a unless a.empty?
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'given a repeat with one-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested one-or-more matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  while r = @scanner.scan(/w+/)
-    a << r
-  end
-  Word.parsed(select_captures(a)) unless a.empty?
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level one-or-more matching code with a dispatch action' do
-          top_level_code {|g| g.gen_dispatch_action repeat, code }.
-            should == (<<-CODE).strip
-a = []
-while r = @scanner.scan(/w+/)
-  a << r
-end
-Word.parsed(select_captures(a)) unless a.empty?
-            CODE
-        end
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { ActionCode.new('|_| _.size') }
-
-    context 'given a repeat with one-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested one-or-more matching code with a direct action' do
-          nested_code {|g| g.gen_direct_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  while r = @scanner.scan(/w+/)
-    a << r
-  end
-  (select_captures(a).size) unless a.empty?
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level one-or-more matching code with a direct action' do
-          top_level_code {|g| g.gen_direct_action repeat, code }.
-            should == (<<-CODE).strip
-a = []
-while r = @scanner.scan(/w+/)
-  a << r
-end
-(select_captures(a).size) unless a.empty?
-            CODE
-        end
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     let(:nested) { Match[/w+/] }

data/spec/rattler/{back_end → compiler}/parser_generator/optional_generator_examples.rb

@@ -61,68 +61,6 @@ shared_examples_for 'an optional generator' do
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'given a repeat with optional bounds' do
-
-      context 'when nested' do
-        it 'generates nested optional matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  r = @scanner.scan(/w+/)
-  Word.parsed(r ? [r] : [])
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level optional matching code with a dispatch action' do
-          top_level_code {|g| g.gen_dispatch_action repeat, code }.
-            should == (<<-CODE).strip
-r = @scanner.scan(/w+/)
-Word.parsed(r ? [r] : [])
-            CODE
-        end
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:nested) { Match[/w+/] }
-    let(:code) { ActionCode.new('|_| _.size') }
-
-    context 'given a repeat with optional bounds' do
-
-      context 'when nested' do
-        it 'generates nested optional matching code with a direct action' do
-          nested_code {|g| g.gen_direct_action repeat, code }.
-            should == (<<-CODE).strip
-begin
-  r = @scanner.scan(/w+/)
-  ((r ? [r] : []).size)
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level optional matching code with a direct action' do
-          top_level_code {|g| g.gen_direct_action repeat, code }.
-            should == (<<-CODE).strip
-r = @scanner.scan(/w+/)
-((r ? [r] : []).size)
-            CODE
-        end
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     let(:nested) { Match[/w+/] }

data/spec/rattler/{back_end → compiler}/parser_generator/repeat_generator_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/zero_or_more_generator_examp
 require File.expand_path(File.dirname(__FILE__) + '/one_or_more_generator_examples')
 require File.expand_path(File.dirname(__FILE__) + '/optional_generator_examples')
 
-include Rattler::BackEnd::ParserGenerator
+include Rattler::Compiler::ParserGenerator
 include Rattler::Parsers
 
 describe RepeatGenerator do
@@ -107,6 +107,71 @@ end
         end
       end
     end
+
+    context 'with an Apply parser' do
+
+      let(:bounds) { [0, nil] }
+      let(:nested) { Apply[:a] }
+
+      it 'generates repeat code that selects only the captures for the result' do
+        top_level_code {|g| g.gen_basic repeat }.should == <<-CODE.strip
+a = []
+while r = match(:a)
+  a << r
+end
+select_captures(a)
+        CODE
+      end
+    end
+
+    context 'with a choice of capturing or non-capturing parsers' do
+
+      let(:bounds) { [0, nil] }
+      let(:nested) { Choice[
+        Match[/a/],
+        Skip[Match[/b/]]
+      ] }
+
+      it 'generates repeat code that selects only the captures for the result' do
+        top_level_code {|g| g.gen_basic repeat }.should == <<-CODE.strip
+a = []
+while r = begin
+  @scanner.scan(/a/) ||
+  (@scanner.skip(/b/) && true)
+end
+  a << r
+end
+select_captures(a)
+        CODE
+      end
+    end
+
+    context 'with an attributed sequence with a semantic action' do
+
+      let(:bounds) { [0, nil] }
+      let(:nested) do
+        AttributedSequence[Match[/\w/], SemanticAction['_']]
+      end
+
+      it 'generates repeat code that selects only the captures for the result' do
+        top_level_code {|g| g.gen_basic repeat }.should == <<-'CODE'.strip
+a = []
+while r = begin
+  p0 = @scanner.pos
+  begin
+    (r0_0 = @scanner.scan(/\w/)) &&
+    (r0_0)
+  end || begin
+    @scanner.pos = p0
+    false
+  end
+end
+  a << r
+end
+select_captures(a)
+        CODE
+      end
+    end
   end
 
   describe '#gen_assert' do

data/spec/rattler/{back_end → compiler}/parser_generator/rule_generator_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::ParserGenerator::RuleGenerator do
+describe Rattler::Compiler::ParserGenerator::RuleGenerator do
 
   include ParserGeneratorSpecHelper
 
@@ -21,7 +21,8 @@ end
 # @private
 def match_a! #:nodoc:
   @scanner.scan("a") ||
-  match(:b)
+  match(:b) ||
+  fail! { :a }
 end
       CODE
     end