rattler 0.4.2 → 0.5.0

data/lib/rattler/parsers.rb

@@ -22,18 +22,18 @@ module Rattler
     autoload :Match, 'rattler/parsers/match'
     autoload :Choice, 'rattler/parsers/choice'
     autoload :Sequence, 'rattler/parsers/sequence'
-    autoload :Optional, 'rattler/parsers/optional'
-    autoload :ZeroOrMore, 'rattler/parsers/zero_or_more'
-    autoload :OneOrMore, 'rattler/parsers/one_or_more'
+    autoload :Repeat, 'rattler/parsers/repeat'
     autoload :ListParser, 'rattler/parsers/list_parser'
-    autoload :List0, 'rattler/parsers/list0'
-    autoload :List1, 'rattler/parsers/list1'
     autoload :Apply, 'rattler/parsers/apply'
     autoload :Assert, 'rattler/parsers/assert'
     autoload :Disallow, 'rattler/parsers/disallow'
     autoload :Eof, 'rattler/parsers/eof'
+    autoload :ESymbol, 'rattler/parsers/e_symbol'
     autoload :DispatchAction, 'rattler/parsers/dispatch_action'
     autoload :DirectAction, 'rattler/parsers/direct_action'
+    autoload :SemanticAssert, 'rattler/parsers/semantic_assert'
+    autoload :SemanticDisallow, 'rattler/parsers/semantic_disallow'
+    autoload :SideEffect, 'rattler/parsers/side_effect'
     autoload :Token, 'rattler/parsers/token'
     autoload :Skip, 'rattler/parsers/skip'
     autoload :Label, 'rattler/parsers/label'
@@ -41,9 +41,13 @@ module Rattler
     autoload :Fail, 'rattler/parsers/fail'
     autoload :ParserDSL, 'rattler/parsers/parser_dsl'
     autoload :Predicate, 'rattler/parsers/predicate'
+    autoload :Atomic, 'rattler/parsers/atomic'
     autoload :Combining, 'rattler/parsers/combining'
     autoload :MatchJoining, 'rattler/parsers/match_joining'
     autoload :ActionCode, 'rattler/parsers/action_code'
+    autoload :EffectCode, 'rattler/parsers/effect_code'
+    autoload :AssertCode, 'rattler/parsers/assert_code'
+    autoload :DisallowCode, 'rattler/parsers/disallow_code'
     autoload :NodeCode, 'rattler/parsers/node_code'
 
     class <<self

data/lib/rattler/parsers/assert_code.rb

@@ -0,0 +1,31 @@
+#
+# = rattler/parsers/assert_code.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  # @private
+  class AssertCode < ActionCode #:nodoc:
+
+    def bind(scope, bind_args)
+      "(#{super}) && #{result_code bind_args}"
+    end
+
+    private
+
+    def result_code(bind_args)
+      if bind_args.size > 1
+        '[' + bind_args.join(', ') + ']'
+      elsif bind_args.size == 1
+        bind_args.first
+      else
+        'true'
+      end
+    end
+
+  end
+end

data/lib/rattler/parsers/atomic.rb

@@ -0,0 +1,19 @@
+#
+# = rattler/parsers/atomic.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+module Rattler::Parsers
+  # @private
+  module Atomic #:nodoc:
+
+    # @param (see Parser#with_ws)
+    # @return (see Parser#with_ws)
+    def with_ws(ws)
+      ws.skip & self
+    end
+
+  end
+end

data/lib/rattler/parsers/direct_action.rb

@@ -18,12 +18,14 @@ module Rattler::Parsers
     include Combining
 
     def self.[](child, code)
-      self.new(child, :code => code)
+      self.new(child, :code => code.strip)
     end
 
     # @private
     def self.parsed(results, *_) #:nodoc:
-      self[*results]
+      optional_expr, code = results
+      expr = optional_expr.first || ESymbol[]
+      self[expr, code]
     end
 
     # If the wrapped parser matches at the parse position, return the result
@@ -35,7 +37,7 @@ module Rattler::Parsers
     #   the parse failed.
     def parse(scanner, rules, scope = {})
       if result = parse_child(child, scanner, rules, scope) {|_| scope = _ }
-        if not capturing?
+        if not child.capturing?
           apply([])
         elsif result.respond_to?(:to_ary)
           apply(result, scope)
@@ -46,13 +48,19 @@ module Rattler::Parsers
     end
 
     def bindable_code
