rattler 0.5.0 → 0.6.0

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

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::Compiler::ParserGenerator::GrammarGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  describe '#generate' do
+
+    context 'given a grammar with a :grammar_name option' do
+
+      let(:grammar) { Grammar.new(rules, :grammar_name => 'ExprGrammar') }
+
+      let(:rules) { RuleSet[Rule[:a, Match['a']]] }
+
+      it 'generates a grammar module with a CLI' do
+        trim_lines(generated_code {|g| g.generate grammar }).strip.
+        should == (<<-CODE).strip
+# encoding: utf-8
+
+# @private
+module ExprGrammar #:nodoc:
+
+  # @private
+  def start_rule #:nodoc:
+    :a
+  end
+
+  # @private
+  def match_a #:nodoc:
+    apply :match_a!
+  end
+
+  # @private
+  def match_a! #:nodoc:
+    @scanner.scan("a") ||
+    fail { :a }
+  end
+
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'rattler'
+  Rattler::Util::GrammarCLI.run(ExprGrammar)
+end
+        CODE
+      end
+    end
+
+    context 'given a grammar with a :parser_name option' do
+
+      let(:grammar) { Grammar.new(rules, :parser_name => 'ExprParser') }
+
+      let(:rules) { RuleSet[Rule[:a, Match['a']]] }
+
+      it 'generates a parser module with a CLI' do
+        trim_lines(generated_code {|g| g.generate grammar }).strip.
+        should == (<<-CODE).strip
+# encoding: utf-8
+
+# @private
+class ExprParser < Rattler::Runtime::PackratParser #:nodoc:
+
+  # @private
+  def start_rule #:nodoc:
+    :a
+  end
+
+  # @private
+  def match_a #:nodoc:
+    apply :match_a!
+  end
+
+  # @private
+  def match_a! #:nodoc:
+    @scanner.scan("a") ||
+    fail { :a }
+  end
+
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'rattler'
+  Rattler::Util::ParserCLI.run(ExprParser)
+end
+        CODE
+      end
+    end
+  end
+
+  def trim_lines(s)
+    s.each_line.map {|_| "#{_.rstrip}\n" }.join
+  end
+
+end

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

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Compiler::ParserGenerator
+include Rattler::Parsers
+
+describe GroupMatchGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  let(:single_group) { GroupMatch[Match[/\s*(\w+)/], {:num_groups => 1}] }
+
+  let(:multi_group) { GroupMatch[Match[/\s*(\w+)\s+(\w+)/], {:num_groups => 2}] }
+
+  describe '#gen_basic' do
+
+    context 'given a single-group match' do
+
+      context 'when nested' do
+        it 'generates nested regex group matching code returning the group' do
+          nested_code {|g| g.gen_basic single_group }.
+            should == (<<-CODE).strip
+begin
+  @scanner.skip(/\\s*(\\w+)/) &&
+  @scanner[1]
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level regex group matching code returning the group' do
+          top_level_code {|g| g.gen_basic single_group }.
+            should == (<<-CODE).strip
+@scanner.skip(/\\s*(\\w+)/) &&
+@scanner[1]
+            CODE
+        end
+      end
+    end
+
+    context 'given a multi-group match' do
+
+      context 'when nested' do
+        it 'generates nested regex matching code returning an array of groups' do
+          nested_code {|g| g.gen_basic multi_group }.
+            should == (<<-CODE).strip
+begin
+  @scanner.skip(/\\s*(\\w+)\\s+(\\w+)/) &&
+  [@scanner[1], @scanner[2]]
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level regex matching code returning an array of groups' do
+          top_level_code {|g| g.gen_basic multi_group }.
+            should == (<<-CODE).strip
+@scanner.skip(/\\s*(\\w+)\\s+(\\w+)/) &&
+[@scanner[1], @scanner[2]]
+            CODE
+        end
+      end
+    end
+  end
+
+end

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

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
-include Rattler::BackEnd::ParserGenerator
+include Rattler::Compiler::ParserGenerator
 
 describe GroupMatch do
   include CombinatorParserSpecHelper

