rattler 0.5.0 → 0.6.0

data/spec/rattler/back_end/semantic_assert_compiler_examples.rb

@@ -1,152 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a positive semantic predicate' 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) { semantic_assert(/\d+/, '_.to_i > 200') }
-    end }
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('123a').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:digits) { semantic_assert(label(:num, /\d+/), 'num.to_i > 200') }
-      end }
-      it { should parse('451a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-      it { should parse('123a').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { semantic_assert :digit, '_.to_i > 200' }
-      rule(:digit) { match(/\d+/) }
-    end }
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('123a').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:num) { semantic_assert(label(:num, :digits), 'num.to_i > 200') }
-        rule(:digits) { match(/\d+/) }
-      end }
-      it { should parse('451a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-      it { should parse('123a').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_assert(
-          match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
-          '_.size > 2'
-        )
-      end
-    end }
-
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('12abc').failing.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
-        semantic_assert(
-          match(/\w+/) & match('=') & match(/\w+/),
-          '|l,_,r| l == r'
-        )
-      end
-    end }
-    it { should parse('451a=451a ').succeeding.like reference_parser }
-    it { should parse('451a=123a ').failing.like reference_parser }
-
-    context 'with labels' do
-      let(:grammar) { define_grammar do
-        rule :assignment do
-          semantic_assert(
-            label(:lt, /\w+/) & match('=') & label(:rt, /\w+/),
-            'lt == rt'
-          )
-        end
-      end }
-      it { should parse('451a=451a ').succeeding.like reference_parser }
-      it { should parse('451a=123a ').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested optional rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_assert(optional(/\w+/), '|_| _.empty?')
-      end
-    end }
-    it { should parse('foo ').failing.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
-        semantic_assert(zero_or_more(/\w/), '|_| _.size < 4')
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('food').failing.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
-        semantic_assert(one_or_more(/\w/), '|_| _.size < 4')
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('food').failing.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_assert(list(/\w+/, /,/, 1, nil), '|_| _.size < 4')
-      end
-    end }
-    it { should parse('a,bc,d ').succeeding.like reference_parser }
-    it { should parse('a,b,c,d').failing.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) { semantic_assert :digit, '_.to_i > 200' }
-      rule(:digit) { match /\d+/ }
-    end }
-    it { should parse('451a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('123a').failing.like reference_parser }
-  end
-
-  context 'with a nested token rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_assert(token(/\w+/), '_.size > 5')
-      end
-    end }
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('      ').failing.like reference_parser }
-    it { should parse('abc12 ').failing.like reference_parser }
-  end
-end

data/spec/rattler/back_end/semantic_disallow_compiler_examples.rb

@@ -1,152 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a negative semantic predicate' 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) { semantic_disallow(/\d+/, '_.to_i > 200') }
-    end }
-    it { should parse('123a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('451a').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:digits) { semantic_disallow(label(:num, /\d+/), 'num.to_i > 200') }
-      end }
-      it { should parse('123a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-      it { should parse('451a').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested apply rule' do
-    let(:grammar) { define_grammar do
-      rule(:foo) { semantic_disallow :digit, '_.to_i > 200' }
-      rule(:digit) { match(/\d+/) }
-    end }
-    it { should parse('123a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('451a').failing.like reference_parser }
-
-    context 'with a label' do
-      let(:grammar) { define_grammar do
-        rule(:num) { semantic_disallow(label(:num, :digits), 'num.to_i > 200') }
-        rule(:digits) { match(/\d+/) }
-      end }
-      it { should parse('123a').succeeding.like reference_parser }
-      it { should parse('    ').failing.like reference_parser }
-      it { should parse('451a').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested choice rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_disallow(
-          match(/[[:alpha:]]+/) | match(/[[:digit:]]+/),
-          '_.size > 2'
-        )
-      end
-    end }
-
-    it { should parse('12abc').succeeding.like reference_parser }
-    it { should parse('abc123').failing.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
-        semantic_disallow(
-          match(/\w+/) & match('=') & match(/\w+/),
-          '|l,_,r| l == r'
-        )
-      end
-    end }
-    it { should parse('451a=123a ').succeeding.like reference_parser }
-    it { should parse('451a=451a ').failing.like reference_parser }
-
-    context 'with labels' do
-      let(:grammar) { define_grammar do
-        rule :assignment do
-          semantic_disallow(
-            label(:lt, /\w+/) & match('=') & label(:rt, /\w+/),
-            'lt == rt'
-          )
-        end
-      end }
-      it { should parse('451a=123a ').succeeding.like reference_parser }
-      it { should parse('451a=451a ').failing.like reference_parser }
-    end
-  end
-
-  context 'with a nested optional rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_disallow(optional(/\w+/), '|_| _.empty?')
-      end
-    end }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('foo ').succeeding.like reference_parser }
-  end
-
-  context 'with a nested zero-or-more rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_disallow(zero_or_more(/\w/), '|_| _.size > 3')
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('food').failing.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
-        semantic_disallow(one_or_more(/\w/), '|_| _.size > 3')
-      end
-    end }
-    it { should parse('foo ').succeeding.like reference_parser }
-    it { should parse('food').failing.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-
-  context 'with a nested list rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_disallow(list(/\w+/, /,/, 1, nil), '|_| _.size > 3')
-      end
-    end }
-    it { should parse('a,bc,d ').succeeding.like reference_parser }
-    it { should parse('a,b,c,d').failing.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) { semantic_disallow :digit, '_.to_i > 200' }
-      rule(:digit) { match /\d+/ }
-    end }
-    it { should parse('123a').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-    it { should parse('451a').failing.like reference_parser }
-  end
-
-  context 'with a nested token rule' do
-    let(:grammar) { define_grammar do
-      rule :foo do
-        semantic_disallow(token(/\w+/), '_.size > 5')
-      end
-    end }
-    it { should parse('abc12 ').succeeding.like reference_parser }
-    it { should parse('      ').failing.like reference_parser }
-    it { should parse('abc123').failing.like reference_parser }
-  end
-end

data/spec/rattler/back_end/side_effect_compiler_examples.rb

@@ -1,227 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-shared_examples_for 'a compiled parser with a side effect' 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) { side_effect(/\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) { side_effect(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) { side_effect :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) { side_effect(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) { side_effect(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) { side_effect(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) { side_effect(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) { side_effect(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
-        side_effect(
-          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
-        side_effect(
-          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
-          side_effect(
-            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
-        side_effect(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
-        side_effect(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
-        side_effect(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
-        side_effect(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
-          side_effect(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
-          side_effect(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
-          side_effect(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
-        side_effect(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) { side_effect :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
-        side_effect(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
-        side_effect(skip(/\w+/), '42' )
-      end
-    end }
-    it { should parse('abc123').succeeding.like reference_parser }
-    it { should parse('    ').failing.like reference_parser }
-  end
-end