rattler 0.5.0 → 0.6.0

data/spec/rattler/{back_end → compiler}/optimizer/flatten_choice_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::Optimizer::FlattenChoice do
+describe Rattler::Compiler::Optimizer::FlattenChoice do
 
   describe '#apply' do
 

data/spec/rattler/{back_end → compiler}/optimizer/flatten_sequence_spec.rb

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

data/spec/rattler/compiler/optimizer/inline_regular_rules_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Compiler::Optimizer
+include Rattler::Parsers
+
+describe InlineRegularRules do
+
+  let(:context) { OptimizationContext[
+    :type => :capturing,
+    :rules => rule_set
+  ] }
+
+  let(:rule_set) { RuleSet[rule_a, {:start_rule => :a}] }
+
+  describe '#apply' do
+
+    context 'given a reference to a regular rule' do
+
+      let(:rule_a) { Rule[:a, Match[/a/], {:inline => true}] }
+
+      it 'inlines the regular rule' do
+        subject.apply(Apply[:a], context).should == Match[/a/]
+      end
+    end
+  end
+
+  describe '#_applies_to?' do
+
+    context 'given a reference to a regular rule' do
+
+      context 'tagged as :inline' do
+
+        let(:rule_a) { Rule[:a, Match[/a/], {:inline => true}] }
+
+        it 'returns true' do
+          subject.applies_to?(Apply[:a], context).should be_true
+        end
+      end
+
+      context 'not tagged as :inline' do
+
+        let(:rule_a) { Rule[:a, Match[/a/]] }
+
+        it 'returns false' do
+          subject.applies_to?(Apply[:a], context).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/rattler/{back_end → compiler}/optimizer/join_match_capturing_sequence_spec.rb

@@ -1,8 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
-include Rattler::BackEnd::Optimizer
+include Rattler::Compiler::Optimizer
 include Rattler::Parsers
-include Rattler::BackEnd::ParserGenerator
+include Rattler::Compiler::ParserGenerator
 
 describe JoinMatchCapturingSequence do
 
@@ -104,27 +104,65 @@ describe JoinMatchCapturingSequence do
 
     context 'given a sequence of matches followed by something else' do
 
-      let(:sequence) { Sequence[
-        Match[/a/],
-        Match[/b/],
-        Apply[:c]
-      ] }
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], something_else] }
 
