rattler 0.4.2 → 0.5.0

data/spec/rattler/back_end/parser_generator/list_generator_spec.rb

@@ -1,126 +1,413 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/list0_generator_examples')
+require File.expand_path(File.dirname(__FILE__) + '/list1_generator_examples')
 
-include Rattler::BackEnd::ParserGenerator
 include Rattler::Parsers
 
-describe ListGenerator do
+describe Rattler::BackEnd::ParserGenerator::ListGenerator do
 
   include ParserGeneratorSpecHelper
 
-  let(:list) { List0[Match[/w+/], Match[/[,;]/]] }
+  let(:list) { ListParser[term_parser, sep_parser, *bounds] }
+
+  it_behaves_like 'a list0 generator'
+  it_behaves_like 'a list1 generator'
+
+  let(:term_parser) { Match[/w+/] }
+  let(:sep_parser) { Match[/[,;]/] }
 
   describe '#gen_basic' do
 
-    let :list do
-      List0[Choice[Match[/[[:alpha:]]/], Match[/[[:digit:]]/]], Match[/[,;]/]]
-    end
+    let(:term_parser) { Choice[Match[/[[:alpha:]]/], Match[/[[:digit:]]/]] }
+
+    context 'given a list with no upper bound' do
+
+      let(:bounds) { [2, nil] }
 
-    context 'when nested' do
-      it 'generates nested list matching code' do
-        nested_code {|g| g.gen_basic list }.
-          should == (<<-CODE).strip
+      context 'when nested' do
+        it 'generates nested list matching code' do
+          nested_code {|g| g.gen_basic list }.
+            should == (<<-CODE).strip
 begin
   a = []
-  lp = nil
+  sp = @scanner.pos
+  ep = nil
   while r = begin
     @scanner.scan(/[[:alpha:]]/) ||
     @scanner.scan(/[[:digit:]]/)
   end
-    lp = @scanner.pos
+    ep = @scanner.pos
     a << r
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
-  a
+  if a.size >= 2
+    @scanner.pos = ep unless ep.nil?
+    a
+  else
+    @scanner.pos = sp
+    false
+  end
 end
-          CODE
+            CODE
+        end
       end
-    end
 
-    context 'when top-level' do
-      it 'generates top-level list matching code' do
-        top_level_code {|g| g.gen_basic list }.
-          should == (<<-CODE).strip
+      context 'when top-level' do
+        it 'generates top-level list matching code' do
+          top_level_code {|g| g.gen_basic list }.
+            should == (<<-CODE).strip
 a = []
-lp = nil
+sp = @scanner.pos
+ep = nil
 while r = begin
   @scanner.scan(/[[:alpha:]]/) ||
   @scanner.scan(/[[:digit:]]/)
 end
-  lp = @scanner.pos
+  ep = @scanner.pos
   a << r
   break unless @scanner.skip(/[,;]/)
 end
-@scanner.pos = lp unless lp.nil?
-a
-          CODE
+if a.size >= 2
+  @scanner.pos = ep unless ep.nil?
+  a
+else
+  @scanner.pos = sp
+  false
+end
+            CODE
+        end
       end
     end
 
-    context 'with a non-capturing parser' do
+    context 'given a list with an upper bound' do
 
-      let(:list) { List0[Skip[Match[/w+/]], Match[/[,;]/]] }
+      let(:bounds) { [2, 4] }
 
       context 'when nested' do
-        it 'generates nested list skipping code' do
+        it 'generates nested list matching code' do
           nested_code {|g| g.gen_basic list }.
             should == (<<-CODE).strip
 begin
-  lp = nil
-  while @scanner.skip(/w+/)
-    lp = @scanner.pos
+  a = []
+  sp = @scanner.pos
+  ep = nil
+  while r = begin
+    @scanner.scan(/[[:alpha:]]/) ||
+    @scanner.scan(/[[:digit:]]/)
+  end
+    ep = @scanner.pos
+    a << r
+    break unless a.size < 4
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
-  true
+  if a.size >= 2
+    @scanner.pos = ep unless ep.nil?
+    a
+  else
+    @scanner.pos = sp
+    false
+  end
 end
             CODE
         end
       end
 
       context 'when top-level' do
