rattler 0.3.0 → 0.4.0

data/lib/rattler/parsers/back_reference.rb

@@ -0,0 +1,46 @@
+#
+# = rattler/parsers/back_reference.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  #
+  # +BackReference+ matches the labeled result of an earlier match.
+  #
+  # @author Jason Arhart
+  #
+  class BackReference < Parser
+
+    def self.[](ref_label)
+      self.new(:ref_label => ref_label.to_sym)
+    end
+
+    def self.parsed(results, *_)
+      self[results.first[1..-1]]
+    end
+
+    def parse(scanner, rules, scope={})
+      scanner.scan Regexp.compile(Regexp.escape scope[ref_label])
+    end
+
+    def re_expr(scope)
+      "/#{re_source scope}/"
+    end
+
+    def re_source(scope)
+      '#{' + Regexp.escape(scope[ref_label].to_s) + '}'
+    end
+
+    # @param (see Parser#with_ws)
+    # @return (see Parser#with_ws)
+    def with_ws(ws)
+      ws.skip & self
+    end
+
+  end
+
+end

data/lib/rattler/parsers/choice.rb

@@ -16,27 +16,26 @@ module Rattler::Parsers
   #
   class Choice < Parser
     include Combining
-    include MatchJoining
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       results.reduce(:|)
     end
-    
+
     # Try each parser in order until one succeeds and return that result.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return the result of the first parser that matches, or +false+
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       for child in children
-        if r = child.parse_labeled(scanner, rules, labeled)
+        if r = child.parse(scanner, rules, scope)
           return r
         end
       end
       false
     end
-    
+
     # Return a new parser that tries this parser first and if it fails tries
     # +other+.
     #
@@ -45,38 +44,6 @@ module Rattler::Parsers
     def |(other)
       Choice[(children + [other])]
     end
-    
-    protected
-    
-    def optimized_children
-      join_matches super
-    end
-    
-    def token_optimized_children
-      join_matches super
-    end
-    
-    def skip_optimized_children
-      join_matches super
-    end
-    
-    def match_join(matches)
-      matches.map {|_| _.re.source }.join('|')
-    end
-    
-    def join_matches(parsers)
-      super flatten_choices(parsers)
-    end
-    
-    private
-    
-    def flatten_choices(parsers)
-      if parsers.all? {|_| Choice === _ }
-        parsers.map {|_| _.to_a }.reduce(:+)
-      else
-        parsers
-      end
-    end
-    
+
   end
 end

data/lib/rattler/parsers/combinator_parser.rb

@@ -0,0 +1,32 @@
+#
+# = rattler/parsers/rule_set.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  class CombinatorParser < Rattler::Runtime::Parser
+
+    def self.as_class(start_rule, rule_set)
+      new_class = Class.new(self)
+      new_class.send :define_method, :initialize do |source|
+        super source, start_rule, rule_set
+      end
+      new_class
+    end
+
+    def initialize(source, start_rule, rule_set)
+      super source
+      @start_rule = start_rule
+      @rule_set = rule_set
+    end
+
+    def __parse__
+      @start_rule.parse(@scanner, @rule_set)
+    end
+
+  end
+end

data/lib/rattler/parsers/combining.rb

@@ -8,40 +8,14 @@
 module Rattler::Parsers
   # @private
   module Combining #:nodoc:
-    
+
     def capturing?
       @capturing ||= any? {|child| child.capturing? }
     end
-    
+
     def with_ws(ws)
       self.class.new(children.map {|_| _.with_ws(ws) }, attrs)
     end
-    
-    def optimized
-      self.class.new(optimized_children, attrs)
-    end
-    
-    def token_optimized
-      self.class.new(token_optimized_children, attrs)
-    end
-    
-    def skip_optimized
-      self.class.new(skip_optimized_children, attrs)
-    end
-    
-    protected
-    
-    def optimized_children
-      children.map {|_| _.optimized }
-    end
-    
-    def token_optimized_children
-      children.map {|_| _.token_optimized }
-    end
-    
-    def skip_optimized_children
-      children.map {|_| _.skip_optimized }
-    end
-    
+
   end
 end

data/lib/rattler/parsers/direct_action.rb

@@ -16,16 +16,16 @@ module Rattler::Parsers
   #
   class DirectAction < Parser
     include Combining
-    
+
     def self.[](child, code)
       self.new(child, :code => code)
     end
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       self[*results]
     end
-    
+
     # If the wrapped parser matches at the parse position, return the result
     # of applying the symantic action, otherwise return a false value.
     #
@@ -33,48 +33,45 @@ module Rattler::Parsers
     #
     # @return the result of applying the symantic action, or a false value if
     #   the parse failed.
-    def parse(scanner, rules, l = {})
-      labeled = {}
-      if result = child.parse(scanner, rules, labeled)
+    def parse(scanner, rules, scope = {})
+      if result = parse_child(child, scanner, rules, scope) {|_| scope = _ }
         if not capturing?
           apply([])
         elsif result.respond_to?(:to_ary)
-          apply(result, labeled)
+          apply(result, scope)
         else
-          apply([result], labeled)
+          apply([result], scope)
         end
       end
     end
-    
+
     def bindable_code
       @bindable_code ||= ActionCode.new(code)
     end
-    
-    def bind(*args)
-      bindable_code.bind(*args)
-    end
-    
-    # @private
-    def token_optimized #:nodoc:
-      child.token_optimized
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      child.skip_optimized
+
+    def bind(scope, bind_args)
+      bindable_code.bind(scope, bind_args)
     end
-    
+
     private