data/spec/rattler/{back_end → compiler}/parser_generator/label_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 LabelGenerator do
@@ -60,60 +60,6 @@ describe LabelGenerator do
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'when nested' do
-      it 'generates nested matching code with a dispatch action' do
-        nested_code {|g| g.gen_dispatch_action label, code }.
-          should == (<<-CODE).strip
-begin
-  (r = @scanner.scan(/\\w+/)) &&
-  Word.parsed([r], :labeled => {:word => r})
-end
-          CODE
-      end
-    end
-
-    context 'when top-level' do
-      it 'generates top level matching code with a dispatch action' do
-        top_level_code {|g| g.gen_dispatch_action label, code }.
-          should == (<<-CODE).strip
-(r = @scanner.scan(/\\w+/)) &&
-Word.parsed([r], :labeled => {:word => r})
-          CODE
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:code) { ActionCode.new('word.to_sym') }
-
-    context 'when nested' do
-      it 'generates nested matching code with a direct action using the label' do
-        nested_code {|g| g.gen_direct_action label, 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 matching code with a direct action' do
-        top_level_code {|g| g.gen_direct_action label, 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/{back_end → compiler}/parser_generator/list0_generator_examples.rb

@@ -133,94 +133,6 @@ true
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'given a list with zero-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless @scanner.skip(/[,;]/)
-  end
-  @scanner.pos = ep unless ep.nil?
-  Word.parsed(select_captures(a))
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-a = []
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless @scanner.skip(/[,;]/)
-end
-@scanner.pos = ep unless ep.nil?
-Word.parsed(select_captures(a))
-            CODE
-        end
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:code) { ActionCode.new('|_| _.size') }
-
-    context 'given a list with zero-or-more bounds' do
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless @scanner.skip(/[,;]/)
-  end
-  @scanner.pos = ep unless ep.nil?
-  (select_captures(a).size)
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-a = []
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless @scanner.skip(/[,;]/)
-end
-@scanner.pos = ep unless ep.nil?
-(select_captures(a).size)
-            CODE
-        end
-      end
-    end
-  end
-
   describe '#gen_skip' do
 
     context 'given a list with zero-or-more bounds' do

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

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

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

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/list1_generator_examples')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::ParserGenerator::ListGenerator do
+describe Rattler::Compiler::ParserGenerator::ListGenerator do
 
   include ParserGeneratorSpecHelper
 
@@ -412,232 +412,6 @@ c < 2
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'given a list with an upper bound' do
-
-      let(:bounds) { [2, 4] }
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  sp = @scanner.pos
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless a.size < 4
-    break unless @scanner.skip(/[,;]/)
-  end
-  if a.size >= 2
-    @scanner.pos = ep unless ep.nil?
-    Word.parsed(select_captures(a))
-  else
-    @scanner.pos = sp
-    false
-  end
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-a = []
-sp = @scanner.pos
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless a.size < 4
-  break unless @scanner.skip(/[,;]/)
-end
-if a.size >= 2
-  @scanner.pos = ep unless ep.nil?
-  Word.parsed(select_captures(a))
-else
-  @scanner.pos = sp
-  false
-end
-            CODE
-        end
-      end
-    end
-
-    context 'given a list with no upper bound' do
-
-      let(:bounds) { [2, nil] }
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  sp = @scanner.pos
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless @scanner.skip(/[,;]/)
-  end
-  if a.size >= 2
-    @scanner.pos = ep unless ep.nil?
-    Word.parsed(select_captures(a))
-  else
-    @scanner.pos = sp
-    false
-  end
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_dispatch_action list, code }.
-            should == (<<-CODE).strip
-a = []
-sp = @scanner.pos
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless @scanner.skip(/[,;]/)
-end
-if a.size >= 2
-  @scanner.pos = ep unless ep.nil?
-  Word.parsed(select_captures(a))
-else
-  @scanner.pos = sp
-  false
-end
-            CODE
-        end
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:code) { ActionCode.new('|_| _.size') }
-
-    context 'given a list with an upper bound' do
-
-      let(:bounds) { [2, 4] }
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  sp = @scanner.pos
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless a.size < 4
-    break unless @scanner.skip(/[,;]/)
-  end
-  if a.size >= 2
-    @scanner.pos = ep unless ep.nil?
-    (select_captures(a).size)
-  else
-    @scanner.pos = sp
-    false
-  end
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-a = []
-sp = @scanner.pos
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless a.size < 4
-  break unless @scanner.skip(/[,;]/)
-end
-if a.size >= 2
-  @scanner.pos = ep unless ep.nil?
-  (select_captures(a).size)
-else
-  @scanner.pos = sp
-  false
-end
-            CODE
-        end
-      end
-    end
-
-    context 'given a list with no upper bound' do
-
-      let(:bounds) { [2, nil] }
-
-      context 'when nested' do
-        it 'generates nested list matching code with a dispatch action' do
-          nested_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-begin
-  a = []
-  sp = @scanner.pos
-  ep = nil
-  while r = @scanner.scan(/w+/)
-    ep = @scanner.pos
-    a << r
-    break unless @scanner.skip(/[,;]/)
-  end
-  if a.size >= 2
-    @scanner.pos = ep unless ep.nil?
-    (select_captures(a).size)
-  else
-    @scanner.pos = sp
-    false
-  end
-end
-            CODE
-        end
-      end
-
-      context 'when top-level' do
-        it 'generates top level list matching code with a dispatch action' do
-          top_level_code {|g| g.gen_direct_action list, code }.
-            should == (<<-CODE).strip
-a = []
-sp = @scanner.pos
-ep = nil
-while r = @scanner.scan(/w+/)
-  ep = @scanner.pos
-  a << r
-  break unless @scanner.skip(/[,;]/)
-end
-if a.size >= 2
-  @scanner.pos = ep unless ep.nil?
-  (select_captures(a).size)
-else
-  @scanner.pos = sp
-  false
-end
-            CODE
-        end
-      end
-    end
-  end
-
   describe '#gen_skip' do
 
     context 'given a list with no upper bound' do