-        it 'generates nested list skipping code' do
+        it 'generates top-level list matching code' do
           top_level_code {|g| g.gen_basic list }.
             should == (<<-CODE).strip
-lp = nil
-while @scanner.skip(/w+/)
-  lp = @scanner.pos
+a = []
+sp = @scanner.pos
+ep = nil
+while r = begin
+  @scanner.scan(/[[:alpha:]]/) ||
+  @scanner.scan(/[[:digit:]]/)
+end
+  ep = @scanner.pos
+  a << r
+  break unless a.size < 4
   break unless @scanner.skip(/[,;]/)
 end
-@scanner.pos = lp unless lp.nil?
-true
+if a.size >= 2
+  @scanner.pos = ep unless ep.nil?
+  a
+else
+  @scanner.pos = sp
+  false
+end
             CODE
         end
       end
     end
+
+    context 'given a non-capturing list' do
+
+      let(:term_parser) { Skip[Match[/w+/]] }
+
+      context 'with no upper bound' do
+
+        let(:bounds) { [2, nil] }
+
+        context 'when nested' do
+          it 'generates nested list skipping code' do
+            nested_code {|g| g.gen_basic list }.
+              should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  ep = nil
+  while @scanner.skip(/w+/)
+    c += 1
+    ep = @scanner.pos
+    break unless @scanner.skip(/[,;]/)
+  end
+  if c >= 2
+    @scanner.pos = ep unless ep.nil?
+    true
+  else
+    @scanner.pos = sp
+    false
+  end
+end
+              CODE
+          end
+        end
+
+        context 'when top-level' do
+          it 'generates top-level list skipping code' do
+            top_level_code {|g| g.gen_basic list }.
+              should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+ep = nil
+while @scanner.skip(/w+/)
+  c += 1
+  ep = @scanner.pos
+  break unless @scanner.skip(/[,;]/)
+end
+if c >= 2
+  @scanner.pos = ep unless ep.nil?
+  true
+else
+  @scanner.pos = sp
+  false
+end
+              CODE
+          end
+        end
+      end
+
+      context 'with an upper bound' do
+
+        let(:bounds) { [2, 4] }
+
+        context 'when nested' do
+          it 'generates nested list skipping code' do
+            nested_code {|g| g.gen_basic list }.
+              should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  ep = nil
+  while @scanner.skip(/w+/)
+    c += 1
+    ep = @scanner.pos
+    break unless c < 4
+    break unless @scanner.skip(/[,;]/)
+  end
+  if c >= 2
+    @scanner.pos = ep unless ep.nil?
+    true
+  else
+    @scanner.pos = sp
+    false
+  end
+end
+              CODE
+          end
+        end
+
+        context 'when top-level' do
+          it 'generates top-level list skipping code' do
+            top_level_code {|g| g.gen_basic list }.
+              should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+ep = nil
+while @scanner.skip(/w+/)
+  c += 1
+  ep = @scanner.pos
+  break unless c < 4
+  break unless @scanner.skip(/[,;]/)
+end
+if c >= 2
+  @scanner.pos = ep unless ep.nil?
+  true
+else
+  @scanner.pos = sp
+  false
+end
+              CODE
+          end
+        end
+      end
+    end
   end
 
   describe '#gen_assert' do
 
-    context 'when nested' do
-      it 'generates "true"' do
-        nested_code {|g| g.gen_assert list }.should == 'true'
+    context 'given a list with no upper bound' do
+
+      let(:bounds) { [2, nil] }
+
+      context 'when nested' do
+        it 'generates nested positive lookahead code' do
+          nested_code {|g| g.gen_assert list }.should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+    break unless @scanner.skip(/[,;]/)
+  end
+  @scanner.pos = sp
+  c >= 2
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level positive lookahead code' do
+          top_level_code {|g| g.gen_assert list }.should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+  break unless @scanner.skip(/[,;]/)
+end
+@scanner.pos = sp
+c >= 2
+          CODE
+        end
       end
     end
 
