rattler 0.4.2 → 0.5.0

data/spec/rattler/back_end/optimizer/simplify_redundant_repeat_spec.rb

@@ -10,215 +10,75 @@ describe SimplifyRedundantRepeat do
 
   describe '#apply' do
 
-    context 'given a zero-or-more' do
+    let(:outer) { Repeat[inner, *outer_bounds] }
+    let(:inner) { Repeat[match, *inner_bounds] }
+    let(:match) { Match[/a/]}
 
-      let(:parser) { ZeroOrMore[child] }
+    context 'given a repeat with one-or-more bounds of a repeat with one-or-more bounds' do
 
-      context 'with a zero-or-more' do
+      let(:outer_bounds) { [1, nil] }
+      let(:inner_bounds) { [1, nil] }
 
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        it 'returns the inner ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
-
-        it 'returns a ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with an optional' do
-
-        let(:child) { Optional[Match[/a/]] }
-
-        it 'returns a ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
+      it 'returns a repeat with one-or-more bounds' do
+        subject.apply(outer, matching).should == Repeat[match, 1, nil]
       end
     end
 
-    context 'given a one-or-more' do
-
-      let(:parser) { OneOrMore[child] }
-
-      context 'with a zero-or-more' do
-
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        it 'returns the inner ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
-
-        it 'returns the inner OneOrMore' do
-          subject.apply(parser, matching).should == OneOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with an optional' do
+    context 'given a repeat with optional bounds of a repeat with optional bounds' do
 
-        let(:child) { Optional[Match[/a/]] }
+      let(:outer_bounds) { [0, 1] }
+      let(:inner_bounds) { [0, 1] }
 
-        it 'returns a ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
+      it 'returns a repeat with one-or-more bounds' do
+        subject.apply(outer, matching).should == Repeat[match, 0, 1]
       end
     end
 
-    context 'given an optional' do
-
-      let(:parser) { Optional[child] }
-
-      context 'with a zero-or-more' do
-
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        it 'returns the inner ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
-
-        it 'returns a ZeroOrMore' do
-          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
-        end
-      end
-
-      context 'with an optional' do
+    context 'given a repeat with zero-or-more bounds of a repeat' do
 
-        let(:child) { Optional[Match[/a/]] }
+      let(:outer_bounds) { [0, nil] }
+      let(:inner_bounds) { [1, nil] }
 
-        it 'returns the inner Optional' do
-          subject.apply(parser, matching).should == Optional[Match[/a/]]
-        end
+      it 'returns a repeat with zero-or-more bounds' do
+        subject.apply(outer, matching).should == Repeat[match, 0, nil]
       end
     end
   end
 
   describe '#applies_to?' do
 
-    context 'given a zero-or-more' do
-
-      let(:parser) { ZeroOrMore[child] }
-
-      context 'with a zero-or-more' do
-
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        context 'in the :matching context' do
-          it 'returns true' do
-            subject.applies_to?(parser, matching).should be_true
-          end
-        end
-
-        context 'in the :capturing context' do
-          it 'returns false' do
-            subject.applies_to?(parser, capturing).should be_false
-          end
-        end
-      end
-
-      context 'with something other than a repeat' do
-
-        let(:child) { Match[/a/] }
+    context 'given a repeat of a repeat' do
 
-        it 'returns false' do
-          subject.applies_to?(parser, matching).should be_false
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
+      let(:parser) { Repeat[Repeat[Match[/a/], 1, nil], 0, nil] }
 
+      context 'in the :matching context' do
         it 'returns true' do
           subject.applies_to?(parser, matching).should be_true
         end
       end
 
-      context 'with an optional' do
-
-        let(:child) { Optional[Match[/a/]] }
-
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
+      context 'in the :capturing context' do
+        it 'returns false' do
+          subject.applies_to?(parser, capturing).should be_false
         end
       end
     end
 
-    context 'given a one-or-more' do
-
-      let(:parser) { OneOrMore[child] }
-
-      context 'with a zero-or-more' do
-
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
-
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
-      end
-
-      context 'with an optional' do
+    context 'given a repeat of something other than a repeat' do
 
