rattler 0.5.0 → 0.6.0

data/lib/rattler/parsers/semantic_disallow.rb

@@ -1,19 +0,0 @@
-require 'rattler/parsers'
-
-module Rattler::Parsers
-  #
-  # +SemanticDisallow+ decorates a parser to peform a symantic action on success
-  # by evaluating ruby code and succeed if the result is a false value.
-  #
-  # @author Jason Arhart
-  #
-  class SemanticDisallow < DirectAction
-
-    protected
-
-    def create_bindable_code
-      DisallowCode.new(code)
-    end
-
-  end
-end

data/lib/rattler/parsers/side_effect.rb

@@ -1,19 +0,0 @@
-require 'rattler/parsers'
-
-module Rattler::Parsers
-  #
-  # +SideEffect+ decorates a parser to peform a symantic action on success by
-  # evaluating ruby code for effect and discarding the result.
-  #
-  # @author Jason Arhart
-  #
-  class SideEffect < DirectAction
-
-    protected
-
-    def create_bindable_code
-      EffectCode.new(code)
-    end
-
-  end
-end

data/spec/rattler/back_end/assert_compiler_examples.rb

@@ -1,187 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with an assert' 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) { assert /\w+/ }
-    end }
-    it { should parse('abc123  ').succeeding.like reference_parser }
-    it { should parse('   ').failing.like reference_parser }
-  end
-
-  context 'with a nested eof rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { assert(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) { assert(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(:word) { assert(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/)) }
-    end }
-    it { should parse('abc123  ').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(:word) { assert(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/)) }
-    end }
-    it { should parse('abc123  ').succeeding.like reference_parser }
-    it { should parse('   ').failing.like reference_parser }
-  end
-
-  context 'with a nested optional rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { assert(optional(/\w+/)) }
-    end }
-    it { should parse('abc123  ').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(:word) { assert(zero_or_more(/\w/)) }
-    end }
-    it { should parse('abc123  ').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(:word) { assert(one_or_more(/\w/)) }
-    end }
-    it { should parse('abc123  ').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(:word) { assert(repeat(/\w/, 2, nil)) }
-    end }
-    it { should parse('abc123 ').succeeding.like reference_parser }
-    it { should parse('a ').failing.like reference_parser }
-
-    context 'with zero-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule(:word) { assert(repeat(/\w/, 0, nil)) }
-      end }
-      it { should parse('abc123  ').succeeding.like reference_parser }
-      it { should parse('   ').succeeding.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule(:word) { assert(repeat(/\w/, 0, 2)) }
-        end }
-        it { should parse('abc123  ').succeeding.like reference_parser }
-        it { should parse('   ').succeeding.like reference_parser }
-      end
-    end
-
-    context 'with one-or-more bounds' do
-      let(:grammar) { define_grammar do
-        rule(:word) { assert(repeat(/\w/, 1, nil)) }
-      end }
-      it { should parse('abc123  ').succeeding.like reference_parser }
-      it { should parse('   ').failing.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule(:word) { assert(repeat(/\w/, 1, 2)) }
-        end }
-        it { should parse('abc123  ').succeeding.like reference_parser }
-        it { should parse('   ').failing.like reference_parser }
-      end
-    end
-  end
-
-  context 'with a nested list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        assert list(/\w+/, /[,;]/, 2, nil)
-      end
-    end }
-    it { should parse('foo  ').failing.like reference_parser }
-    it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
-
-    context 'with an upper bound' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          assert list(/\w+/, /[,;]/, 2, 4)
-        end
-      end }
-      it { should parse('foo  ').failing.like reference_parser }
-      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
-    end
-
-    context 'with a non-capturing parser' do
-      let(:grammar) { define_grammar do
-        rule :foo do
-          assert list(skip(/\w+/), /[,;]/, 2, nil)
-        end
-      end }
-      it { should parse('foo  ').failing.like reference_parser }
-      it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
-
-      context 'with an upper bound' do
-        let(:grammar) { define_grammar do
-          rule :foo do
-            assert list(skip(/\w+/), /[,;]/, 2, 4)
-          end
-        end }
-        it { should parse('foo  ').failing.like reference_parser }
-        it { should parse('foo,bar;baz  ').succeeding.like reference_parser }
-      end
-    end
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { match :word }
-      rule(:word) { assert /\w+/ }
-    end }
-    it { should parse('abc123  ').succeeding.like reference_parser }
-    it { should parse('   ').failing.like reference_parser }
-  end
-
-  context 'with a nested dispatch-action rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { assert(dispatch_action(/\w+/)) }
-    end }
-    it { should parse('abc123  ').succeeding.like reference_parser }
-    it { should parse('   ').failing.like reference_parser }
-  end
-
-  context 'with a nested token rule' do
-    let(:grammar) { define_grammar do
-      rule(:word) { assert(token(match(/\w+/))) }
-    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(:word) { assert(skip(/\w+/)) }
-    end }
-    it { should parse('abc123  ').succeeding.like reference_parser }
-    it { should parse('   ').failing.like reference_parser }
-  end
-end