-    context 'when top-level' do
-      it 'generates "true"' do
-        top_level_code {|g| g.gen_assert list }.should == 'true'
+    context 'given a list with an upper bound' do
+
+      let(:bounds) { [2, 4] }
+
+      context 'when nested' do
+        it 'generates nested positive lookahead code' do
+          nested_code {|g| g.gen_assert list }.should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+    break unless c < 4
+    break unless @scanner.skip(/[,;]/)
+  end
+  @scanner.pos = sp
+  c >= 2
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level positive lookahead code' do
+          top_level_code {|g| g.gen_assert list }.should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+  break unless c < 4
+  break unless @scanner.skip(/[,;]/)
+end
+@scanner.pos = sp
+c >= 2
+          CODE
+        end
       end
     end
   end
 
   describe '#gen_disallow' do
 
-    context 'when nested' do
-      it 'generates "false"' do
-        nested_code {|g| g.gen_disallow list }.should == 'false'
+    context 'given a list with no upper bound' do
+
+      let(:bounds) { [2, nil] }
+
+      context 'when nested' do
+        it 'generates nested negative lookahead code' do
+          nested_code {|g| g.gen_disallow list }.should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+    break unless @scanner.skip(/[,;]/)
+  end
+  @scanner.pos = sp
+  c < 2
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level negative lookahead code' do
+          top_level_code {|g| g.gen_disallow list }.should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+  break unless @scanner.skip(/[,;]/)
+end
+@scanner.pos = sp
+c < 2
+          CODE
+        end
       end
     end
 
-    context 'when top-level' do
-      it 'generates "false"' do
-        top_level_code {|g| g.gen_disallow list }.should == 'false'
+    context 'given a list with an upper bound' do
+
+      let(:bounds) { [2, 4] }
+
+      context 'when nested' do
+        it 'generates nested negative lookahead code' do
+          nested_code {|g| g.gen_disallow list }.should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+    break unless c < 4
+    break unless @scanner.skip(/[,;]/)
+  end
+  @scanner.pos = sp
+  c < 2
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level negative lookahead code' do
+          top_level_code {|g| g.gen_disallow list }.should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+  break unless c < 4
+  break unless @scanner.skip(/[,;]/)
+end
+@scanner.pos = sp
+c < 2
+          CODE
+        end
       end
     end
   end
@@ -129,164 +416,334 @@ true
 
     let(:code) { NodeCode.new('Word', 'parsed') }
 
-    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
+    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 = []
-  lp = nil
+  sp = @scanner.pos
+  ep = nil
   while r = @scanner.scan(/w+/)
-    lp = @scanner.pos
+    ep = @scanner.pos
     a << r
+    break unless a.size < 4
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
-  Word.parsed(select_captures(a))
+  if a.size >= 2
+    @scanner.pos = ep unless ep.nil?
+    Word.parsed(select_captures(a))
+  else
+    @scanner.pos = sp
+    false
+  end
 end
-          CODE
+            CODE
+        end
       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
+      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 = []
-lp = nil
+sp = @scanner.pos
+ep = nil
 while r = @scanner.scan(/w+/)
-  lp = @scanner.pos
+  ep = @scanner.pos
   a << r
+  break unless a.size < 4
   break unless @scanner.skip(/[,;]/)
 end
-@scanner.pos = lp unless lp.nil?
-Word.parsed(select_captures(a))
-          CODE
+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
+    context 'given a list with no upper bound' do
 
-    let(:code) { ActionCode.new('|_| _.size') }
+      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
+      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 = []
-  lp = nil
+  sp = @scanner.pos
+  ep = nil
   while r = @scanner.scan(/w+/)
-    lp = @scanner.pos
+    ep = @scanner.pos
     a << r
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
-  (select_captures(a).size)
+  if a.size >= 2
+    @scanner.pos = ep unless ep.nil?
+    Word.parsed(select_captures(a))
+  else
+    @scanner.pos = sp
+    false
+  end
 end
-          CODE
+            CODE
+        end
       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
+      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 = []
-lp = nil
+sp = @scanner.pos
+ep = nil
 while r = @scanner.scan(/w+/)
-  lp = @scanner.pos
+  ep = @scanner.pos
   a << r
   break unless @scanner.skip(/[,;]/)
 end
-@scanner.pos = lp unless lp.nil?
-(select_captures(a).size)
-          CODE
+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_skip' do
+  describe '#gen_direct_action' do
+
+    let(:code) { ActionCode.new('|_| _.size') }
 