-    
-    def apply(results, labeled={})
-      l = {}
-      labeled.each {|k, v| l[k] = v.inspect }
+
+    def parse_child(child, scanner, rules, scope)
+      if child.is_a? Sequence
+        child.parse_and_yield_scope(scanner, rules, scope) {|_| yield _ }
+      else
+        child.parse(scanner, rules, scope) {|_| yield _ }
+      end
+    end
+
+    def apply(results, scope={})
+      code_scope = {}
+      scope.each {|k, v| code_scope[k] = v.inspect }
       if child.variable_capture_count?
-        eval(bind([results.inspect], l))
+        eval(bind(code_scope, [results.inspect]))
       else
-        eval(bind(results.map {|_| _.inspect }, l))
+        eval(bind(code_scope, results.map {|_| _.inspect }))
       end
     end
-    
+
   end
 end

data/lib/rattler/parsers/disallow.rb

@@ -13,33 +13,19 @@ module Rattler::Parsers
   # and vice versa.
   #
   class Disallow < Predicate
-    
+
     # Succeed and return +true+ if and only if decorated parser fails.  Never
     # consumes any input.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return [Boolean] +true+ if the decorated parser fails
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       pos = scanner.pos
-      result = !child.parse(scanner, rules)
+      result = !child.parse(scanner, rules, scope)
       scanner.pos = pos
       result
     end
-    
-    # Return a parser that parses identically but may have a more optimized
-    # structure.
-    #
-    # @return a parser that parses identically but may have a more optimized
-    #   structure
-    def optimized
-      Disallow[child.optimized]
-    end
-    
-    # @private
-    def as_match #:nodoc:
-      Match[child.disallow_re] if Match === child
-    end
-    
+
   end
 end

data/lib/rattler/parsers/dispatch_action.rb

@@ -16,19 +16,19 @@ module Rattler::Parsers
   #
   class DispatchAction < Parser
     include Combining
-    
+
     # @private
     @@node_defaults = {
       :target => 'Rattler::Runtime::ParseNode',
       :method => 'parsed'
     }
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       attributed, optional_attribute = results
       self[attributed, optional_attribute.first || @@node_defaults[:target]]
     end
-    
+
     # @private
     def self.parse_attrs_arg(arg) #:nodoc:
       case arg
@@ -40,7 +40,7 @@ module Rattler::Parsers
         { :target => arg.to_s.strip }
       end
     end
-    
+
     # Create a new parser that decorates a parser to peform a symantic
     # on success.
     #
@@ -60,10 +60,10 @@ module Rattler::Parsers
       @@node_defaults.each {|k, v| attrs[k] ||= v } unless attrs[:code]
       @method_name = attrs[:method]
     end
-    
+
     # the name of the method used as the symantic action
     attr_reader :method_name
-    
+
     # If the wrapped parser matches at the parse position, return the result
     # of applying the symantic action, otherwise return a false value.
     #
@@ -71,39 +71,44 @@ module Rattler::Parsers
     #
     # @return the result of applying the symantic action, or a false value if
     #   the parse failed.
-    def parse(scanner, rules, l = {})
-      labeled = {}
-      if result = child.parse(scanner, rules, labeled)
+    def parse(scanner, rules, scope = {})
+      if result = parse_child(child, scanner, rules, scope) {|_| scope = _ }
         if not capturing?
           apply([])
         elsif result.respond_to?(:to_ary)
-          apply(result, labeled)
+          apply(result, scope)
         else
-          apply([result], labeled)
+          apply([result], scope)
         end
       end
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      child.token_optimized
+
+    def bindable_code
+      @bindable_code ||= NodeCode.new(target, method_name)
     end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      child.skip_optimized
+
+    def bind(scope, bind_args)
+      bindable_code.bind(scope, bind_args)
     end
-    
+
     private
-    
-    def apply(results, labeled={})
-      attrs = labeled.empty? ? {} : {:labeled => labeled}
+
+    def parse_child(child, scanner, rules, scope)
+      if child.is_a? Sequence
+        child.parse_and_yield_scope(scanner, rules, scope) {|_| yield _ }
+      else
+        child.parse(scanner, rules, scope) {|_| yield _ }
+      end
+    end
+
+    def apply(results, scope={})
+      attrs = scope.empty? ? {} : {:labeled => scope}
       target_class.send method_name, results, attrs
     end
-    
+
     def target_class
       @target_class ||= target.split('::').inject(Kernel, :const_get)
     end
-    
+
   end
 end

data/lib/rattler/parsers/label.rb

@@ -17,45 +17,36 @@ module Rattler::Parsers
   #
   class Label < Parser
     include Combining
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       self[*results]
     end
-    
+
     # Create a new parser that decorates +parser+ and associates +label+ with
     # +parser+'s parse result on success.
     def self.[](label, parser)
       self.new(parser, :label => label.to_sym)
     end
-    
+
     # Always +true+
     # @return true
     def labeled?
       true
     end
-    
+
     # Delegate to the decorated parser and associate #label with the parse
     # result if successful.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return the decorated parser's parse result
-    def parse(scanner, rules, labeled = {})
-      child.parse(scanner, rules, labeled)
-    end
-    
-    # Parse and on success associate the label with the parse result if
-    # +capturing?+.
-    #
-    # @param (see Parser#parse_labeled)
-    # @return (see Parser#parse_labeled)
-    def parse_labeled(scanner, rules, labeled)
-      if r = super
-        labeled[label] = r if capturing?
-        r
+    def parse(scanner, rules, scope = {})
+      if result = child.parse(scanner, rules, scope) {|_| scope = _ }
+        yield scope.merge(label => result) if block_given?
+        result
       end
     end
-    
+
   end
 end