rattler 0.4.2 → 0.5.0

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

@@ -0,0 +1,281 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/zero_or_more_generator_examples')
+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::Parsers
+
+describe RepeatGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  let(:repeat) { Repeat[nested, *bounds] }
+
+  it_behaves_like 'a zero-or-more generator'
+  it_behaves_like 'a one-or-more generator'
+  it_behaves_like 'an optional generator'
+
+  describe '#gen_basic' do
+
+    context 'with an upper bound' do
+
+      let(:bounds) { [2, 4] }
+      let(:nested) { Match[/w+/] }
+
+      context 'when nested' do
+        it 'generates nested repeat matching code' do
+          nested_code {|g| g.gen_basic repeat }.should == (<<-CODE).strip
+begin
+  a = []
+  rp = @scanner.pos
+  while r = @scanner.scan(/\w+/)
+    a << r
+    break if a.size >= 4
+  end
+  if a.size >= 2
+    a
+  else
+    @scanner.pos = rp
+    false
+  end
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates nested repeat matching code' do
+          top_level_code {|g| g.gen_basic repeat }.should == (<<-CODE).strip
+a = []
+rp = @scanner.pos
+while r = @scanner.scan(/\w+/)
+  a << r
+  break if a.size >= 4
+end
+if a.size >= 2
+  a
+else
+  @scanner.pos = rp
+  false
+end
+          CODE
+        end
+      end
+    end
+
+    context 'with no upper bound' do
+
+      let(:bounds) { [2, nil] }
+      let(:nested) { Match[/w+/] }
+
+      context 'when nested' do
+        it 'generates nested repeat matching code' do
+          nested_code {|g| g.gen_basic repeat }.should == (<<-CODE).strip
+begin
+  a = []
+  rp = @scanner.pos
+  while r = @scanner.scan(/\w+/)
+    a << r
+  end
+  if a.size >= 2
+    a
+  else
+    @scanner.pos = rp
+    false
+  end
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates nested repeat matching code' do
+          top_level_code {|g| g.gen_basic repeat }.should == (<<-CODE).strip
+a = []
+rp = @scanner.pos
+while r = @scanner.scan(/\w+/)
+  a << r
+end
+if a.size >= 2
+  a
+else
+  @scanner.pos = rp
+  false
+end
+          CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_assert' do
+
+    let(:bounds) { [2, 4] }
+    let(:nested) { Match[/w+/] }
+
+    context 'when nested' do
+      it 'generates nested repeat positive lookahead code' do
+        nested_code {|g| g.gen_assert repeat }.should == (<<-CODE).strip
+begin
+  c = 0
+  rp = @scanner.pos
+  while @scanner.skip(/\w+/)
+    c += 1
+    break if c >= 2
+  end
+  @scanner.pos = rp
+  (c >= 2)
+end
+        CODE
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level repeat positive lookahead code' do
+        top_level_code {|g| g.gen_assert repeat }.should == (<<-CODE).strip
+c = 0
+rp = @scanner.pos
+while @scanner.skip(/\w+/)
+  c += 1
+  break if c >= 2
+end
+@scanner.pos = rp
+(c >= 2)
+        CODE
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+
+    let(:bounds) { [2, 4] }
+    let(:nested) { Match[/w+/] }
+
+    context 'when nested' do
+      it 'generates nested repeat negative lookahead code' do
+        nested_code {|g| g.gen_disallow repeat }.should == (<<-CODE).strip
+begin
+  c = 0
+  rp = @scanner.pos
+  while @scanner.skip(/\w+/)
+    c += 1
+    break if c >= 2
+  end
+  @scanner.pos = rp
+  (c < 2)
+end
+        CODE
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level repeat negative lookahead code' do
+        top_level_code {|g| g.gen_disallow repeat }.should == (<<-CODE).strip
+c = 0
+rp = @scanner.pos
+while @scanner.skip(/\w+/)
+  c += 1
+  break if c >= 2
+end
+@scanner.pos = rp
+(c < 2)
+        CODE
+      end
+    end
+  end
+
+  describe '#gen_skip' do
+
+    context 'with an upper bound' do
+
+      let(:bounds) { [2, 4] }
+      let(:nested) { Match[/w+/] }
+
+      context 'when nested' do
+        it 'generates nested repeat skipping code' do
+          nested_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+begin
+  c = 0
+  rp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+    break if c >= 4
+  end
+  if c >= 2
+    true
+  else
+    @scanner.pos = rp
+    false
+  end
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level repeat skipping code' do
+          top_level_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+c = 0
+rp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+  break if c >= 4
+end
+if c >= 2
+  true
+else
+  @scanner.pos = rp
+  false
+end
+          CODE
+        end
+      end
+    end
+
+    context 'with no upper bound' do
+
+      let(:bounds) { [2, nil] }
+      let(:nested) { Match[/w+/] }
+
+      context 'when nested' do
+        it 'generates nested repeat skipping code' do
+          nested_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+begin
+  c = 0
+  rp = @scanner.pos
+  while @scanner.skip(/w+/)
+    c += 1
+  end
+  if c >= 2
+    true
+  else
+    @scanner.pos = rp
+    false
+  end
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level repeat skipping code' do
+          top_level_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+c = 0
+rp = @scanner.pos
+while @scanner.skip(/w+/)
+  c += 1
+end
+if c >= 2
+  true
+else
+  @scanner.pos = rp
+  false
+end
+          CODE
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,277 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+shared_examples_for 'a zero-or-more generator' do
+
+  let(:bounds) { [0, nil] }
+  let(:nested) { Match[/w+/] }
+
+  describe '#gen_basic' do
+
+    let(:nested) { Choice[Match[/[[:alpha:]]/], Match[/[[:digit:]]/]] }
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates nested zero-or-more matching code' do
+          nested_code {|g| g.gen_basic repeat }.
+            should == (<<-CODE).strip
+begin
+  a = []
+  while r = begin
+    @scanner.scan(/[[:alpha:]]/) ||
+    @scanner.scan(/[[:digit:]]/)
+  end
+    a << r
+  end
+  a
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level zero-or-more matching code' do
+          top_level_code {|g| g.gen_basic repeat }.
+            should == (<<-CODE).strip
+a = []
+while r = begin
+  @scanner.scan(/[[:alpha:]]/) ||
+  @scanner.scan(/[[:digit:]]/)
+end
+  a << r
+end
+a
+            CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_assert' do
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates "true"' do
+          nested_code {|g| g.gen_assert repeat }.should == 'true'
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates "true"' do
+          top_level_code {|g| g.gen_assert repeat }.should == 'true'
+        end
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates "false"' do
+          nested_code {|g| g.gen_disallow repeat }.should == 'false'
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates "false"' do
+          top_level_code {|g| g.gen_disallow repeat }.should == 'false'
+        end
+      end
+    end
+  end
+
+  describe '#gen_dispatch_action' do
+
+    let(:nested) { Match[/w+/] }
+    let(:code) { NodeCode.new('Word', 'parsed') }
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates nested zero-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))
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level zero-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))
+            CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_direct_action' do
+
+    let(:nested) { Match[/w+/] }
+    let(:code) { ActionCode.new('|_| _.size') }
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates nested zero-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)
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level zero-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)
+            CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_token' do
+
+    let(:nested) { Match[/w+/] }
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates nested zero-or-more matching code' do
+          nested_code {|g| g.gen_token repeat }.
+            should == (<<-CODE).strip
+begin
+  a = []
+  while r = @scanner.scan(/w+/)
+    a << r
+  end
+  a.join
+end
+            CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level zero-or-more matching code' do
+          top_level_code {|g| g.gen_token repeat }.
+            should == (<<-CODE).strip
+a = []
+while r = @scanner.scan(/w+/)
+  a << r
+end
+a.join
+            CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_skip' do
+
+    let(:nested) { Match[/w+/] }
+
+    context 'given a repeat with zero-or-more bounds' do
+
+      context 'when nested' do
+        it 'generates nested zero-or-more skipping code' do
+          nested_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+begin
+  while @scanner.skip(/w+/); end
+  true
+end
+          CODE
+        end
+      end
+
+      context 'when top-level' do
+        it 'generates top level zero-or-more skipping code' do
+          top_level_code {|g| g.gen_skip repeat }.should == (<<-CODE).strip
+while @scanner.skip(/w+/); end
+true
+          CODE
+        end
+      end
+    end
+  end
+
+  describe '#gen_intermediate' do
+
+    let(:nested) { Match[/w+/] }
+
+    context 'given a repeat with zero-or-more bounds' do
+      it 'generates nested zero-or-more matching code' do
+        nested_code {|g| g.gen_intermediate repeat }.
+          should == (<<-CODE).strip
+begin
+  a = []
+  while r = @scanner.scan(/w+/)
+    a << r
+  end
+  a
+end
+          CODE
+      end
+    end
+  end
+
+  describe '#gen_intermediate_assert' do
+    context 'given a repeat with zero-or-more bounds' do
+      it 'generates "true"' do
+        nested_code {|g| g.gen_intermediate_assert repeat }.should == 'true'
+      end
+    end
+  end
+
+  describe '#gen_intermediate_disallow' do
+    context 'given a repeat with zero-or-more bounds' do
+      it 'generates "false"' do
+        nested_code {|g| g.gen_intermediate_disallow repeat }.should == 'false'
+      end
+    end
+  end
+
+  describe '#gen_intermediate_skip' do
+
+    let(:nested) { Match[/w+/] }
+
+    context 'given a repeat with zero-or-more bounds' do
+      it 'generates nested zero-or-more skipping code' do
+        nested_code {|g| g.gen_intermediate_skip repeat }.
+          should == (<<-CODE).strip
+begin
+  while @scanner.skip(/w+/); end
+  true
+end
+          CODE
+      end
+    end
+  end
+
+end