rattler 0.3.0 → 0.4.0

data/lib/rattler/parsers/list.rb

@@ -15,41 +15,10 @@ module Rattler::Parsers
   #
   # @author Jason Arhart
   #
-  class List < Parser
-    include Combining
+  class List < ListParser
+    protected
 
-    # @private
-    def self.parsed(results, *_) #:nodoc:
-      self[*results]
-    end
-
-    # Create a new list parser that matches terms with +term_parser+ and
-    # separators with +sep_parser+
-    def self.[](term_parser, sep_parser)
-      self.new(term_parser, :sep_parser => sep_parser)
-    end
-
-    # Parse terms matched by the term parser in a list with separators matched
-    # by the separator parser. Return the terms in an array, or +true+ if the
-    # term parser is not <tt>capturing?</tt>.
-    #
-    # @param (see Parser#parse_labeled)
-    #
-    # @return [Array, true] an array containing the term parser's parse results,
-    #   or +true+ if the term parser is not <tt>capturing?</tt>
-    def parse(scanner, rules, labeled = {})
-      a = []
-      p = scanner.pos
-      while result = child.parse(scanner, rules)
-        p = scanner.pos
-        a << result
-        break unless sep_parser.parse(scanner, rules)
-      end
-      scanner.pos = p
-      capturing? ? a : true
-    end
-
-    def variable_capture_count?
+    def enough?(results)
       true
     end
 

data/lib/rattler/parsers/list1.rb

@@ -15,43 +15,11 @@ module Rattler::Parsers
   #
   # @author Jason Arhart
   #
-  class List1 < Parser
-    include Combining
+  class List1 < ListParser
+    protected
 
-    # @private
-    def self.parsed(results, *_) #:nodoc:
-      self[*results]
-    end
-
-    # Create a new list1 parser that matches terms with +term_parser+ and
-    # separators with +sep_parser+
-    def self.[](term_parser, sep_parser)
-      self.new(term_parser, :sep_parser => sep_parser)
-    end
-
-    # Parse terms matched by the term parser in a list with separators matched
-    # by the separator parser. Return the terms in an array, or +true+ if the
-    # term parser is not <tt>capturing?</tt>, or +false+ if no terms matched..
-    #
-    # @param (see Parser#parse_labeled)
-    #
-    # @return [Array, true] an array containing the term parser's parse results,
-    #   or +true+ if the term parser is not <tt>capturing?</tt>, or +false+ if
-    #   no terms matched.
-    def parse(scanner, rules, labeled = {})
-      a = []
-      p = scanner.pos
-      while result = child.parse(scanner, rules)
-        p = scanner.pos
-        a << result
-        break unless sep_parser.parse(scanner, rules)
-      end
-      scanner.pos = p
-      (capturing? ? a : true) unless a.empty?
-    end
-
-    def variable_capture_count?
-      true
+    def enough?(results)
+      not results.empty?
     end
 
   end

data/lib/rattler/parsers/list_parser.rb

@@ -0,0 +1,64 @@
+#
+# = rattler/parsers/list.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.
+  #
+  # @author Jason Arhart
+  #
+  class ListParser < Parser
+    include Combining
+
+    # @private
+    def self.parsed(results, *_) #:nodoc:
+      self[*results]
+    end
+
+    # Create a new list parser that matches terms with +term_parser+ and
+    # separators with +sep_parser+
+    def self.[](term_parser, sep_parser)
+      self.new(term_parser, sep_parser.skip)
+    end
+
+    def term_parser
+      children[0]
+    end
+
+    def sep_parser
+      children[1]
+    end
+
+    # Parse terms matched by the term parser in a list with separators matched
+    # by the separator parser. Return the terms in an array, or +true+ if the
+    # term parser is not <tt>capturing?</tt>.
+    #
+    # @param (see Parser#parse_labeled)
+    #
+    # @return [Array, true] an array containing the term parser's parse results,
+    #   or +true+ if the term parser is not <tt>capturing?</tt>
+    def parse(scanner, rules, scope = {})
+      a = []
+      p = scanner.pos
+      while result = term_parser.parse(scanner, rules, scope)
+        p = scanner.pos
+        a << result
+        break unless sep_parser.parse(scanner, rules, scope)
+      end
+      scanner.pos = p
+      (capturing? ? a : true) if enough? a
+    end
+
+    def variable_capture_count?
+      true
+    end
+
+  end
+end

data/lib/rattler/parsers/match.rb

@@ -16,7 +16,7 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Match < Parser
-    
+
     # Create a new parser that matches with +re+.
     #
     # @param [Regexp] re the pattern to match
@@ -26,62 +26,27 @@ module Rattler::Parsers
     def self.[](re)
       self.new(:re => re)
     end
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       self[eval(results.first)]
     end
-    
+
     # If the +Regexp+ matches at the parse position, return the matched
     # string, otherwise return a false value.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return the matched string, or +nil+
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope={})
       scanner.scan re
     end
-    
+
     # @param (see Parser#with_ws)
     # @return (see Parser#with_ws)
     def with_ws(ws)
