rattler 0.3.0 → 0.4.0

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

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe JoinPredicateOrBareMatch do
+
+  let(:match) { Match[/a/] }
+
+  let(:assert) { Assert[Match[/b/]] }
+  let(:disallow) { Disallow[Match[/b/]] }
+
+  describe '#apply' do
+
+    context 'given a choice with a match followed by a predicate' do
+
+      let(:choice) { Choice[Apply[:a], match, predicate] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/a|(?=b)/]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/a|(?!b)/]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/a|\z/]]
+        end
+      end
+    end
+
+    context 'given a choice with a predicate followed by a match' do
+
+      let(:choice) { Choice[Apply[:a], predicate, match] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/(?=b)|a/]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/(?!b)|a/]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent single match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Match[/\z|a/]]
+        end
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a choice with a match followed by a predicate' do
+
+      let(:choice) { Choice[Apply[:a], match, predicate] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+    end
+
+    context 'given a choice with a predicate followed by a match' do
+
+      let(:choice) { Choice[Apply[:a], predicate, match] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe JoinPredicateOrNestedMatch do
+
+  let(:skip) { Skip[Match[/a/]] }
+
+  let(:assert) { Assert[Match[/b/]] }
+  let(:disallow) { Disallow[Match[/b/]] }
+
+  describe '#apply' do
+
+    context 'given a choice with a skip of a match followed by a predicate' do
+
+      let(:choice) { Choice[Apply[:a], skip, predicate] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/a|(?=b)/]]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/a|(?!b)/]]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/a|\z/]]]
+        end
+      end
+    end
+
+    context 'given a choice with a predicate followed by a skip of a match' do
+
+      let(:choice) { Choice[Apply[:a], predicate, skip] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/(?=b)|a/]]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/(?!b)|a/]]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent skip of a match' do
+          subject.apply(choice, :any).should ==
+            Choice[Apply[:a], Skip[Match[/\z|a/]]]
+        end
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a choice with a skip of a match followed by a predicate' do
+
+      let(:choice) { Choice[Apply[:a], skip, predicate] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+    end
+
+    context 'given a choice with a predicate followed by a skip of a match' do
+
+      let(:choice) { Choice[Apply[:a], predicate, skip] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(choice, :any).should be_true
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe ReduceRepeatMatch do
+
+  let(:matching) { OptimizationContext[:type => :matching] }
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+
+  describe '#apply' do
+
+    context 'given a zero-or-more match' do
+
+      let(:repeat) { ZeroOrMore[Match[/a/]] }
+
+      it 'converts it to an equivalent match' do
+        subject.apply(repeat, matching).should == Match[/(?>a)*/]
+      end
+    end
+
+    context 'given a one-or-more of a match' do
+
+      let(:repeat) { OneOrMore[Match[/a/]] }
+
+      it 'returns true' do
+        subject.apply(repeat, matching).should == Match[/(?>a)+/]
+      end
+    end
+
+    context 'given an optional match' do
+
+      let(:repeat) { Optional[Match[/a/]] }
+
+      it 'returns true' do
+        subject.apply(repeat, matching).should == Match[/(?>a)?/]
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'in the :capturing context' do
+
+      let(:repeat) { ZeroOrMore[Match[/a/]] }
+
+      it 'returns false' do
+        subject.applies_to?(repeat, capturing).should be_false
+      end
+    end
+
+    context 'given a zero-or-more of a match' do
+
+      let(:repeat) { ZeroOrMore[Match[/a/]] }
+
+      it 'returns true' do
+        subject.applies_to?(repeat, matching).should be_true
+      end
+    end
+
+    context 'given a one-or-more of a match' do
+
+      let(:repeat) { OneOrMore[Match[/a/]] }
+
+      it 'returns true' do
+        subject.applies_to?(repeat, matching).should be_true
+      end
+    end
+
+    context 'given an optional match' do
+
+      let(:repeat) { Optional[Match[/a/]] }
+
+      it 'returns true' do
+        subject.applies_to?(repeat, matching).should be_true
+      end
+    end
+
+    context 'given a repeat of something other than a match' do
+
+      let(:repeat) { ZeroOrMore[Apply[:a]] }
+
+      it 'returns false' do
+        subject.applies_to?(repeat, matching).should be_false
+      end
+    end
+
+    context 'given something other than a repeat' do
+
+      let(:other) { Assert[Match[/a/]] }
+
+      it 'returns false' do
+        subject.applies_to?(other, matching).should be_false
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,226 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe SimplifyRedundantRepeat do
+
+  let(:matching) { OptimizationContext[:type => :matching] }
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+
+  describe '#apply' do
+
+    context 'given a zero-or-more' do
+
+      let(:parser) { ZeroOrMore[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
+
+        let(:child) { Optional[Match[/a/]] }
+
+        it 'returns a ZeroOrMore' do
+          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
+        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 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
+
+        let(:child) { Optional[Match[/a/]] }
+
+        it 'returns a ZeroOrMore' do
+          subject.apply(parser, matching).should == ZeroOrMore[Match[/a/]]
+        end
+      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
+
+        let(:child) { Optional[Match[/a/]] }
+
+        it 'returns the inner Optional' do
+          subject.apply(parser, matching).should == Optional[Match[/a/]]
+        end
+      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/] }
+
+        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/]] }
+
+        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
+        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
+
+        let(:child) { Optional[Match[/a/]] }
+
+        it 'returns true' do
+          subject.applies_to?(parser, matching).should be_true
+        end
+      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
+
+        let(:child) { Optional[Match[/a/]] }
+
+        it 'returns true' do
+          subject.applies_to?(parser, matching).should be_true
+        end
+      end
+    end
+  end
+
+end