-      @bindable_code ||= ActionCode.new(code)
+      @bindable_code ||= create_bindable_code
     end
 
     def bind(scope, bind_args)
       bindable_code.bind(scope, bind_args)
     end
 
+    protected
+
+    def create_bindable_code
+      ActionCode.new(code)
+    end
+
     private
 
     def parse_child(child, scanner, rules, scope)

data/lib/rattler/parsers/disallow_code.rb

@@ -0,0 +1,31 @@
+#
+# = rattler/parsers/disallow_code.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  # @private
+  class DisallowCode < ActionCode #:nodoc:
+
+    def bind(scope, bind_args)
+      "!(#{super}) && #{result_code bind_args}"
+    end
+
+    private
+
+    def result_code(bind_args)
+      if bind_args.size > 1
+        '[' + bind_args.join(', ') + ']'
+      elsif bind_args.size == 1
+        bind_args.first
+      else
+        'true'
+      end
+    end
+
+  end
+end

data/lib/rattler/parsers/dispatch_action.rb

@@ -25,8 +25,9 @@ module Rattler::Parsers
 
     # @private
     def self.parsed(results, *_) #:nodoc:
-      attributed, optional_attribute, optional_name = results
-      a = self[attributed, optional_attribute.first || @@node_defaults[:target]]
+      optional_expr, optional_attribute, optional_name = results
+      expr = optional_expr.first || ESymbol[]
+      a = self[expr, optional_attribute.first || @@node_defaults[:target]]
       unless optional_name.empty?
         a.with_attrs(:target_attrs => {:name => eval(optional_name.first, TOPLEVEL_BINDING)})
       else

data/lib/rattler/parsers/e_symbol.rb

@@ -0,0 +1,47 @@
+#
+# = rattler/parsers/e_symbol.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+require 'singleton'
+
+module Rattler::Parsers
+  #
+  # +ESymbol+ always succeeds without advancing.
+  #
+  # @author Jason Arhart
+  #
+  class ESymbol < Parser
+    include Atomic
+    include Singleton
+
+    # Return the singleton instance of +ESymbol+
+    #
+    # @return [ESymbol] the singleton instance
+    def self.[]()
+      self.instance
+    end
+
+    # @private
+    def self.parsed(*_) #:nodoc:
+      self.instance
+    end
+
+    # Return +true+ without advancing
+    #
+    # @param (see Parser#parse)
+    #
+    # @return true
+    def parse(scanner, rules, scope = {})
+      true
+    end
+
+    def capturing?
+      false
+    end
+
+  end
+end

data/lib/rattler/parsers/effect_code.rb

@@ -0,0 +1,31 @@
+#
+# = rattler/parsers/effect_code.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  # @private
+  class EffectCode < ActionCode #:nodoc:
+
+    def bind(scope, bind_args)
+      "#{super}; #{result_code bind_args}"
+    end
+
+    private
+
+    def result_code(bind_args)
+      if bind_args.size > 1
+        '[' + bind_args.join(', ') + ']'
+      elsif bind_args.size == 1
+        bind_args.first
+      else
+        'true'
+      end
+    end
+
+  end
+end

data/lib/rattler/parsers/eof.rb

@@ -15,36 +15,29 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Eof < Predicate
+    include Atomic
     include Singleton
-    
+
     # Return the singleton instance of +Eof+
     #
     # @return [Eof] the singleton instance
     def self.[]()
       self.instance
     end
-    
+
     # @private
     def self.parsed(*_) #:nodoc:
       self.instance
     end
-    
+
     # Return +true+ if there is no more input to parse
     #
     # @param (see Parser#parse_labeled)
     #
     # @return true if there is no more input to parse
-    def parse(scanner, rules, labeled = {})
+    def parse(scanner, rules, scope = {})
       scanner.eos?
     end
-    
-    # Return a new parser that uses +ws+ to skip whitespace before matching.
-    #
-    # @param (see Parser#with_ws)
-    # @return (see Parser#with_ws)
-    def with_ws(ws)
-      Skip[ws] & self
-    end
-    
+
   end
 end

data/lib/rattler/parsers/list_parser.rb

@@ -1,5 +1,5 @@
 #
-# = rattler/parsers/list.rb
+# = rattler/parsers/list_parser.rb
 #
 # Author:: Jason Arhart
 # Documentation:: Author
@@ -10,7 +10,9 @@ require 'rattler/parsers'
 module Rattler::Parsers
   #
   # +ListParser+ matches terms matched by a term parser in a list with
-  # separators matched by a separator parser.
+  # 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
   #