-      Skip[ws] & self
-    end
-    
-    # @private
-    def re_optional #:nodoc:
-      Match[/#{atomic_re.source}?/]
-    end
-    
-    # @private
-    def re_zero_or_more #:nodoc:
-      Match[/#{atomic_re.source}*/]
-    end
-    
-    # @private
-    def re_one_or_more #:nodoc:
-      Match[/#{atomic_re.source}+/]
+      ws.skip & self
     end
-    
-    # @private
-    def assert_re #:nodoc:
-      /(?=#{re.source})/
-    end
-    
-    # @private
-    def disallow_re #:nodoc:
-      /(?!#{re.source})/
-    end
-    
-    # @private
-    def atomic_re #:nodoc:
-      /(?>#{re.source})/
-    end
-    
-    # @private
-    def as_match #:nodoc:
-      self
-    end
-    
+
   end
 end

data/lib/rattler/parsers/node_code.rb

@@ -0,0 +1,44 @@
+#
+# = rattler/parsers/node_code.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  # @private
+  class NodeCode #:nodoc:
+
+    def self.bindable_code(action)
+      self.new(action.target, action.method_name)
+    end
+
+    def initialize(target_name, method_name)
+      @target_name = target_name
+      @method_name = method_name
+    end
+
+    attr_reader :target_name, :method_name
+
+    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
+      t = target_name == 'self' ? '' : "#{target_name}."
+      "#{t}#{method_name}(#{args.join ', '})"
+    end
+
+    def array_expr(bind_args)
+      if bind_args.respond_to? :to_str
+        bind_args
+      else
+        '[' + bind_args.join(', ') + ']'
+      end
+    end
+
+  end
+end

data/lib/rattler/parsers/one_or_more.rb

@@ -16,12 +16,12 @@ module Rattler::Parsers
   #
   class OneOrMore < Parser
     include Combining
-    
+
     # Parse using the wrapped parser repeatedly until it fails. If the
     # wrapped parser succeeds at least once return the results in an array,
     # or +true+ if the wrapped parser is not <tt>capturing?</tt>.  Return
     # +false+ if the wrapped parser does not succeed at least once.
-    
+
     # Parse using the decorated parser as many times as it succeeds. If it does
     # not succeeds at least once return +false+, otherwise the results in an
     # array, or +true+ if the decorated parser is not <tt>capturing?</tt>.
@@ -29,39 +29,19 @@ module Rattler::Parsers
     # @param (see Parser#parse_labeled)
     #
     # @return [Array, Boolean] an array containing the decorated parser's parse
-    #   returns, or +true+ if the decorated parser is not <tt>capturing?</tt>,
+    #   results, or +true+ if the decorated parser is not <tt>capturing?</tt>,
     #   or +false+ if the decorated parser does not succeed at least once.
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       a = []
-      while result = child.parse(scanner, rules)
+      while result = child.parse(scanner, rules, scope)
         a << result
       end
       (capturing? ? a : true) unless a.empty?
     end
-    
+
     def variable_capture_count?
       true
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      to = super
-      if Match === to.child
-        to.child.re_one_or_more
-      else
-        to
-      end
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      to = super
-      if Match === to.child
-        to.child.re_one_or_more
-      else
-        to
-      end
-    end
-    
+
   end
 end

data/lib/rattler/parsers/optional.rb

@@ -15,7 +15,7 @@ module Rattler::Parsers
   #
   class Optional < Parser
     include Combining
-    
+
     # Parse using the decorated parser and always succeed. If the decorated
     # parser is <tt>capturing?</tt> return the result in an array, or an empty
     # array if the wrapped parser fails.  If the decorated parser is not
@@ -26,37 +26,17 @@ module Rattler::Parsers
     # @return [Array, true] an array containing the decorated parser's parse
     #   results if it matches or an empty array if not, or always +true+ if the
     #   decorated parser is not <tt>capturing?</tt>
-    def parse(scanner, rules, labeled = {})
-      if result = child.parse(scanner, rules)
+    def parse(scanner, rules, scope = {})
+      if result = child.parse(scanner, rules, scope)
         capturing? ? [result] : true
       else
         capturing? ? [] : true
       end
     end
-    
+
     def variable_capture_count?
       true
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      to = super
-      if Match === to.child
-        to.child.re_optional
-      else
-        to
-      end
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      so = super
-      if Match === so.child
-        so.child.re_optional
-      else
-        so
-      end
-    end
-    
+
   end
 end

data/lib/rattler/parsers/parser.rb

@@ -14,12 +14,12 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Parser < Rattler::Util::Node
-    
+
     # @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.
     #
@@ -28,11 +28,11 @@ module Rattler::Parsers
     def capturing?
       true
     end
-    
+
     def variable_capture_count?
       false
     end
-    
+
     # Return +true+ if the parser associates a label with parse results. Only
     # instances of +Label+ should return +true+.
     #
@@ -40,77 +40,49 @@ module Rattler::Parsers
     def labeled?
       false
     end
-    
-    # Parse and on success associate the label with the parse result if
-    # +labeled?+ and +capturing?+.
-    #
-    # @param [StringScanner] scanner the scanner used match patterns
-    # @param [Rules] rules the parse rules defining the parser
-    # @param [Hash] labeled a hash for associating labels with children
-    #
-    # @return the parse result on success, or a false value on failure
-    def parse_labeled(scanner, rules, labeled)
-      parse(scanner, rules, labeled)
-    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+
     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
     def &(other)
       Sequence[self, other]
     end
-    
+
     # @return a new parser that tries this parser but returns +true+ if it
     #   fails
     def optional
       Optional[self]
     end
-    
+
     # @return a new parser that tries this parser until it fails and returns
     #   all of the results
     def zero_or_more
       ZeroOrMore[self]
     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
     def one_or_more
       OneOrMore[self]
     end
-    
+
+    # @return a new parser that skips over what this parser matches
+    def skip
+      Skip[self]
+    end
+
     # @param [Parser] ws the parser used to skip whitespace
     # @return [Parser] a new parser that uses +ws+ to skip whitespace
     def with_ws(ws)
       self
     end
-    
-    # @return [Parser] a parser that parses identically but may have a more
-    #   optimized structure
-    def optimized
-      self
-    end
-    
-    # @private
-    def token_optimized #:nodoc:
-      self
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      self
-    end
-    
-    # @private
-    def as_match #:nodoc:
-      nil
-    end
-    
+
   end
 end