rattler 0.4.2 → 0.5.0

data/lib/rattler/parsers/predicate.rb

@@ -10,6 +10,7 @@ require 'rattler/parsers'
 module Rattler::Parsers
   # @private
   class Predicate < Parser #:nodoc:
+    include Combining
 
     def self.parsed(results, *_)
       self[results.first]
@@ -19,9 +20,5 @@ module Rattler::Parsers
       false
     end
 
-    def with_ws(ws)
-      self.class.new(child.with_ws(ws), attrs)
-    end
-
   end
 end

data/lib/rattler/parsers/repeat.rb

@@ -0,0 +1,76 @@
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  #
+  # +Repeat+ decorates a parser with repeat counts to match repeatedly (up to
+  # the upper bound, if given) and succeed if the decorated parser succeeds at
+  # least as many times as specified by the lower bound.
+  #
+  # @author Jason Arhart
+  #
+  class Repeat < Parser
+    include Combining
+
+    def self.[](parser, lower_bound, upper_bound)
+      self.new(parser, :lower_bound => lower_bound, :upper_bound => upper_bound)
+    end
+
+    # @private
+    def self.parsed(results, *_) #:nodoc
+      parser, bounds = results
+      self[parser, *bounds]
+    end
+
+    # Parse using the wrapped parser repeatedly until it fails or the upper
+    # bound is reached. If the wrapped parser succeeds at least as many times
+    # as specified by the lower bound, return the results in an array, or
+    # +true+ if the wrapped parser is not <tt>capturing?</tt>.  Return +false+
+    # if the lower bound is not reached.
+    #
+    # @param (see Parser#parse_labeled)
+    #
+    # @return [Array, Boolean] an array containing the decorated parser's parse
+    #   results, or +true+ if the decorated parser is not <tt>capturing?</tt>,
+    #   or +false+ if the decorated parser does not succeed up to the lower
+    #   bound.
+    def parse(scanner, rules, scope = {})
+      a = []
+      start_pos = scanner.pos
+      while result = child.parse(scanner, rules, scope)
+        a << result
+        break if upper_bound? and a.size >= upper_bound
+      end
+      if a.size >= lower_bound
+        capturing? ? a : true
+      else
+        scanner.pos = start_pos
+        false
+      end
+    end
+
+    def zero_or_more?
+      lower_bound == 0 and not upper_bound?
+    end
+
+    def one_or_more?
+      lower_bound == 1 and not upper_bound?
+    end
+
+    def optional?
+      lower_bound == 0 and upper_bound == 1
+    end
+
+    def lower_bound?
+      lower_bound > 0
+    end
+
+    def upper_bound?
+      not upper_bound.nil?
+    end
+
+    def variable_capture_count?
+      true
+    end
+
+  end
+end

data/lib/rattler/parsers/semantic_assert.rb

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

data/lib/rattler/parsers/semantic_disallow.rb

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

@@ -0,0 +1,19 @@
+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/lib/rattler/parsers/skip.rb

@@ -13,6 +13,7 @@ module Rattler::Parsers
   # the results
   #
   class Skip < Parser
+    include Combining
 
     # @private
     def self.parsed(results, *_) #:nodoc:
@@ -36,15 +37,6 @@ module Rattler::Parsers
       false
     end
 
-    # Return a new parser that uses +ws+ to skip whitespace before matching
-    # tokens.
-    #
-    # @param (see Parser#with_ws)
-    # @return (see Parser#with_ws)
-    def with_ws(ws)
-      child.with_ws(ws).skip
-    end
-
     # @return (see Parser#skip)
     def skip
       self

data/lib/rattler/parsers/token.rb

@@ -14,6 +14,7 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Token < Parser
+    include Atomic
 
     # If the decorated parser matches return the entire matched string,
     # otherwise return a false value.
@@ -26,11 +27,5 @@ module Rattler::Parsers
       child.parse(scanner, rules, scope) && scanner.string[p...(scanner.pos)]
     end
 
-    # @param (see Parser#with_ws)
-    # @return (see Parser#with_ws)
-    def with_ws(ws)
-      ws.skip & self
-    end
-
   end
 end

data/lib/rattler/util/graphviz/node_builder.rb

@@ -50,7 +50,7 @@ module Rattler::Util::GraphViz
     # @return the label option for a node representing +o+.
     def node_label(o)
       if o.is_a? ::Rattler::Util::Node
-        record_label(o, o.attrs)
+        record_label(o, parse_node_fields(o.attrs))
       elsif record_like? o
         record_label(o, o)
       elsif array_like? o
@@ -81,8 +81,7 @@ module Rattler::Util::GraphViz
       o.none? {|k, v| array_like? v or record_like? v }
     end
 
-    def record_label(o, h)
-      fields = h.reject {|k,v| k == :name }
+    def record_label(o, fields)
       '{' + ([type_label(o)] + hash_content_labels(fields)).join('|') + '}'
     end
 
@@ -90,6 +89,10 @@ module Rattler::Util::GraphViz
       h.map {|pair| '{' + pair.map {|_| _.inspect }.join('|') + '}' }
     end
 
+    def parse_node_fields(attrs)
+      attrs.reject {|k,| k == :name || k == :labeled }
+    end
+
     # @private
     class Mapping #:nodoc:
       def initialize(key, value)

data/spec/rattler/back_end/assert_compiler_examples.rb

@@ -0,0 +1,187 @@
+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/direct_action_compiler_examples.rb

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