data/spec/rattler/back_end/compiler_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require File.expand_path(File.dirname(__FILE__) + '/shared_compiler_examples')
-
-describe Rattler::BackEnd::Compiler do
-  include CompilerSpecHelper
-
-  describe '.compile_parser result' do
-
-    let :compiled_parser do
-      described_class.compile_parser compiled_parser_base, grammar
-    end
-
-    let(:compiled_parser_base) { Rattler::Runtime::RecursiveDescentParser }
-
-    it_behaves_like 'a compiled parser'
-  end
-
-  describe '.compile_parser' do
-
-    context 'given parse rules' do
-
-      let(:grammar) { define_grammar do
-        rule(:word) { match /\w+/ }
-        rule(:space) { match /\s*/ }
-      end }
-
-      let(:parser_base) { Rattler::Runtime::RecursiveDescentParser }
-
-      let(:result) { described_class.compile_parser(parser_base, grammar) }
-
-      it 'compiles a match_xxx method for each rule' do
-        result.should have_method(:match_word)
-        result.should have_method(:match_space)
-      end
-    end
-
-  end
-
-  def have_method(rule_name)
-    be_method_defined(rule_name)
-  end
-
-end

data/spec/rattler/back_end/direct_action_compiler_examples.rb

@@ -1,227 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a direct 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(:num) { direct_action(/\d+/, '|_| _.to_i') }
-    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) { direct_action(label(:num, /\d+/), 'num.to_i') }
-      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(:foo) { direct_action :digit, '|_| _.to_i' }
-      rule(:digit) { match(/\d/) }
-    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(:num) { direct_action(label(:num, :digits), 'num.to_i') }
-        rule(:digits) { match(/\d+/) }
-      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) { direct_action(assert(/\d/), ':digit') }
-    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) { direct_action(disallow(/\d/), ':nondigit') }
-    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) { direct_action(eof, ':eof') }
-    end }
-    it { should parse('foo').failing.like reference_parser }
-    it { should parse('').succeeding.like reference_parser }
-    it { should parse('foo').from(3).succeeding.like reference_parser }
-  end
-
-  context 'with a nested "E" symbol rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { direct_action(e, ':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 :foo do
-        direct_action(
-          match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
-          '|_| _.size'
-        )
-      end
-    end }
-
-    it { should parse('abc123').succeeding.like reference_parser }
-    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
-        direct_action(
-          match(/[[:alpha:]]+/) & match('=') & match(/[[:digit:]]+/),
-          '|l,_,r| "#{r} -> #{l}"'
-        )
-      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
-          direct_action(
-            label(:name, /[[:alpha:]]+/) & match('=') & label(:value, /[[:digit:]]+/),
-            '"#{value} -> #{name}"'
-          )
-        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
-        direct_action(optional(/\w+/), '|_| _.size')
-      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
-        direct_action(zero_or_more(/\w/), '|_| _.size')
-      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
-        direct_action(one_or_more(/\w/), '|_| _.size')
-      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
-        direct_action(repeat(/\w/, 2, 4), '|_| _.size')
-      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
-          direct_action(repeat(/\w+/, 0, 1), '|_| _.size')
-        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
-          direct_action(repeat(/\w/, 0, nil), '|_| _.size')
-        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
-          direct_action(repeat(/\w/, 1, nil), '|_| _.size')
-        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
-        direct_action(list(/\w+/, /,/, 1, nil), '|_| _.reduce(:+)')
-      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(:foo) { direct_action :digit, '|_| _.to_i' }
-      rule(:digit) { match /\d/ }
-    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
-        direct_action(token(/\w+/), '|_| _.size')
-      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
-        direct_action(skip(/\w+/), '42' )
-      end
-    end }
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-end