rattler 0.3.0 → 0.4.0

data/lib/rattler/parsers/parser_dsl.rb

@@ -20,7 +20,7 @@ module Rattler
       #
       # @option options [Parser] ws (nil) a parser to be used to skip whitespace
       #
-      # @return [Rattler::Parsers::Rules] a set of parse rules
+      # @return [Rattler::Parsers::RuleSet] a set of parse rules
       #
       def self.rules(options = {}, &block)
         self.new(options).rules(&block)
@@ -48,10 +48,10 @@ module Rattler
 
       # Evaluate the given block to define parse rules
       #
-      # @return [Rules] the rules defined in the block
+      # @return [RuleSet] the rules defined in the block
       def rules(&block)
         instance_exec(self, &block)
-        Rules[@rules]
+        RuleSet[@rules]
       end
 
       # Evaluate the given block to define a parse rule
@@ -104,6 +104,7 @@ module Rattler
         when :SPACE   then match /[[:space:]]/
         when :UPPER   then match /[[:upper:]]/
         when :XDIGIT  then match /[[:xdigit:]]/
+        when :WORD    then match /[[:alnum:]_]/
         when Symbol   then Apply[arg]
         else match Regexp.new(Regexp.escape(arg.to_s))
         end
@@ -133,6 +134,8 @@ module Rattler
         ZeroOrMore[to_parser(arg)]
       end
 
+      alias_method :any, :zero_or_more
+
       # Create a new one-or-more parser.
       #
       # @overload one_or_more(parser)
@@ -145,6 +148,8 @@ module Rattler
         OneOrMore[to_parser(arg)]
       end
 
+      alias_method :some, :one_or_more
+
       # Create a new list parser.
       #
       # @overload list(term_parser, sep_parser)
@@ -343,6 +348,11 @@ module Rattler
         match :XDIGIT
       end
 
+      # @return [Match] a parser matching the +word+ character class
+      def word
+        match :WORD
+      end
+
       private
 
       def to_parser(o)

data/lib/rattler/parsers/predicate.rb

@@ -10,26 +10,18 @@ require 'rattler/parsers'
 module Rattler::Parsers
   # @private
   class Predicate < Parser #:nodoc:
-    
+
     def self.parsed(results, *_)
       self[results.first]
     end
-    
+
     def capturing?
       false
     end
-    
+
     def with_ws(ws)
       self.class.new(child.with_ws(ws), attrs)
     end
-    
-    def token_optimized
-      optimized
-    end
-    
-    def skip_optimized
-      optimized
-    end
-    
+
   end
 end

data/lib/rattler/parsers/rule.rb

@@ -15,22 +15,19 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Rule < Rattler::Util::Node
-    
-    # @private
-    def self.parsed(results, *_) #:nodoc:
-      self[*results]
-    end
-    
+
     # Create a new +Rule+.
     #
     # @param [Symbol, String] name the name of the new rule
     # @param [Parser] parser the parser that defines the rule body
     #
     # @return [Rule] a new parse rule
-    def self.[](name, parser)
-      self.new(parser, :name => name.to_sym)
+    def self.[](name, parser, attrs={})
+      self.new(parser, attrs.merge(:name => name.to_sym))
     end
-    
+
+    alias_method :expr, :child
+
     # Parse using +scanner+ and +rules+ and on success return the result, on
     # failure return a false value.
     #
@@ -38,20 +35,22 @@ module Rattler::Parsers
     # @param rules (see Parser#parse_labeled)
     #
     # @return (see Parser#parse_labeled)
-    def parse(scanner, rules)
-      child.parse(scanner, rules)
+    def parse(scanner, rules, scope = {})
+      catch(:rule_failed) do
+        return expr.parse(scanner, rules, scope)
+      end
+      false
     end
-    
+
+    def with_expr(new_expr)
+      Rule[name, new_expr, attrs]
+    end
+
     # @param (see Parser#with_ws)
     # @return (see Parser#with_ws)
     def with_ws(ws)
-      Rule[name, child.with_ws(ws)]
+      self.with_expr expr.with_ws(ws)
     end
-    
-    # @return (see Parser#optimized)
-    def optimized
-      Rule[name, child.optimized]
-    end
-    
+
   end
 end

data/lib/rattler/parsers/rule_set.rb

@@ -0,0 +1,63 @@
+#
+# = rattler/parsers/rule_set.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  class RuleSet < Rattler::Util::Node
+
+    # @private
+    def self.parsed(results, *_) #:nodoc:
+      self.new(results)
+    end
+
+    def initialize(*args)
+      super
+      @by_name = {}
+      children.each {|rule| @by_name[rule.name] = rule }
+    end
+
+    alias_method :rules, :children
+
+    def start_rule
+      attrs[:start_rule]
+    end
+
+    def rule(name)
+      @by_name[name]
+    end
+
+    def [](*args)
+      if args.length == 1 and args[0].is_a?(Symbol)
+        rule(args[0])
+      else
+        super
+      end
+    end
+
+    def with_attrs(new_attrs)
+      self.class.new(children, attrs.merge(new_attrs))
+    end
+
+    def with_rules(new_rules)
+      self.class.new(new_rules, attrs)
+    end
+
+    def map_rules
+      self.with_rules rules.map {|_| yield _ }
+    end
+
+    def select_rules
+      self.with_rules rules.select {|_| yield _ }
+    end
+
+    def analysis
+      @analysis ||= Rattler::Grammar::Analysis.new(self)
+    end
+
+  end
+end

