rattler 0.5.0 → 0.6.0

data/spec/rattler/back_end/disallow_compiler_examples.rb

@@ -1,187 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a disallow' do
-  include CompilerSpecHelper
-
-  subject { compiled_parser }
-
-  let(:reference_parser) { combinator_parser grammar }
-
-  context 'with a nested match rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow /\w+/ }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested eof rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { disallow(eof) }
-    end }
-    it { should parse('foo').succeeding.like reference_parser }
-    it { should parse('').failing.like reference_parser }
-    it { should parse('foo').from(3).failing.like reference_parser }
-  end
-
-  context 'with a nested "E" symbol rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { disallow(e) }
-    end }
-    it { should parse('').failing.like reference_parser }
-    it { should parse('foo').failing.like reference_parser }
-  end
-
-  context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(match(/[[:alpha:]]/) | match(/[[:digit:]]/)) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested sequence rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/)) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested optional rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(optional(/\w+/)) }
-    end }
-    it { should parse('   ').failing.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested zero_or_more rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(zero_or_more(/\w/)) }
-    end }
-    it { should parse('   ').failing.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested one_or_more rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(one_or_more(/\w/)) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested repeat rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(repeat(/\w/, 2, nil)) }
-    end }
-    it { should parse('a ').succeeding.like reference_parser }
-    it { should parse('abc123 ').failing.like reference_parser }
-
-    context 'with zero-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule(:word) { disallow(repeat(/\w/, 0, nil)) }
-      end }
-      it { should parse('   ').failing.like reference_parser }
-      it { should parse('abc123  ').failing.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule(:word) { disallow(repeat(/\w/, 0, 2)) }
-        end }
-        it { should parse('   ').failing.like reference_parser }
-        it { should parse('abc123  ').failing.like reference_parser }
-      end
-    end
-
-    context 'with one-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule(:word) { disallow(repeat(/\w/, 1, nil)) }
-      end }
-      it { should parse('   ').succeeding.like reference_parser }
-      it { should parse('abc123  ').failing.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule(:word) { disallow(repeat(/\w/, 1, 2)) }
-        end }
-        it { should parse('   ').succeeding.like reference_parser }
-        it { should parse('abc123  ').failing.like reference_parser }
-      end
-    end
-  end
-
-  context 'with a nested list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        disallow list(/\w+/, /[,;]/, 2, nil)
-      end
-    end }
-    it { should parse('foo  ').succeeding.like reference_parser }
-    it { should parse('foo,bar;baz  ').failing.like reference_parser }
-
-    context 'with an upper bound' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          disallow list(/\w+/, /[,;]/, 2, 4)
-        end
-      end }
-      it { should parse('foo  ').succeeding.like reference_parser }
-      it { should parse('foo,bar;baz  ').failing.like reference_parser }
-    end
-
-    context 'with a non-capturing parser' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          disallow list(skip(/\w+/), /[,;]/, 2, nil)
-        end
-      end }
-      it { should parse('foo  ').succeeding.like reference_parser }
-      it { should parse('foo,bar;baz  ').failing.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule :foo do
-            disallow list(skip(/\w+/), /[,;]/, 2, 4)
-          end
-        end }
-        it { should parse('foo  ').succeeding.like reference_parser }
-        it { should parse('foo,bar;baz  ').failing.like reference_parser }
-      end
-    end
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { match :word }
-      rule(:word) { disallow /\w+/ }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested dispatch-action rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(dispatch_action(/\w+/)) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested token rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(token(match(/\w+/))) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-
-  context 'with a nested skip rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { disallow(skip(/\w+/)) }
-    end }
-    it { should parse('   ').succeeding.like reference_parser }
-    it { should parse('abc123  ').failing.like reference_parser }
-  end
-end

data/spec/rattler/back_end/dispatch_action_compiler_examples.rb

