rattler 0.5.0 → 0.6.0

data/lib/rattler/parsers/label.rb

@@ -1,20 +1,10 @@
-#
-# = rattler/parsers/label.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Label+ decorates a parser and associates a label with the decorated
   # parser's parse result if successful. The label only applies if nested in a
   # +Choice+ or +Sequence+ decorated by an +Action+.
-  #
-  # @author Jason Arhart
-  #
   class Label < Parser
     include Combining
 
@@ -29,8 +19,12 @@ module Rattler::Parsers
       self.new(parser, :label => label.to_sym)
     end
 
-    # Always +true+
-    # @return true
+    # (see Parser#capturing_decidable?)
+    def capturing_decidable?
+      child.capturing_decidable?
+    end
+
+    # @return +true+
     def labeled?
       true
     end
@@ -38,12 +32,12 @@ module Rattler::Parsers
     # Delegate to the decorated parser and associate #label with the parse
     # result if successful.
     #
-    # @param (see Parser#parse_labeled)
+    # @param (see Match#parse)
     #
     # @return the decorated parser's parse result
-    def parse(scanner, rules, scope = {})
+    def parse(scanner, rules, scope = ParserScope.empty)
       if result = child.parse(scanner, rules, scope) {|_| scope = _ }
-        yield scope.merge(label => result) if block_given?
+        yield scope.bind(label => result) if block_given?
         result
       end
     end

data/lib/rattler/parsers/list_parser.rb

@@ -1,21 +1,11 @@
-#
-# = rattler/parsers/list_parser.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +ListParser+ matches terms matched by a term parser in a list with
   # separators matched by a separator parser. +ListParser+ fails unless at
   # least <tt>#lower_bound</tt> terms are matched and stops matching at
   # <tt>#upper_bound</tt>.
-  #
-  # @author Jason Arhart
-  #
   class ListParser < Parser
     include Combining
 
@@ -25,15 +15,22 @@ module Rattler::Parsers
       self[term_parser, sep_parser, *bounds]
     end
 
+    # @param [Parser] term_parser the parser for matching list terms
+    # @param [Parser] sep_parser the parser for matching the list separator
+    # @param [Integer] lower_bound the minimum number of terms to match
+    # @param [Integer] upper_bound the maximum number of terms to match
+    # @return [ListParser] a parser that matches lists
     def self.[](term_parser, sep_parser, lower_bound, upper_bound)
       self.new(term_parser, sep_parser.skip,
                 :lower_bound => lower_bound, :upper_bound => upper_bound)
     end
 
+    # @return [Parser] the parser for matching list terms
     def term_parser
       children[0]
     end
 
+    # @return [Parser] the parser for matching the list separator
     def sep_parser
       children[1]
     end
@@ -44,12 +41,12 @@ module Rattler::Parsers
     # least <tt>#lower_bound</tt> terms are matched and stops matching at
     # <tt>#upper_bound</tt>.
     #
-    # @param (see Parser#parse_labeled)
+    # @param (see Match#parse)
     #
-    # @return [Array, Boolean] an array containing the term parser's parse
+    # @return [Array or Boolean] an array containing the term parser's parse
     #   results, or +true+ if the term parser is not <tt>capturing?</tt> or
     #   +false+ if the parse fails.
-    def parse(scanner, rules, scope = {})
+    def parse(scanner, rules, scope = ParserScope.empty)
       a = []
       p = start_pos = scanner.pos
       while result = term_parser.parse(scanner, rules, scope) and
@@ -67,14 +64,17 @@ module Rattler::Parsers
       end
     end
 
+    # @return [Fixnum] lower_bound the minimum number of terms to match
     def lower_bound?
       lower_bound > 0
     end
 
+    # @return [Fixnum] upper_bound the maximum number of terms to match
     def upper_bound?
       not upper_bound.nil?
     end
 
+    # @return +true+
     def variable_capture_count?
       true
     end

data/lib/rattler/parsers/match.rb

@@ -1,29 +1,15 @@
-#
-# = rattler/parsers/match.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Match+ parses by matching with a +Regexp+. If the +Regexp+ matches at
   # the parse position the entire matched string is returned, otherwise the
   # parse fails.
-  #
-  # @author Jason Arhart
-  #
   class Match < Parser
     include Atomic
 
-    # Create a new parser that matches with +re+.
-    #
     # @param [Regexp] re the pattern to match
-    #
     # @return [Match] a new match parser that matches with +re+
-    #
     def self.[](re)
       self.new(:re => re)
     end
@@ -36,10 +22,12 @@ module Rattler::Parsers
     # If the +Regexp+ matches at the parse position, return the matched
     # string, otherwise return a false value.
     #
-    # @param (see Parser#parse_labeled)
+    # @param [StringScanner] scanner the scanner for the current parse
+    # @param [RuleSet] rules the grammar rules being used for the current parse
+    # @param [ParserScope] scope the scope of captured results
     #
     # @return the matched string, or +nil+
-    def parse(scanner, rules, scope={})
+    def parse(scanner, rules, scope = ParserScope.empty)
       scanner.scan re
     end
 