data/lib/rattler/parsers/sequence.rb

@@ -16,13 +16,12 @@ module Rattler::Parsers
   #
   class Sequence < Parser
     include Combining
-    include MatchJoining
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       results.reduce(:&)
     end
-    
+
     # Try each parser in sequence, and if they all succeed return an array of
     # captured results, or return +false+ if any parser fails.
     #
@@ -30,24 +29,29 @@ module Rattler::Parsers
     #
     # @return an array of captured results of each parser in sequence, or
     #   +false+
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
+      parse_and_yield_scope scanner, rules, scope
+    end
+
+    def parse_and_yield_scope(scanner, rules, scope = {})
       pos = scanner.pos
       results = []
       for child in children
-        if r = child.parse_labeled(scanner, rules, labeled)
+        if r = child.parse(scanner, rules, scope) {|_| scope = _ }
           results << r unless r == true
         else
           scanner.pos = pos
           return false
         end
       end
+      yield scope if block_given?
       case capture_count
       when 0 then true
       when 1 then results[0]
       else results
       end
     end
-    
+
     # Return a new parser that tries both this parser and +other+ and fails
     # unless both parse in sequence.
     #
@@ -56,51 +60,13 @@ module Rattler::Parsers
     def &(other)
       Sequence[(children + [other])]
     end
-    
+
     # The number of child parsers that are capturing
     #
     # @return the number of child parsers that are capturing
     def capture_count
       @capture_count ||= count {|_| _.capturing? }
     end
-    
-    protected
-    
-    def optimized_children
-      oc = super
-      if oc.count {|_| _.capturing? } == 1
-        flattened = flatten_sequences oc
-        if flattened.count {|_| _.capturing? } == 1
-          join_matches flattened
-        else
-          join_matches oc
-        end
-      else
-        oc
-      end
-    end
-    
-    def token_optimized_children
-      join_matches flatten_sequences(super)
-    end
-    
-    def skip_optimized_children
-      join_matches flatten_sequences(super)
-    end
-    
-    def match_join(matches)
-      matches.map {|_| _.atomic_re.source }.join
-    end
-    
-    private
-    
-    def flatten_sequences(parsers)
-      if parsers.all? {|_| Sequence === _ }
-        parsers.map {|_| _.to_a }.reduce(:+)
-      else
-        parsers
-      end
-    end
-    
+
   end
 end

data/lib/rattler/parsers/skip.rb

@@ -13,12 +13,12 @@ module Rattler::Parsers
   # the results
   #
   class Skip < Parser
-    
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       self[results.first]
     end
-    
+
     # If the decorated parser matches return +true+, otherwise return a false
     # value.
     #
@@ -26,43 +26,29 @@ module Rattler::Parsers
     #
     # @return [Boolean] +true+ if the decorated parser matches at the parse
     #   position
-    def parse(scanner, rules, labeled = {})
-      child.parse(scanner, rules) && true
+    def parse(scanner, rules, scope = {})
+      child.parse(scanner, rules, scope) && true
     end
-    
+
     # Always +false+
     # @return false
     def capturing?
       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)
-      Skip[child.with_ws(ws)]
-    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
-      Skip[child.skip_optimized]
+      child.with_ws(ws).skip
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      child.token_optimized
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      child.skip_optimized
+
+    # @return (see Parser#skip)
+    def skip
+      self
     end
-    
+
   end
 end

data/lib/rattler/parsers/token.rb

@@ -14,38 +14,23 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Token < Parser
-    
+
     # If the decorated parser matches return the entire matched string,
     # otherwise return a false value.
     #
     # @param (see Parser#parse_labeled)
     #
     # @return (see Match#parse)
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       p = scanner.pos
-      child.parse(scanner, rules) && scanner.string[p...(scanner.pos)]
+      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)
-      Skip[ws] & self
-    end
-    
-    # @return (see Parser#optimized)
-    def optimized
-      Token[child.token_optimized]
+      ws.skip & self
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      child.token_optimized
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      child.skip_optimized
-    end
-    
+
   end
 end

data/lib/rattler/parsers/zero_or_more.rb

@@ -15,7 +15,7 @@ module Rattler::Parsers
   #
   class ZeroOrMore < Parser
     include Combining
-    
+
     # Parse using the decorated parser as many times as it succeeds. Return the
     # results in an array, or +true+ if the decorated parser is not
     # <tt>capturing?</tt>.
@@ -23,38 +23,18 @@ module Rattler::Parsers
     # @param (see Parser#parse_labeled)
     #
     # @return [Array, true] an array containing the decorated parser's parse
-    #   returns, or +true+ if the decorated parser is not <tt>capturing?</tt>
-    def parse(scanner, rules, labeled = {})
+    #   results, or +true+ if the decorated parser is not <tt>capturing?</tt>
+    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
     end
-    
+
     def variable_capture_count?
       true
     end
-    
-    # @private
-    def token_optimized #:nodoc:
-      to = super
-      if Match === to.child
-        to.child.re_zero_or_more
-      else
-        to
-      end
-    end
-    
-    # @private
-    def skip_optimized #:nodoc:
-      so = super
-      if Match === so.child
-        so.child.re_zero_or_more
-      else
-        so
-      end
-    end
-    
+
   end
 end