rattler 0.3.0 → 0.4.0

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

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::Parsers
+
+describe Rattler::BackEnd::Optimizer::FlattenChoice do
+
+  describe '#apply' do
+
+    context 'given a choice with choice terms' do
+
+      let(:choice) { Choice[
+        Match[/a/],
+        Choice[Match[/b/], Match[/c/]],
+        Sequence[Match[/d/], Match[/e/]]
+      ] }
+
+      it 'flattens the choice' do
+        subject.apply(choice, :any).should == Choice[
+          Match[/a/],
+          Match[/b/],
+          Match[/c/],
+          Sequence[Match[/d/], Match[/e/]]
+        ]
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a choice with choice terms' do
+
+      let(:choice) { Choice[
+        Match[/a/],
+        Choice[Match[/b/], Match[/c/]],
+        Sequence[Match[/d/], Match[/e/]]
+      ] }
+
+      it 'returns true' do
+        subject.applies_to?(choice, :any).should be_true
+      end
+    end
+
+    context 'given a choice without choice terms' do
+
+      let(:choice) { Choice[
+        Match[/a/],
+        Match[/b/],
+        Sequence[Match[/c/], Match[/d/]]
+      ] }
+
+      it 'returns false' do
+        subject.applies_to?(choice, :any).should be_false
+      end
+    end
+
+    context 'given something other than a choie' do
+
+      let(:choice) { Sequence[
+        Match[/a/],
+        Choice[Match[/b/], Match[/c/]],
+        Sequence[Match[/d/], Match[/e/]]
+      ] }
+
+      it 'returns false' do
+        subject.applies_to?(choice, :any).should be_false
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe FlattenSequence do
+
+  let(:matching) { OptimizationContext[:type => :matching] }
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+
+  describe '#apply' do
+
+    context 'in the matching context' do
+
+      context 'given a sequence with sequence terms' do
+
+        let(:sequence) { Sequence[
+          Match[/a/],
+          Sequence[Match[/b/], Match[/c/]],
+          Choice[Match[/c/], Match[/d/]]
+        ] }
+
+        it 'flattens the sequence' do
+          subject.apply(sequence, matching).should == Sequence[
+            Match[/a/],
+            Match[/b/],
+            Match[/c/],
+            Choice[Match[/c/], Match[/d/]],
+          ]
+        end
+      end
+    end
+
+    context 'in the capturing context' do
+
+      context 'given a sequence with single-capturing sequence terms' do
+
+        let(:sequence) { Sequence[
+          Match[/a/],
+          Sequence[Skip[Match[/b/]], Skip[Match[/c/]]],
+          Sequence[Match[/b/], Skip[Match[/c/]]]
+        ] }
+
+        it 'flattens the sequences' do
+          subject.apply(sequence, capturing).should == Sequence[
+            Match[/a/],
+            Skip[Match[/b/]],
+            Skip[Match[/c/]],
+            Match[/b/],
+            Skip[Match[/c/]]
+          ]
+        end
+      end
+
+      context 'given a sequence with multi-capturing sequence terms' do
+
+        let(:sequence) { Sequence[
+          Match[/a/],
+          Sequence[Skip[Match[/b/]], Skip[Match[/c/]]],
+          Sequence[Match[/b/], Match[/c/]]
+        ] }
+
+        it 'avoids flattening the capturing sequences' do
+          subject.apply(sequence, capturing).should == Sequence[
+            Match[/a/],
+            Skip[Match[/b/]],
+            Skip[Match[/c/]],
+            Sequence[Match[/b/], Match[/c/]]
+          ]
+        end
+      end
+    end
+
+  end
+
+  describe '#applies_to?' do
+
+    context 'given a sequence with only capturing sequence terms' do
+
+      let(:sequence) { Sequence[
+        Match[/a/],
+        Sequence[Match[/b/], Match[/c/]],
+        Choice[Match[/c/], Match[/d/]]
+      ] }
+
+      context 'in the matching context' do
+        it 'returns true' do
+          subject.applies_to?(sequence, matching).should be_true
+        end
+      end
+
+      context 'in the capturing context' do
+        it 'returns false' do
+          subject.applies_to?(sequence, capturing).should be_false
+        end
+      end
+    end
+
+    context 'given a sequence with non-capturing sequence terms' do
+
+      let(:sequence) { Sequence[
+        Match[/a/],
+        Sequence[Skip[Match[/b/]], Skip[Match[/c/]]],
+        Choice[Match[/c/], Match[/d/]]
+      ] }
+
+      context 'in the capturing context' do
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+    end
+
+    context 'given a sequence with single-capturing sequence terms' do
+
+      let(:sequence) { Sequence[
+        Match[/a/],
+        Sequence[Skip[Match[/b/]], Skip[Match[/c/]]],
+        Sequence[Match[/b/], Skip[Match[/c/]]]
+      ] }
+
+      context 'in the capturing context' do
+        it 'returns true' do
+          subject.applies_to?(sequence, capturing).should be_true
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+
+describe InlineRegularRules do
+
+  let(:standalone) { OptimizationContext[
+    :type => :capturing,
+    :rules => rule_set,
+    :standalone => true
+  ] }
+
+  let(:modular) { 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/]] }
+
+      it 'inlines the regular rule' do
+        subject.apply(Apply[:a], standalone).should == Match[/a/]
+      end
+    end
+  end
+
+  describe '#_applies_to?' do
+
+    context 'with the :standalone option set' do
+
+      context 'given a reference to a regular rule' do
+
+        let(:rule_a) { Rule[:a, Match[/a/]] }
+
+        it 'returns true' do
+          subject.applies_to?(Apply[:a], standalone).should be_true
+        end
+      end
+
+      context 'given a reference to a recursive rule' do
+
+        let(:rule_a) { Rule[:a, Sequence[Match[/a/], Apply[:a]]] }
+
+        it 'returns false' do
+          subject.applies_to?(Apply[:a], standalone).should be_false
+        end
+      end
+    end
+
+    context 'without the :standalone option set' 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], modular).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], modular).should be_false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+include Rattler::BackEnd::Optimizer
+include Rattler::Parsers
+include Rattler::BackEnd::ParserGenerator
+
+describe JoinMatchCapturingSequence do
+
+  let(:capturing) { OptimizationContext[:type => :capturing] }
+  let(:matching) { OptimizationContext[:type => :matching] }
+
+  describe '#apply' do
+
+    context 'given a sequence of all skipping matches' do
+
+      let(:sequence) { Sequence[
+        Skip[Match[/a/]],
+        Skip[Match[/b/]],
+        Skip[Match[/c/]]
+      ] }
+
+      it 'joins them into a single skipping match' do
+        subject.apply(sequence, capturing).
+        should == Skip[Match[/(?>a)(?>b)(?>c)/]]
+      end
+    end
+
+    context 'given a sequence of skipping matches followed by something else' do
+
+      let(:sequence) { Sequence[
+        Skip[Match[/a/]],
+        Skip[Match[/b/]],
+        Apply[:c]
+      ] }
+
+      it 'joins the consecutive skipping matches into a single match' do
+        subject.apply(sequence, capturing).should == Sequence[
+          Skip[Match[/(?>a)(?>b)/]],
+          Apply[:c]
+        ]
+      end
+    end
+
+    context 'given a sequence of skipping matches following something else' do
+
+      let(:sequence) { Sequence[
+        Apply[:a],
+        Skip[Match[/b/]],
+        Skip[Match[/c/]]
+      ] }
+
+      it 'joins the consecutive skipping matches into a single match' do
+        subject.apply(sequence, capturing).should == Sequence[
+          Apply[:a],
+          Skip[Match[/(?>b)(?>c)/]]
+        ]
+      end
+    end
+
+    context 'given a sequence of matches' do
+
+      let(:sequence) { Sequence[
+        Match[/a/],
+        Match[/b/],
+        Match[/c/]
+      ] }
+
+      it 'joins them into a single group match' do
+        subject.apply(sequence, capturing).
+        should == GroupMatch[Match[/(a)(b)(c)/], {:num_groups => 3}]
+      end
+    end
+
+    context 'given a sequence of single-group matches' do
+
+      let(:sequence) { Sequence[
+        GroupMatch[Match[/\s*(a)/], {:num_groups => 1}],
+        GroupMatch[Match[/\s*(b)/], {:num_groups => 1}],
+        GroupMatch[Match[/\s*(c)/], {:num_groups => 1}]
+      ] }
+
+      it 'joins them into a single group match' do
+        subject.apply(sequence, capturing).
+        should == GroupMatch[Match[/(?>\s*(a))(?>\s*(b))(?>\s*(c))/], {:num_groups => 3}]
+      end
+    end
+
+    context 'give a mix of bare and single-group matches' do
+
+      let(:sequence) { Sequence[
+        GroupMatch[Match[/\s*(a)/], {:num_groups => 1}],
+        Match[/[+\-*\/]/],
+        GroupMatch[Match[/\s*(b)/], {:num_groups => 1}],
+      ] }
+
+      it 'joins them into a single group match' do
+        subject.apply(sequence, capturing).
+        should == GroupMatch[Match[/(?>\s*(a))([+\-*\/])(?>\s*(b))/], {:num_groups => 3}]
+      end
+    end
+  end
+
+  describe '#applies_to?' do
+
+    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, capturing).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, capturing).should be_true
+      end
+    end
+
+    context 'given a sequence of skipping matches followed by something else' do
+
+      let(:sequence) { Sequence[
+        Skip[Match[/a/]],
+        Skip[Match[/b/]],
+        Apply[:c]
+      ] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, capturing).should be_true
+      end
+    end
+
+    context 'given a sequence of skipping matches following something else' do
+
+      let(:sequence) { Sequence[
+        Apply[:a],
+        Skip[Match[/b/]],
+        Skip[Match[/c/]]
+      ] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, capturing).should be_true
+      end
+    end
+
+    context 'given a sequence of single-group matches followed by something else' do
+
+      let(:sequence) { Sequence[
+        GroupMatch[Match[/a/], {:num_groups => 1}],
+        GroupMatch[Match[/b/], {:num_groups => 1}],
+        Apply[:c]
+      ] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, capturing).should be_true
+      end
+    end
+
+    context 'given a sequence of single-group matches following something else' do
+
+      let(:sequence) { Sequence[
+        Apply[:a],
+        GroupMatch[Match[/b/], {:num_groups => 1}],
+        GroupMatch[Match[/c/], {:num_groups => 1}]
+      ] }
+
+      it 'returns true' do
+        subject.applies_to?(sequence, capturing).should be_true
+      end
+    end
+
+    context 'given a sequence of multi-group matches followed by something else' do
+
+      let(:sequence) { Sequence[
+        GroupMatch[Match[/a/], {:num_groups => 2}],
+        GroupMatch[Match[/b/], {:num_groups => 2}],
+        Apply[:c]
+      ] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, capturing).should be_false
+      end
+    end
+
+    context 'given a sequence of multi-group matches following something else' do
+
+      let(:sequence) { Sequence[
+        Apply[:a],
+        GroupMatch[Match[/b/], {:num_groups => 2}],
+        GroupMatch[Match[/c/], {:num_groups => 2}]
+      ] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, capturing).should be_false
+      end
+    end
+
+    context 'given a sequence with only one match' do
+
+      let(:sequence) { Sequence[Apply[:a], Skip[Match[/b/]], Apply[:c]] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, capturing).should be_false
+      end
+    end
+
+    context 'given a sequence of non-consecutive matches' do
+
+      let(:sequence) { Sequence[Skip[Match[/a/]], Apply[:b], Skip[Match[/c/]]] }
+
+      it 'returns false' do
+        subject.applies_to?(sequence, capturing).should be_false
+      end
+    end
+
+    context 'given a non-sequence' do
+
+      let(:parser) { Choice[
+        Skip[Match[/a/]],
+        Skip[Match[/b/]],
+        Skip[Match[/c/]]
+      ] }
+
+      it 'returns false' do
+        subject.applies_to?(parser, capturing).should be_false
+      end
+    end
+  end
+
+end