-      it 'returns true' do
-        subject.applies_to?(sequence, capturing).should be_true
+      context 'if the something else is non-capturing' do
+
+        let(:something_else) { Skip[Apply[:c]] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+
+      context 'if the something else is capturing' do
+
+        let(:something_else) { Apply[:c] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+
+      context 'if the something else is a semantic action' do
+
+        let(:something_else) { Skip[SemanticAction['_.join']] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
       end
     end
 
     context 'given a sequence of matches following something else' do
 
-      let(:sequence) { Sequence[
-        Apply[:a],
-        Match[/b/],
-        Match[/c/]
-      ] }
+      let(:sequence) { Sequence[something_else, Match[/b/], Match[/c/]] }
 
-      it 'returns true' do
-        subject.applies_to?(sequence, capturing).should be_true
+      context 'if the something else is non-capturing' do
+
+        let(:something_else) { Skip[Apply[:a]] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+
+      context 'if the something else is capturing' do
+
+        let(:something_else) { Apply[:a] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+
+      context 'if the something else is a semantic action' do
+
+        let(:something_else) { Skip[SemanticAction['_.join']] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
       end
     end
 
@@ -159,24 +197,70 @@ describe JoinMatchCapturingSequence do
       let(:sequence) { Sequence[
         GroupMatch[Match[/a/], {:num_groups => 1}],
         GroupMatch[Match[/b/], {:num_groups => 1}],
-        Apply[:c]
+        something_else
       ] }
 
-      it 'returns true' do
-        subject.applies_to?(sequence, capturing).should be_true
+      context 'if the something else is non-capturing' do
+
+        let(:something_else) { Skip[Apply[:c]] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+
+      context 'if the something else is capturing' do
+
+        let(:something_else) { Apply[:c] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+
+      context 'if the something else is a semantic action' do
+
+        let(:something_else) { Skip[SemanticAction['_.join']] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
       end
     end
 
     context 'given a sequence of single-group matches following something else' do
 
       let(:sequence) { Sequence[
-        Apply[:a],
+        something_else,
         GroupMatch[Match[/b/], {:num_groups => 1}],
         GroupMatch[Match[/c/], {:num_groups => 1}]
       ] }
 
-      it 'returns true' do
-        subject.applies_to?(sequence, capturing).should be_true
+      context 'if the something else is non-capturing' do
+
+        let(:something_else) { Skip[Apply[:a]] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+
+      context 'if the something else is capturing' do
+
+        let(:something_else) { Apply[:a] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+
+      context 'if the something else is a semantic action' do
+
+        let(:something_else) { Skip[SemanticAction['_.join']] }
+
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
       end
     end
 

data/spec/rattler/{back_end → compiler}/optimizer/join_match_choice_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::Optimizer::JoinMatchChoice do
+describe Rattler::Compiler::Optimizer::JoinMatchChoice do
 
   describe '#apply' do
 

data/spec/rattler/{back_end → compiler}/optimizer/join_match_matching_sequence_spec.rb

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

data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_bare_match_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::Optimizer::JoinPredicateBareMatch do
+describe Rattler::Compiler::Optimizer::JoinPredicateBareMatch do
 
   describe '#apply' do
 

data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_nested_match_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::Optimizer::JoinPredicateNestedMatch do
+describe Rattler::Compiler::Optimizer::JoinPredicateNestedMatch do
 
   let(:skip) { Skip[Match[/a/]] }
   let(:token) { Token[Match[/a/]] }

data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_or_bare_match_spec.rb

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

data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_or_nested_match_spec.rb

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

data/spec/rattler/{back_end → compiler}/optimizer/reduce_repeat_match_spec.rb

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

data/spec/rattler/compiler/optimizer/remove_meaningless_wrapper_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Compiler::Optimizer
+include Rattler::Parsers
+
+describe RemoveMeaninglessWrapper do
+
+  let(:matching) { OptimizationContext[:type => :matching] }
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+
+  describe '#apply' do
+    context 'in the matching context' do
+
+      context 'given a token parser' do
+
+        let(:token) { Token[Sequence[Match[/a/], Match[/b/]]] }
+
+        it 'returns the nested parser' do
+          subject.apply(token, matching).should ==
+            Sequence[Match[/a/], Match[/b/]]
+        end
+      end
+
+      context 'given a skip parser' do
+
+        let(:skip) { Skip[Match[/\s+/]] }
+
+        it 'returns the nested parser' do
+          subject.apply(skip, matching).should == Match[/\s+/]
+        end
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a token parser' do
+
+      let(:token) { Token[Sequence[Match[/a/], Match[/b/]]] }
+
+      context 'in the matching context' do
+        it 'returns true' do
+          subject.applies_to?(token, matching).should be_true
+        end
+      end
+
+      context 'in the capturing context' do
+        it 'returns false' do
+          subject.applies_to?(token, capturing).should be_false
+        end
+      end
+    end
+
+    context 'given a skip parser' do
+
+      let(:skip) { Skip[Match[/\s+/]] }
+
+      context 'in the matching context' do
+        it 'returns true' do
+          subject.applies_to?(skip, matching).should be_true
+        end
+      end
+
+      context 'in the capturing context' do
+        it 'returns false' do
+          subject.applies_to?(skip, capturing).should be_false
+        end
+      end
+    end
+
+    context 'given another type of parser' do
+
+      let(:predicate) { Assert[Match[/\s+/]] }
+
+      context 'in the matching context' do
+        it 'returns false' do
+          subject.applies_to?(predicate, matching).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/rattler/{back_end → compiler}/optimizer/simplify_redundant_repeat_spec.rb

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

data/spec/rattler/{back_end → compiler}/optimizer/simplify_token_match_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 include Rattler::Parsers
 
-describe Rattler::BackEnd::Optimizer::SimplifyTokenMatch do
+describe Rattler::Compiler::Optimizer::SimplifyTokenMatch do
 
   describe '#apply' do
 

data/spec/rattler/{back_end → compiler}/optimizer_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/shared_compiler_examples')
 
-describe Rattler::BackEnd::Optimizer do
+describe Rattler::Compiler::Optimizer do
   include CompilerSpecHelper
 
   describe '.optimize result' do

data/spec/rattler/{back_end → compiler}/parser_generator/apply_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 ApplyGenerator do
@@ -84,44 +84,6 @@ r
     end
   end
 
-  describe '#gen_dispatch_action' do
-
-    let(:code) { NodeCode.new('Word', 'parsed') }
-
-    context 'when nested' do
-      it 'generates nested apply-rule code with a dispatch action' do
-        nested_code {|g| g.gen_dispatch_action apply, code }.
-          should == '((r = match(:foo)) && Word.parsed([r]))'
-      end
-    end
-
-    context 'when top-level' do
-      it 'generates top level apply-rule code with a dispatch action' do
-        top_level_code {|g| g.gen_dispatch_action apply, code }.
-          should == '(r = match(:foo)) && Word.parsed([r])'
-      end
-    end
-  end
-
-  describe '#gen_direct_action' do
-
-    let(:code) { ActionCode.new('|_| _.to_sym') }
-
-    context 'when nested' do
-      it 'generates nested apply-rule code with a direct action' do
-        nested_code {|g| g.gen_direct_action apply, code }.
-          should == '((r = match(:foo)) && (r.to_sym))'
-      end
-    end
-
-    context 'when top-level' do
-      it 'generates top level apply-rule code with a direct action' do
-        top_level_code {|g| g.gen_direct_action apply, code }.
-          should == '(r = match(:foo)) && (r.to_sym)'
-      end
-    end
-  end
-
   describe '#gen_token' do
 
     context 'when nested' do