data/lib/rattler/parsers/node_action.rb

@@ -0,0 +1,72 @@
+module Rattler::Parsers
+
+  # +NodeAction+ is a pseudo-parser that creates a parse node object from
+  # captured parse results
+  class NodeAction < Parser
+    include Semantic
+
+    DEFAULT_NODE_TYPE = 'Rattler::Runtime::ParseNode'
+    DEFAULT_FACTORY_METHOD = :parsed
+
+    # @private
+    def self.parsed(results, *_) #:nodoc:
+      optional_node_def, optional_name = results
+      attrs = {}
+      unless optional_name.empty?
+        attrs[:node_attrs] = {:name => eval(optional_name[0], TOPLEVEL_BINDING)}
+      end
+      if optional_node_def.empty?
+        self[DEFAULT_NODE_TYPE, attrs]
+      else
+        node_type, optional_method = optional_node_def[0]
+        attrs[:method] = optional_method[0] unless optional_method.empty?
+        self[node_type, attrs]
+      end
+    end
+
+    # @param [String,Symbol] node_type the name of the class to instantiate
+    #   nodes from
+    # @param [Hash] attrs attributes defining how to instantiate the node
+    # @option attrs [Hash] :node_attrs ({}) attributes to add to new parse
+    #   nodes
+    # @option attrs [Strin,Symbol] :method (:parsed) the class method used to
+    #   create new parse nodes
+    # @return [NodeAction] a pseudo-parser that creates parse nodes
+    def self.[](node_type, attrs={})
+      self.new(attrs.merge :node_type => node_type)
+    end
+
+    # @return [Symbol] the name of the class to instantiate nodes from
+    def node_type
+      (attrs[:node_type] || DEFAULT_NODE_TYPE).to_sym
+    end
+
+    # @return [Hash] attributes to add to the instantiated node
+    def node_attrs
+      attrs[:node_attrs] || {}
+    end
+
+    # @return [Symbol] the class method used to create new parse nodes
+    def factory_method
+      (attrs[:method] || DEFAULT_FACTORY_METHOD).to_sym
+    end
+
+    # Create a new parse node from parse results in +scope+
+    #
+    # @param (see Match#parse)
+    #
+    # @return a new parse node created from parse results in +scope+
+    def parse(scanner, rules, scope = ParserScope.empty)
+      apply scope
+    end
+
+    protected
+
+    # @return [NodeCode] an object that be bound to a parser scope to return
+    #   ruby code that creates a new node
+    def create_bindable_code
+      NodeCode.new(node_type, factory_method, node_attrs)
+    end
+
+  end
+end

data/lib/rattler/parsers/node_code.rb

@@ -1,45 +1,62 @@
-#
-# = rattler/parsers/node_code.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  # @private
+
+  # +NodeCode+ defines a set of attributes that can be found to captured parse
+  # returns to produce ruby code that creates a new node from the parse results.
   class NodeCode #:nodoc:
 
-    def self.bindable_code(action)
-      self.new(action.target, action.method_name)
+    # @param [Symbol] node_type the name of the class to instantiate nodes from
+    # @param [Symbol] factory_method the class method used to create new parse
+    #   nodes
+    # @param [Hash] node_attrs attributes to add to new parse nodes
+    def initialize(node_type, factory_method, node_attrs)
+      @node_type = node_type
+      @factory_method = factory_method
+      @node_attrs = node_attrs
+    end
+
+    attr_reader :node_type, :factory_method, :node_attrs
+
+    # @param [ParserScope] scope the scope of captured parse results
+    # @return [String] ruby code that creates a new node from the parse results
+    def bind(scope)
+      "#{node_type}.#{factory_method}(#{args_expr scope})"
     end
 
-    def initialize(target_name, method_name, target_attrs = {})
-      @target_name = target_name
-      @method_name = method_name
-      @target_attrs = target_attrs
+    # @param [ParserScope] scope the scope of captured parse results
+    # @return [String] ruby code for the arguments to the node factory method
+    def args_expr(scope)
+      args = [captures_expr(scope)]
+      attrs = encoded_binding_attrs(scope).merge encoded_node_attrs(scope)
+      args << encode_assocs(attrs) unless attrs.empty?
+      args.join(', ')
     end
 
-    attr_reader :target_name, :method_name, :target_attrs
+    # @param [ParserScope] scope the scope of captured parse results
+    # @return [String] ruby code for the captures argument to the node factory
+    #   method
+    def captures_expr(scope)
+      expr = '[' + scope.captures.join(', ') + ']'
+      scope.captures_decidable? ? expr : "select_captures(#{expr})"
+    end
+
+    private
+
+    def encoded_binding_attrs(scope)
+      scope.bindings.empty? ? {} : { :labeled => encode_hash(scope.bindings) }
+    end
+
+    def encoded_node_attrs(scope)
+      node_attrs.map {|k, v| {k => v.inspect} }.inject({}, &:merge)
+    end
 