@@ -1,225 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a dispatch action' do
-  include CompilerSpecHelper
-
-  subject { compiled_parser }
-
-  let(:reference_parser) { combinator_parser grammar }
-
-  context 'with a nested match rule' do
-    let(:grammar) { define_grammar do
-      rule(:digits) { dispatch_action(/\d+/) }
-    end }
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:digits) { dispatch_action(label(:num, /\d+/)) }
-      end }
-      it { should parse('451a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:digit) { match(/\d/) }
-      rule(:foo) { dispatch_action :digit }
-    end }
-    it { should parse('451 ').twice.succeeding.like reference_parser }
-    it { should parse('hi').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:digits) { match(/\d+/) }
-        rule(:num) { dispatch_action(label(:num, :digits)) }
-      end }
-      it { should parse('451a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested assert rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { dispatch_action(assert(/\d/)) }
-    end }
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested disallow rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { dispatch_action(disallow(/\d/)) }
-    end }
-    it { should parse('    ').succeeding.like reference_parser }
-    it { should parse('451a').failing.like reference_parser }
-  end
-
-  context 'with a nested eof rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { dispatch_action(eof) }
-    end }
-    it { should parse('').succeeding.like reference_parser }
-    it { should parse('foo').from(3).succeeding.like reference_parser }
-    it { should parse('foo').failing.like reference_parser }
-  end
-
-  context 'with a nested "E" symbol rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { dispatch_action(e) }
-    end }
-    it { should parse('').succeeding.like reference_parser }
-    it { should parse('foo').succeeding.like reference_parser }
-  end
-
-  context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
-      rule :atom do
-        dispatch_action(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
-      end
-    end }
-
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested sequence rule' do
-    let(:grammar) { define_grammar do
-      rule :assignment do
-        dispatch_action(
-          match(/[[:alpha:]]+/) &
-          match('=') &
-          match(/[[:digit:]]+/)
-        )
-      end
-    end }
-
-    it { should parse('val=42 ').succeeding.like reference_parser }
-    it { should parse('val=x').failing.like reference_parser }
-
-    context 'with labels' do
-      let(:grammar) { define_grammar do
-        rule :assignment do
-          dispatch_action(
-            label(:name, /[[:alpha:]]+/) &
-            match('=') &
-            label(:value, /[[:digit:]]+/)
-          )
-        end
-      end }
-      it { should parse('val=42 ').succeeding.like reference_parser }
-    end
-  end
-
-  context 'with a nested optional rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(optional(/\w+/))
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('    ').succeeding.like reference_parser }
-  end
-
-  context 'with a nested zero-or-more rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(zero_or_more(/\w/))
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('    ').succeeding.like reference_parser }
-  end
-
-  context 'with a nested one-or-more rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(one_or_more(/\w/))
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested repeat rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(repeat(/\w/, 2, 4))
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('abcde ').succeeding.like reference_parser }
-    it { should parse('a ').failing.like reference_parser }
-
-    context 'with optional bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          dispatch_action(repeat(/\w+/, 0, 1))
-        end
-      end }
-      it { should parse('foo ').succeeding.like reference_parser }
-      it { should parse('    ').succeeding.like reference_parser }
-    end
-
-    context 'with zero-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          dispatch_action(repeat(/\w/, 0, nil))
-        end
-      end }
-      it { should parse('foo ').succeeding.like reference_parser }
-      it { should parse('    ').succeeding.like reference_parser }
-    end
-
-    context 'with one-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          dispatch_action(repeat(/\w/, 1, nil))
-        end
-      end }
-      it { should parse('foo ').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(list(/\w+/, /,/, 1, nil))
-      end
-    end }
-    it { should parse('a,bc,d ').succeeding.like reference_parser }
-    it { should parse('  ').failing.like reference_parser }
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:digit) { match /\d/ }
-      rule(:foo) { dispatch_action :digit }
-    end }
-    it { should parse('451a').succeeding.twice.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested token rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(token(match(/\w+/)))
-      end
-    end }
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested skip rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        dispatch_action(skip(/\w+/))
-      end
-    end }
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-end

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

@@ -1,80 +0,0 @@
-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