rattler 0.3.0 → 0.4.0

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

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::BackEnd::Optimizer::JoinMatchChoice do
+
+  describe '#apply' do
+
+    context 'given a choice of all matches' do
+
+      let(:choice) { Choice[Match[/a/], Match[/b/], Match[/c/]] }
+
+      it 'joins them into a single match' do
+        subject.apply(choice, :any).should == Match[/a|b|c/]
+      end
+    end
+
+    context 'given a choice of matches followed by something else' do
+
+      let(:choice) { Choice[Match[/a/], Match[/b/], Apply[:c]] }
+
+      it 'joins the consecutive matches into a single match' do
+        subject.apply(choice, :any).should == Choice[
+          Match[/a|b/],
+          Apply[:c]
+        ]
+      end
+    end
+
+    context 'given a choice of matches following something else' do
+
+      let(:choice) { Choice[Apply[:a], Match[/b/], Match[/c/]] }
+
+      it 'joins the consecutive matches into a single match' do
+        subject.apply(choice, :any).should == Choice[
+          Apply[:a],
+          Match[/b|c/]
+        ]
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a choice of all matches' do
+
+      let(:choice) { Choice[Match[/a/], Match[/b/], Match[/c/]] }
+
+      it 'returns true' do
+        subject.applies_to?(choice, :any).should be_true
+      end
+    end
+
+    context 'given a choice of matches followed by something else' do
+
+      let(:choice) { Choice[Match[/a/], Match[/b/], Apply[:c]] }
+
+      it 'returns true' do
+        subject.applies_to?(choice, :any).should be_true
+      end
+    end
+
+    context 'given a choice of matches following something else' do
+
+      let(:choice) { Choice[Apply[:a], Match[/b/], Match[/c/]] }
+
+      it 'returns true' do
+        subject.applies_to?(choice, :any).should be_true
+      end
+    end
+
+    context 'given a choice with only one match' do
+
+      let(:choice) { Choice[Apply[:a], Match[/b/], Apply[:c]] }
+
+      it 'returns true' do
+        subject.applies_to?(choice, :any).should be_false
+      end
+    end
+
+    context 'given a choice of non-consecutive matches' do
+
+      let(:choice) { Choice[Match[/a/], Apply[:b], Match[/c/]] }
+
+      it 'returns false' do
+        subject.applies_to?(choice, :any).should be_false
+      end
+    end
+
+    context 'given a non-choice' do
+
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], Match[/c/]] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, :any).should be_false
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,112 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe JoinMatchMatchingSequence do
+
+  let(:matching) { OptimizationContext[:type => :matching] }
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+
+  describe '#apply' do
+
+    context 'given a sequence of all matches' do
+
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], Match[/c/]] }
+
+      it 'joins them into a single match' do
+        subject.apply(sequence, matching).should == Match[/(?>a)(?>b)(?>c)/]
+      end
+    end
+
+    context 'given a sequence of matches followed by something else' do
+
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], Apply[:c]] }
+
+      it 'joins the consecutive matches into a single match' do
+        subject.apply(sequence, matching).should == Sequence[
+          Match[/(?>a)(?>b)/],
+          Apply[:c]
+        ]
+      end
+    end
+
+    context 'given a sequence of matches following something else' do
+
+      let(:sequence) { Sequence[Apply[:a], Match[/b/], Match[/c/]] }
+
+      it 'joins the consecutive matches into a single match' do
+        subject.apply(sequence, matching).should == Sequence[
+          Apply[:a],
+          Match[/(?>b)(?>c)/]
+        ]
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a sequence of all matches' do
+
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], Match[/c/]] }
+
+      context 'in the :matching context' do
+        it 'returns true' do
+          subject.applies_to?(sequence, matching).should be_true
+        end
+      end
+
+      context 'in the :matching context' do
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+    end
+
+    context 'given a sequence of matches followed by something else' do
+
+      let(:sequence) { Sequence[Match[/a/], Match[/b/], Apply[:c]] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, matching).should be_true
+      end
+    end
+
+    context 'given a sequence of matches following something else' do
+
+      let(:sequence) { Sequence[Apply[:a], Match[/b/], Match[/c/]] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, matching).should be_true
+      end
+    end
+
+    context 'given a sequence with only one match' do
+
+      let(:sequence) { Sequence[Apply[:a], Match[/b/], Apply[:c]] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, matching).should be_false
+      end
+    end
+
+    context 'given a sequence of non-consecutive matches' do
+
+      let(:sequence) { Sequence[Match[/a/], Apply[:b], Match[/c/]] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, matching).should be_false
+      end
+    end
+
+    context 'given a non-sequence' do
+
+      let(:choice) { Choice[Match[/a/], Match[/b/], Match[/c/]] }
+
+      it 'returns false' do
+        subject.applies_to?(choice, matching).should be_false
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,194 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::BackEnd::Optimizer::JoinPredicateBareMatch do
+
+  describe '#apply' do
+
+    let(:match) { Match[/a/] }
+
+    let(:assert) { Assert[Match[/b/]] }
+    let(:disallow) { Disallow[Match[/b/]] }
+
+    context 'given a sequence with a match followed by a predicate' do
+
+      let(:sequence) { Sequence[Apply[:a], match, predicate, Apply[:b]] }
+
+      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(sequence, :any).should ==
+            Sequence[Apply[:a], Match[/(?>a)(?=b)/], Apply[: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(sequence, :any).should ==
+            Sequence[Apply[:a], Match[/(?>a)(?!b)/], Apply[:b]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent single match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Match[/(?>a)\z/], Apply[:b]]
+        end
+      end
+    end
+
+    context 'given a sequence with a predicate followed by a match' do
+
+      let(:sequence) { Sequence[Apply[:a], predicate, match, Apply[:b]] }
+
+      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(sequence, :any).should ==
+            Sequence[Apply[:a], Match[/(?=b)(?>a)/], Apply[: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(sequence, :any).should ==
+            Sequence[Apply[:a], Match[/(?!b)(?>a)/], Apply[:b]]
+        end
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    let(:match) { Match[/a/] }
+
+    let(:assert) { Assert[Match[/b/]] }
+    let(:disallow) { Disallow[Match[/b/]] }
+
+    context 'given a sequence with a match followed by a predicate' do
+
+      let(:sequence) { Sequence[Apply[:a], match, predicate, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with an assert of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+
+      context 'with a disallow of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+    end
+
+
+    context 'given a sequence with a predicate followed by a match' do
+
+      let(:sequence) { Sequence[Apply[:a], predicate, match, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with an assert of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+
+      context 'with a disallow of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+    end
+
+    context 'given a sequence with a match and a predicate not adjacent' do
+
+      let(:sequence) { Sequence[Apply[:a], match, Apply[:b], assert] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, :any).should be_false
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,180 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::BackEnd::Optimizer::JoinPredicateNestedMatch do
+
+  let(:skip) { Skip[Match[/a/]] }
+  let(:token) { Token[Match[/a/]] }
+
+  let(:assert) { Assert[Match[/b/]] }
+  let(:disallow) { Disallow[Match[/b/]] }
+
+  describe '#apply' do
+
+    context 'given a sequence with a skip of a match followed by a predicate' do
+
+      let(:sequence) { Sequence[Apply[:a], skip, predicate, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent skipping match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Skip[Match[/(?>a)(?=b)/]], Apply[:b]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent skipping match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Skip[Match[/(?>a)(?!b)/]], Apply[:b]]
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'reduces the match and Eof into an equivalent skipping match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Skip[Match[/(?>a)\z/]], Apply[:b]]
+        end
+      end
+    end
+
+    context 'given a sequence with a predicate followed by a skip of a match' do
+
+      let(:sequence) { Sequence[Apply[:a], predicate, skip, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'reduces the match and assert into an equivalent skipping match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Skip[Match[/(?=b)(?>a)/]], Apply[:b]]
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'reduces the match and disallow into an equivalent skipping match' do
+          subject.apply(sequence, :any).should ==
+            Sequence[Apply[:a], Skip[Match[/(?!b)(?>a)/]], Apply[:b]]
+        end
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a sequence with a skip of a match followed by a predicate' do
+
+      let(:sequence) { Sequence[Apply[:a], skip, predicate, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with Eof' do
+
+        let(:predicate) { Eof[] }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with an assert of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+
+      context 'with a disallow of something else' do
+
+        let(:predicate) { Disallow[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+    end
+
+
+    context 'given a sequence with a predicate followed by a skip of match' do
+
+      let(:sequence) { Sequence[Apply[:a], predicate, skip, Apply[:b]] }
+
+      context 'with an assert of a match' do
+
+        let(:predicate) { assert }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with a disallow of a match' do
+
+        let(:predicate) { disallow }
+
+        it 'returns true' do
+          subject.applies_to?(sequence, :any).should be_true
+        end
+      end
+
+      context 'with an assert of something else' do
+
+        let(:predicate) { Assert[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+
+      context 'with a disallow of something else' do
+
+        let(:predicate) { Disallow[Apply[:a]]}
+
+        it 'returns false' do
+          subject.applies_to?(sequence, :any).should be_false
+        end
+      end
+    end
+
+    context 'given a sequence with a match and a predicate not adjacent' do
+
+      let(:sequence) { Sequence[Apply[:a], skip, Apply[:b], assert] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, :any).should be_false
+      end
+    end
+  end
+
+end