-    def bind(scope, bind_args)
-      args = [array_expr(bind_args)]
-      if not scope.empty?
-        labeled = '{' + scope.map {|k, v| ":#{k} => #{v}"}.join(', ') + '}'
-        args << ":labeled => #{labeled}"
-      end
-      target_attrs.each {|k, v| args << ":#{k} => #{v.inspect}" }
-      t = target_name == 'self' ? '' : "#{target_name}."
-      "#{t}#{method_name}(#{args.join ', '})"
+    def encode_hash(h)
+      "{#{encode_assocs h}}"
     end
 
-    def array_expr(bind_args)
-      if bind_args.respond_to? :to_str
-        bind_args
-      else
-        '[' + bind_args.join(', ') + ']'
-      end
+    def encode_assocs(h)
+      h.map {|k, v| ":#{k} => #{v}" }.join(', ')
     end
 
   end

data/lib/rattler/parsers/parser.rb

@@ -1,79 +1,110 @@
-#
-# = rattler/parsers/parser.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Parser+ is the base class for all of Rattler's combinator parser types.
-  #
-  # @author Jason Arhart
-  #
   class Parser < Rattler::Util::Node
 
+    include Rattler::Runtime::ParserHelper
+
     # @private
     def self.parsed(*args) #:nodoc:
       self[*args]
     end
 
-    # Return +true+ if the parser returns parse results on success, or
-    # +false+ if the parser simply returns +true+ on success.
-    #
-    # @return [Boolean] +true+ if the parser returns parse results on
-    #   success, or +false+ if the parser simply returns +true+ on success
+    # @return +true+ if the parser returns parse results on success, or +false+
+    #   if the parser simply returns +true+ on success
     def capturing?
       true
     end
 
+    # @return +true+ if the number of parse results returned by the parser
+    #   varies based on the input
     def variable_capture_count?
       false
     end
 
-    # Return +true+ if the parser associates a label with parse results. Only
+    # @return +true+ if it can be determined statically whether the parser
+    #   returns parse results on success
+    def capturing_decidable?
+      true
+    end
+
+    # +true+ if the parser associates a label with parse results. Only
     # instances of +Label+ should return +true+.
     #
-    # @return [Boolean] +true+ if the parser associates a label with parse results
+    # @return +true+ if the parser associates a label with parse
+    #   results
     def labeled?
       false
     end
 
+    # @return +true+ if the parser is a sequence
+    def sequence?
+      false
+    end
+
+    # @return +true+ if the parser is a semantic action
+    def semantic?
+      false
+    end
+
     # @param [Parser] other the parser to try if this parser fails.
-    # @return a new parser that tries this parser first and if it fails tries
-    #   +other+
+    # @return [Choice] a new parser that tries this parser first and if it
+    #   fails tries +other+
     def |(other)
       Choice[self, other]
     end
 
     # @param [Parser] other the next parser to try if this parser succeeds.
-    # @return a new parser that tries both this parser and +other+ and fails
-    #   unless both parse in sequence
+    # @return [Sequence] a new parser that tries both this parser and +other+
+    #   and fails unless both parse in sequence
     def &(other)
       Sequence[self, other]
     end
 
-    # @return a new parser that tries this parser but returns +true+ if it
-    #   fails
+    # @param [Parser] semantic a semantic action.
+    # @return [AttributedSequence] a new parser that tries this parser and
+    #   returns the result of the semantic action if it succeeds
+    def >>(semantic)
+      AttributedSequence[self, semantic]
+    end
+
+    # @param [Integer] lower_bound the minimum number of times to match
+    # @param [Integer] upper_bound the maximum number of times to match
+    # @return [Repeat] a new parser that tries this parser repeatedly
+    def repeat(lower_bound, upper_bound)
+      Repeat[self, lower_bound, upper_bound]
+    end
+
+    # @return [Repeat] a new parser that tries this parser but returns +true+
+    #   if it fails
     def optional
-      Optional[self]
+      repeat(0, 1)
     end
 
-    # @return a new parser that tries this parser until it fails and returns
-    #   all of the results
+    # @return [Repeat] a new parser that tries this parser until it fails
+    #   and returns all of the results
     def zero_or_more
-      ZeroOrMore[self]
+      repeat(0, nil)
     end
 
-    # @return a new parser that tries this parser until it fails and returns
-    #   all of the results if it succeeded at least once and fails otherwise
+    # @return [Repeat] a new parser that tries this parser until it fails
+    #   and returns all of the results if it succeeded at least once and fails
+    #   otherwise
     def one_or_more
-      OneOrMore[self]
+      repeat(1, nil)
+    end
+
+    # @param [Parser] sep_parser the parser for matching the list separator
+    # @param [Integer] lower_bound the minimum number of times to match
+    # @param [Integer] upper_bound the maximum number of times to match
+    # @return [Repeat] a new parser that matches lists with this parser
+    def list(sep_parser, lower_bound, upper_bound)
+      ListParser[self, sep_parser, lower_bound, upper_bound]
     end
 
-    # @return a new parser that skips over what this parser matches
+    # @return [Skip] a new parser that skips over what this parser matches
     def skip
       Skip[self]
     end