@@ -19,13 +21,13 @@ module Rattler::Parsers
 
     # @private
     def self.parsed(results, *_) #:nodoc:
-      self[*results]
+      term_parser, bounds, sep_parser = results
+      self[term_parser, sep_parser, *bounds]
     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)
+    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
 
     def term_parser
@@ -38,22 +40,39 @@ module Rattler::Parsers
 
     # 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>.
+    # term parser is not <tt>capturing?</tt>. Fails returning false unless at
+    # least <tt>#lower_bound</tt> terms are matched and stops matching at
+    # <tt>#upper_bound</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>
+    # @return [Array, 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 = {})
       a = []
-      p = scanner.pos
-      while result = term_parser.parse(scanner, rules, scope)
+      p = start_pos = scanner.pos
+      while result = term_parser.parse(scanner, rules, scope) and
+            (!upper_bound or a.size < upper_bound)
         p = scanner.pos
         a << result
         break unless sep_parser.parse(scanner, rules, scope)
       end
-      scanner.pos = p
-      (capturing? ? a : true) if enough? a
+      if a.size >= lower_bound
+        scanner.pos = p
+        capturing? ? a : true
+      else
+        scanner.pos = start_pos
+        false
+      end
+    end
+
+    def lower_bound?
+      lower_bound > 0
+    end
+
+    def upper_bound?
+      not upper_bound.nil?
     end
 
     def variable_capture_count?

data/lib/rattler/parsers/match.rb

@@ -16,6 +16,7 @@ module Rattler::Parsers
   # @author Jason Arhart
   #
   class Match < Parser
+    include Atomic
 
     # Create a new parser that matches with +re+.
     #
@@ -42,11 +43,5 @@ module Rattler::Parsers
       scanner.scan re
     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/parser_dsl.rb

@@ -66,7 +66,7 @@ module Rattler
       end
 
       # Create a new parser to match a pattern, literal, referenced parse rule,
-      # posix character class, or EOF.
+      # posix character class, EOF, or E.
       #
       # @overload match(pattern)
       #   @param [Regexp] pattern the pattern to match
@@ -88,10 +88,15 @@ module Rattler
       #   @param :EOF
       #   @return [Eof] the {Eof} singleton
       #
+      # @overload match(:E)
+      #   @param :E
+      #   @return [ESymbol] the {ESymbol} singleton
+      #
       def match(arg)
         case arg
         when Regexp   then Match[arg]
         when :EOF     then eof
+        when :E       then e
         when :ALNUM   then match /[[:alnum:]]/
         when :ALPHA   then match /[[:alpha:]]/
         when :BLANK   then match /[[:blank:]]/
@@ -113,25 +118,25 @@ module Rattler
       # Create a new optional parser.
       #
       # @overload optional(parser)
-      #   @return [Optional] a new optional parser
+      #   @return [Repeat] a new optional parser
       # @overload optional(arg)
-      #   @return [Optional] a new optional parser using arg to define a match
+      #   @return [Repeat] a new optional parser using arg to define a match
       #     parser
       #   @see #match
       def optional(arg)
-        Optional[to_parser(arg)]
+        Repeat[to_parser(arg), 0, 1]
       end
 
       # Create a new zero-or-more parser.
       #
       # @overload zero_or_more(parser)
-      #   @return [ZeroOrMore] a new zero-or-more parser
+      #   @return [Repeat] a new zero-or-more parser
       # @overload zero_or_more(arg)
-      #   @return [ZeroOrMore] a new zero-or-more parser using arg to define a
+      #   @return [Repeat] a new zero-or-more parser using arg to define a
       #     match parser
       #   @see #match
       def zero_or_more(arg)
-        ZeroOrMore[to_parser(arg)]
+        Repeat[to_parser(arg), 0, nil]
       end
 
       alias_method :any, :zero_or_more
@@ -139,39 +144,38 @@ module Rattler
       # Create a new one-or-more parser.
       #
       # @overload one_or_more(parser)
-      #   @return [OneOrMore] a new one-or-more parser
+      #   @return [Repeat] a new one-or-more parser
       # @overload one_or_more(arg)
-      #   @return [OneOrMore] a new one-or-more parser using arg to define a
-      #     match parser
+      #   @return [Repeat] a new one-or-more parser using arg to define a match
+      #     parser
       #   @see #match
       def one_or_more(arg)
-        OneOrMore[to_parser(arg)]
+        Repeat[to_parser(arg), 1, nil]
       end
 
       alias_method :some, :one_or_more
 