-    context 'when nested' do
-      it 'generates nested list skipping code' do
-        nested_code {|g| g.gen_skip list }.
-          should == (<<-CODE).strip
+    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
-  lp = nil
-  while @scanner.skip(/w+/)
-    lp = @scanner.pos
+  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
-  @scanner.pos = lp unless lp.nil?
-  true
+  if a.size >= 2
+    @scanner.pos = ep unless ep.nil?
+    (select_captures(a).size)
+  else
+    @scanner.pos = sp
+    false
+  end
 end
-          CODE
+            CODE
+        end
       end
-    end
 
-    context 'when top-level' do
-      it 'generates top-level list skipping code' do
-        top_level_code {|g| g.gen_skip list }.
-          should == (<<-CODE).strip
-lp = nil
-while @scanner.skip(/w+/)
-  lp = @scanner.pos
+      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
-@scanner.pos = lp unless lp.nil?
-true
-          CODE
+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_intermediate' do
-    it 'generates nested list matching code' do
-      nested_code {|g| g.gen_intermediate list }.
-        should == (<<-CODE).strip
+    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 = []
-  lp = nil
+  sp = @scanner.pos
+  ep = nil
   while r = @scanner.scan(/w+/)
-    lp = @scanner.pos
+    ep = @scanner.pos
     a << r
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
-  a
+  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
-        CODE
+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_intermediate_assert' do
-    it 'generates "true"' do
-      nested_code {|g| g.gen_intermediate_assert list }.should == 'true'
-    end
+  describe '#gen_skip' do
+
+    context 'given a list with no upper bound' do
+
+      let(:bounds) { [2, nil] }
+
+      context 'when nested' do
+        it 'generates nested list skipping code' do
+          nested_code {|g| g.gen_skip list }.should == (<<-CODE).strip
+begin
+  c = 0
+  sp = @scanner.pos
+  ep = nil
+  while @scanner.skip(/w+/)
+    c += 1
+    ep = @scanner.pos
+    break unless @scanner.skip(/[,;]/)
+  end
+  if c >= 2
+    @scanner.pos = ep unless ep.nil?
+    true
+  else
+    @scanner.pos = sp
+    false
   end
+end
+            CODE
+        end
+      end
 
-  describe '#gen_intermediate_disallow' do
-    it 'generates "false"' do
-      nested_code {|g| g.gen_intermediate_disallow list }.should == 'false'
+      context 'when top-level' do
+        it 'generates top-level list skipping code' do
+          top_level_code {|g| g.gen_skip list }.should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+ep = nil
+while @scanner.skip(/w+/)
+  c += 1
+  ep = @scanner.pos
+  break unless @scanner.skip(/[,;]/)
+end
+if c >= 2
+  @scanner.pos = ep unless ep.nil?
+  true
+else
+  @scanner.pos = sp
+  false
+end
+            CODE
+        end
+      end
     end
-  end
 
-  describe '#gen_intermediate_skip' do
-    it 'generates nested list skipping code' do
-      nested_code {|g| g.gen_intermediate_skip list }.
-        should == (<<-CODE).strip
+    context 'given a list with an upper bound' do
+
+      let(:bounds) { [2, 4] }
+
+      context 'when nested' do
+        it 'generates nested list skipping code' do
+          nested_code {|g| g.gen_skip list }.
+            should == (<<-CODE).strip
 begin
-  lp = nil
+  c = 0
+  sp = @scanner.pos
+  ep = nil
   while @scanner.skip(/w+/)
-    lp = @scanner.pos
+    c += 1
+    ep = @scanner.pos
+    break unless c < 4
     break unless @scanner.skip(/[,;]/)
   end
-  @scanner.pos = lp unless lp.nil?
+  if c >= 2
+    @scanner.pos = ep unless ep.nil?
+    true
+  else
+    @scanner.pos = sp
+    false
+  end
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top-level list skipping code' do
+          top_level_code {|g| g.gen_skip list }.
+            should == (<<-CODE).strip
+c = 0
+sp = @scanner.pos
+ep = nil
+while @scanner.skip(/w+/)
+  c += 1
+  ep = @scanner.pos
+  break unless c < 4
+  break unless @scanner.skip(/[,;]/)
+end
+if c >= 2
+  @scanner.pos = ep unless ep.nil?
   true
+else
+  @scanner.pos = sp
+  false
 end
-        CODE
+            CODE
+        end
+      end
     end
   end