-        let(:child) { Optional[Match[/a/]] }
+      let(:parser) { Repeat[Match[/a/], 2, 4] }
 
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
+      it 'returns false' do
+        subject.applies_to?(parser, capturing).should be_false
       end
     end
 
-    context 'given an optional' do
-
-      let(:parser) { Optional[child] }
-
-      context 'with a zero-or-more' do
-
-        let(:child) { ZeroOrMore[Match[/a/]] }
-
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
-      end
-
-      context 'with a one-or-more' do
-
-        let(:child) { OneOrMore[Match[/a/]] }
-
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
-      end
-
-      context 'with an optional' do
+    context 'given something other than a repeat' do
 
-        let(:child) { Optional[Match[/a/]] }
+      let(:parser) { Match[/a/] }
 
-        it 'returns true' do
-          subject.applies_to?(parser, matching).should be_true
-        end
+      it 'returns false' do
+        subject.applies_to?(parser, capturing).should be_false
       end
     end
   end

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

@@ -0,0 +1,149 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::ParserGenerator
+include Rattler::Parsers
+
+describe ESymbolGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  describe '#gen_basic' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code' do
+        nested_code {|g| g.gen_basic ESymbol[] }.should == 'true'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code' do
+        top_level_code {|g| g.gen_basic ESymbol[] }.should == 'true'
+      end
+    end
+  end
+
+  describe '#gen_assert' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code' do
+        nested_code {|g| g.gen_assert ESymbol[] }.should == 'true'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code' do
+        top_level_code {|g| g.gen_assert ESymbol[] }.should == 'true'
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+
+    context 'when nested' do
+      it 'generates nested eof disallowing code' do
+        nested_code {|g| g.gen_disallow ESymbol[] }.should == 'false'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof disallowing code' do
+        top_level_code {|g| g.gen_disallow ESymbol[] }.should == 'false'
+      end
+    end
+  end
+
+  describe '#gen_dispatch_action' do
+
+    let(:code) { NodeCode.new('Word', 'parsed') }
+
+    context 'when nested' do
+      it 'generates nested eof matching code with a dispatch action' do
+        nested_code {|g| g.gen_dispatch_action ESymbol[], code }.
+          should == 'Word.parsed([])'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code with a dispatch action' do
+        top_level_code {|g| g.gen_dispatch_action ESymbol[], code }.
+          should == 'Word.parsed([])'
+      end
+    end
+  end
+
+  describe '#gen_direct_action' do
+
+    let(:code) { ActionCode.new(':foo') }
+
+    context 'when nested' do
+      it 'generates nested eof matching code with a direct action' do
+        nested_code {|g| g.gen_direct_action ESymbol[], code }.
+          should == '(:foo)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code with a direct action' do
+        top_level_code {|g| g.gen_direct_action ESymbol[], code }.
+          should == ':foo'
+      end
+    end
+  end
+
+  describe '#gen_token' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code matching as ""' do
+        nested_code {|g| g.gen_token ESymbol[] }.
+          should == "''"
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code matching as ""' do
+        top_level_code {|g| g.gen_token ESymbol[] }.
+          should == "''"
+      end
+    end
+  end
+
+  describe '#gen_skip' do
+
+    context 'when nested' do
+      it 'generates nested eof skipping code' do
+        nested_code {|g| g.gen_skip ESymbol[] }.should == 'true'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof skipping code' do
+        top_level_code {|g| g.gen_skip ESymbol[] }.should == 'true'
+      end
+    end
+  end
+
+  describe '#gen_intermediate' do
+    it 'generates basic eof matching code' do
+      nested_code {|g| g.gen_intermediate ESymbol[] }.should == 'true'
+    end
+  end
+
+  describe '#gen_intermediate_assert' do
+    it 'generates intermediate eof matching code' do
+      nested_code {|g| g.gen_intermediate_assert ESymbol[] }.should == 'true'
+    end
+  end
+
+  describe '#gen_intermediate_disallow' do
+    it 'generates intermediate eof disallowing code' do
+      nested_code {|g| g.gen_intermediate_disallow ESymbol[] }.should == 'false'
+    end
+  end
+
+  describe '#gen_intermediate_skip' do
+    it 'generates intermediate eof skipping code' do
+      nested_code {|g| g.gen_intermediate_skip ESymbol[] }.should == 'true'
+    end
+  end
+
+end

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

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::ParserGenerator
+include Rattler::Parsers
+
+describe EofGenerator do
+
+  include ParserGeneratorSpecHelper
+
+  describe '#gen_basic' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code' do
+        nested_code {|g| g.gen_basic Eof[] }.should == '@scanner.eos?'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code' do
+        top_level_code {|g| g.gen_basic Eof[] }.should == '@scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_assert' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code' do
+        nested_code {|g| g.gen_assert Eof[] }.should == '@scanner.eos?'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code' do
+        top_level_code {|g| g.gen_assert Eof[] }.should == '@scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_disallow' do
+
+    context 'when nested' do
+      it 'generates nested eof disallowing code' do
+        nested_code {|g| g.gen_disallow Eof[] }.should == '(!@scanner.eos?)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof disallowing code' do
+        top_level_code {|g| g.gen_disallow Eof[] }.should == '!@scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_dispatch_action' do
+
+    let(:code) { NodeCode.new('Word', 'parsed') }
+
+    context 'when nested' do
+      it 'generates nested eof matching code with a dispatch action' do
+        nested_code {|g| g.gen_dispatch_action Eof[], code }.
+          should == '(Word.parsed([]) if @scanner.eos?)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code with a dispatch action' do
+        top_level_code {|g| g.gen_dispatch_action Eof[], code }.
+          should == 'Word.parsed([]) if @scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_direct_action' do
+
+    let(:code) { ActionCode.new(':eof') }
+
+    context 'when nested' do
+      it 'generates nested eof matching code with a direct action' do
+        nested_code {|g| g.gen_direct_action Eof[], code }.
+          should == '((:eof) if @scanner.eos?)'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code with a direct action' do
+        top_level_code {|g| g.gen_direct_action Eof[], code }.
+          should == '(:eof) if @scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_token' do
+
+    context 'when nested' do
+      it 'generates nested eof matching code matching as ""' do
+        nested_code {|g| g.gen_token Eof[] }.
+          should == "('' if @scanner.eos?)"
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof matching code matching as ""' do
+        top_level_code {|g| g.gen_token Eof[] }.
+          should == "'' if @scanner.eos?"
+      end
+    end
+  end
+
+  describe '#gen_skip' do
+
+    context 'when nested' do
+      it 'generates nested eof skipping code' do
+        nested_code {|g| g.gen_skip Eof[] }.should == '@scanner.eos?'
+      end
+    end
+
+    context 'when top-level' do
+      it 'generates top level eof skipping code' do
+        top_level_code {|g| g.gen_skip Eof[] }.should == '@scanner.eos?'
+      end
+    end
+  end
+
+  describe '#gen_intermediate' do
+    it 'generates basic eof matching code' do
+      nested_code {|g| g.gen_intermediate Eof[] }.should == '@scanner.eos?'
+    end
+  end
+
+  describe '#gen_intermediate_assert' do
+    it 'generates intermediate eof matching code' do
+      nested_code {|g| g.gen_intermediate_assert Eof[] }.
+        should == '@scanner.eos?'
+    end
+  end
+
+  describe '#gen_intermediate_disallow' do
+    it 'generates intermediate eof disallowing code' do
+      nested_code {|g| g.gen_intermediate_disallow Eof[] }.
+        should == '(!@scanner.eos?)'
+    end
+  end
+
+  describe '#gen_intermediate_skip' do
+    it 'generates intermediate eof skipping code' do
+      nested_code {|g| g.gen_intermediate_skip Eof[] }.
+        should == '@scanner.eos?'
+    end
+  end
+
+end