-      # Create a new list parser.
+      # Create a generalized repeat parser.
       #
-      # @overload list(term_parser, sep_parser)
-      #   @return [List0] a new list parser
-      # @overload list(term_arg, sep_arg)
-      #   @return [List0] a new list parser using args to define a match parsers
+      # @overload one_or_more(parser, min, max)
+      #   @return [Repeat] a new repeat parser with the given bounds
+      # @overload one_or_more(arg, min, max)
+      #   @return [Repeat] a new repeat parser using arg to define a match
+      #     parser
       #   @see #match
-      def list0(term_arg, sep_arg)
-        List0[to_parser(term_arg), to_parser(sep_arg)]
+      def repeat(arg, min, max)
+        Repeat[to_parser(arg), min, max]
       end
 
-      alias_method :list, :list0
-
-      # Create a new list1 parser.
+      # Create a new list parser.
       #
-      # @overload list(term_parser, sep_parser)
-      #   @return [List1] a new list1 parser
-      # @overload list(term_arg, sep_arg)
-      #   @return [List1] a new list1 parser using args to define match parsers
+      # @overload list(term_parser, sep_parser, min, max)
+      #   @return [ListParser] a new list parser
+      # @overload list(term_arg, sep_arg, min, max)
+      #   @return [ListParser] a new list parser using args to define a match parsers
       #   @see #match
-      def list1(term_arg, sep_arg)
-        List1[to_parser(term_arg), to_parser(sep_arg)]
+      def list(term_arg, sep_arg, min, max)
+        ListParser[to_parser(term_arg), to_parser(sep_arg), min, max]
       end
 
       # Create a new assert parser.
@@ -203,32 +207,71 @@ module Rattler
         Eof[]
       end
 
-      # Create a new symantic action that dispatches to a method.
+      # @return the "E" symbol parser
+      def e
+        ESymbol[]
+      end
+
+      # Create a new semantic action that dispatches to a method.
       #
       # @overload dispatch_action(parser)
-      #   @return [DispatchAction] a new symantic action
+      #   @return [DispatchAction] a new semantic action
       # @overload dispatch_action(arg)
-      #   @return [DispatchAction] a new symantic action using arg to define a
+      #   @return [DispatchAction] a new semantic action using arg to define a
       #     match parser
       #   @see #match
       def dispatch_action(arg, attrs={})
         DispatchAction[to_parser(arg), attrs]
       end
 
-      # alias action dispatch_action
-
-      # Create a new symantic action that evaluates ruby code.
+      # Create a new semantic action that evaluates ruby code.
       #
       # @overload direct_action(parser, code)
-      #   @return [DirectAction] a new symantic action
+      #   @return [DirectAction] a new semantic action
       # @overload direct_action(arg, code)
-      #   @return [DirectAction] a new symantic action using arg to define a
+      #   @return [DirectAction] a new semantic action using arg to define a
       #     match parser
       #   @see #match
       def direct_action(arg, code)
         DirectAction[to_parser(arg), code]
       end
 
+      # Create a new semantic action that evaluates ruby code for effect.
+      #
+      # @overload side_effect(parser, code)
+      #   @return [SideEffect] a new semantic action
+      # @overload side_effect(arg, code)
+      #   @return [SideEffect] a new semantic action using arg to define a
+      #     match parser
+      #   @see #match
+      def side_effect(arg, code)
+        SideEffect[to_parser(arg), code]
+      end
+
+      # Create a new positive semantic predicate.
+      #
+      # @overload semantic_assert(parser, code)
+      #   @return [SemanticAssert] a new positive Semantic predicate
+      # @overload semantic_assert(arg, code)
+      #   @return [SemanticAssert] a new positive Semantic predicate using arg
+      #     to define a match parser
+      #   @see #match
+      def semantic_assert(arg, code)
+        SemanticAssert[to_parser(arg), code]
+      end
+
+      # Create a new negative semantic predicate.
+      #
+      # @overload semantic_disallow(parser, code)
+      #   @return [SemanticDisallow] a new negative Semantic predicate
+      # @overload semantic_disallow(arg, code)
+      #   @return [SemanticDisallow] a new negative Semantic predicate using
+      #     arg to define a match parser
+      #   @see #match
+      def semantic_disallow(arg, code)
+        SemanticDisallow[to_parser(arg), code]
+      end
+
       # Create a new token parser or token rule.
       #
       # @overload token(rule_name, &block)