rattler 0.2.2 → 0.3.0

data/lib/rattler/grammar/rattler.rtlr

@@ -8,32 +8,32 @@ include Rattler::Parsers
   
   grammar         <-  heading rules EOF                                         <Grammar>
   
-  heading         <-  requires module_decl? includes                            {|r,m,i| heading r, m, i }
+  heading         <-  requires module_decl? includes                            { heading *_ }
   
-  requires        <-  (~`require` literal ~eol)*                                {|r| {:requires => r} }
+  requires        <-  (~`require` literal ~eol)*                                { { :requires => _ } }
   
-  module_decl     <-  ~`parser` constant (~'<' constant)? ~eol                  {|p,b| parser_decl p, b }
-                    | ~`grammar` constant ~eol                                  {|g| {:grammar_name => g} }
+  module_decl     <-  ~`parser` constant (~'<' constant)? ~eol                  { parser_decl *_ }
+                    | ~`grammar` constant ~eol                                  { { :grammar_name => _ } }
   
-  includes        <-  (~`include` constant ~eol)*                               {|i| {:includes => i} }
+  includes        <-  (~`include` constant ~eol)*                               { { :includes => _ } }
   
   rules           <-  (directive | rule | block_close)+                         <Rules>
   
   directive       <-  ws_directive | wc_directive
   
-  ws_directive    <-  ws_decl ~'{'                                              {|e| start_ws e }
-                    | ws_decl                                                   {|e| set_ws e }
+  ws_directive    <-  ws_decl ~'{'                                              { start_ws _ }
+                    | ws_decl                                                   { set_ws _ }
   
   ws_decl         <-  ~`%whitespace` unattributed
   
-  wc_directive    <-  wc_decl ~'{'                                              {|e| start_wc e }
-                    | wc_decl                                                   {|e| set_wc e }
+  wc_directive    <-  wc_decl ~'{'                                              { start_wc _ }
+                    | wc_decl                                                   { set_wc _ }
   
   wc_decl         <-  ~`%word_character` unattributed
   
   block_close     <-  ~'}'                                                      { end_block }
   
-  rule            <-  identifier ~'<-' expression                               {|n,e| rule n, e }
+  rule            <-  identifier ~'<-' expression                               { rule *_ }
   
   unattributed    <-  unattributed ~'|' terms                                   <Choice>
                     | terms
@@ -41,32 +41,32 @@ include Rattler::Parsers
   expression      <-  expression ~'|' attributed                                <Choice>
                     | attributed
   
-  attributed      <-  attributed attribute                                      <DispatchAction>
-                    | attributed action                                         <DirectAction>
+  attributed      <-  attributed ~'<' dispatch? ~'>'                            <DispatchAction>
+                    | attributed ~'{' action ~'}'                               <DirectAction>
                     | terms
   
-  attribute       <-  ~'<' option? ~'>'
+  dispatch        <-  @(name (~'.' var_name)?)
   
-  option          <-  @(name method?)
-  
-  method          <-  ~'.' var_name
-  
-  action          <-  ~'{' @(('{' [^}]* '}' | [^{}])*) ~'}'
-                    | ~'<' method ~'>'                                          {|m| "|_| _.#{m}" }
+  action          <-  @(('{' [^}]* '}' | [^{}])*)
   
   terms           <-  terms term                                                <Sequence>
                     | term
   
-  term            <-  fail_expr | labeled | prefixed | suffixed | primary
+  term            <-  fail_expr | labeled | labelable
   
   fail_expr       <-  (`fail` | `fail_rule` | `fail_parse`) fail_arg            <Fail>
   
   fail_arg        <-  ~'(' literal ~')'
                     | literal
   
-  labeled         <-  label (prefixed | prefixable)                             <Label>
+  labeled         <-  var_name ~':' labelable                                   <Label>
+  
+  labelable       <-  list | list_term
+  
+  list            <-  list_term ~'*^' list_term                                 <List>
+                    | list_term ~'+^' list_term                                 <List1>
   
-  label           <-  var_name ~':'
+  list_term       <-  prefixed | prefixable
   
   prefixed        <-  ~'&' prefixable                                           <Assert>
                     | ~'!' prefixable                                           <Disallow>
@@ -76,18 +76,18 @@ include Rattler::Parsers
   prefixable      <-  suffixed | primary
   
   suffixed        <-  primary ~'?'                                              <Optional>
-                    | primary ~'*'                                              <ZeroOrMore>
-                    | primary ~'+'                                              <OneOrMore>
+                    | primary ~'*' !'^'                                         <ZeroOrMore>
+                    | primary ~'+' !'^'                                         <OneOrMore>
   
   primary         <-  ~'(' expression ~')'
                     | atom
   
   atom            <-  `EOF`                                                     <Eof>
-                    | posix_class                                               {|n| posix_class n }
+                    | posix_class                                               { posix_class _ }
                     | identifier !'<-'                                          <Apply>
-                    | literal                                                   {|e| literal e }
-                    | word_literal                                              {|e| word_literal e }
-                    | class                                                     {|e| char_class e }
+                    | literal                                                   { literal _ }
+                    | word_literal                                              { word_literal _ }
+                    | class                                                     { char_class _ }
                     | regexp                                                    <Match>
                     | ~'.'                                                      { Match[/./] }
   

data/lib/rattler/parsers/action_code.rb

@@ -10,26 +10,37 @@ require 'rattler/parsers'
 module Rattler::Parsers
   # @private
   class ActionCode #:nodoc:
-    
+
     def initialize(code)
       if md = /\A\s*\|([^|]*)\|(.*)\Z/.match(code)
         @param_names = md[1].split(',').map {|_| _.strip }
         @body = md[2].strip
       else
         @param_names = []
-        @body = code
+        @body = code.strip
       end
     end
-    
+
     attr_reader :param_names, :body
-    
+
     def bind(*args)
       bindings = {}
-      bindings.merge!(arg_bindings(args.shift)) if args.first.respond_to?(:to_ary)
+      if args.first.respond_to?(:to_ary)
+        a = args.shift
+        bindings.merge!(blank_binding(a)).merge!(arg_bindings(a))
+      end
       bindings.merge!(args.shift) unless args.empty?
       bind_in body, bindings
     end
-    
+
+    def blank_binding(args)
+      case args.size
+      when 0 then {}
+      when 1 then { '_' => args.first }
+      else        { '_' => '[' + args.join(', ') + ']' }
+      end
+    end
+
     def arg_bindings(args)
       if param_names.count > args.count
         raise ArgumentError, 'more parameter names than arguments'
@@ -38,9 +49,9 @@ module Rattler::Parsers
       param_names.zip(args).each {|name, arg| bindings[name] = arg if name }
       bindings
     end
-    
+
     private
-    
+
     def bind_in(code, bindings)
       new_code = code
       bindings.each do |k, v|
@@ -49,6 +60,6 @@ module Rattler::Parsers
       end
       new_code
     end
-    
+
   end
 end

data/lib/rattler/parsers/fail.rb

@@ -14,7 +14,7 @@ module Rattler::Parsers
   #
   # @author Jason Arhart
   #
-  class Fail < Predicate
+  class Fail < Parser
     
     # @private
     def self.parsed(results, *_) #:nodoc:
@@ -51,5 +51,11 @@ module Rattler::Parsers
       false
     end
     
+    # Always +false+
+    # @return false
+    def capturing?
+      false
+    end
+    
   end
 end

data/lib/rattler/parsers/list.rb

@@ -0,0 +1,57 @@
+#
+# = rattler/parsers/list.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  #
+  # +List+ matches terms matched by a term parser in a list with separators
+  # matched by a separator parser.  +List+ always matches even if there are no
+  # matched terms.
+  #
+  # @author Jason Arhart
+  #
+  class List < 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 => 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?
+      true
+    end
+
+  end
+end

data/lib/rattler/parsers/list1.rb

@@ -0,0 +1,58 @@
+#
+# = rattler/parsers/list1.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+
+require 'rattler/parsers'
+
+module Rattler::Parsers
+  #
+  # +List1+ matches terms matched by a term parser in a list with separators
+  # matched by a separator parser. +List1+ fails unless at least one term is
+  # matched.
+  #
+  # @author Jason Arhart
+  #
+  class List1 < Parser
+    include Combining
+
+    # @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
+    end
+
+  end
+end

data/lib/rattler/parsers/parser_dsl.rb

@@ -15,7 +15,7 @@ module Rattler
     # @author Jason Arhart
     #
     class ParserDSL
-      
+
       # Define parse rules with the given block
       #
       # @option options [Parser] ws (nil) a parser to be used to skip whitespace
@@ -25,27 +25,27 @@ module Rattler
       def self.rules(options = {}, &block)
         self.new(options).rules(&block)
       end
-      
+
       # @private
       def initialize(options = {}) #:nodoc:
         @rules = options[:rules] || []
         @options = options
         @ws = options[:ws]
       end
-      
+
       # @private
       def with_options(options, &block) #:nodoc:
         dsl = self.class.new(@options.merge(:rules => @rules).merge(options))
         dsl.instance_exec(dsl, &block)
       end
-      
+
       # Evaluate the given block using +ws+ to skip whitespace
       #
       # @param [Parser] ws the parser to be used to skip whitespace
       def with_ws(ws, &block)
         with_options(:ws => to_parser(ws), &block)
       end
-      
+
       # Evaluate the given block to define parse rules
       #
       # @return [Rules] the rules defined in the block
@@ -53,7 +53,7 @@ module Rattler
         instance_exec(self, &block)
         Rules[@rules]
       end
-      
+
       # Evaluate the given block to define a parse rule
       #
       # @param [Symbol] name the name for the rule
@@ -64,7 +64,7 @@ module Rattler
         @rules << Rule[name, (@ws ? parser.with_ws(@ws) : parser)]
         @rules.last
       end
-      
+
       # Create a new parser to match a pattern, literal, referenced parse rule,
       # posix character class, or EOF.
       #
@@ -108,7 +108,7 @@ module Rattler
         else match Regexp.new(Regexp.escape(arg.to_s))
         end
       end
-      
+
       # Create a new optional parser.
       #
       # @overload optional(parser)
@@ -120,7 +120,7 @@ module Rattler
       def optional(arg)
         Optional[to_parser(arg)]
       end
-      
+
       # Create a new zero-or-more parser.
       #
       # @overload zero_or_more(parser)
@@ -132,7 +132,7 @@ module Rattler
       def zero_or_more(arg)
         ZeroOrMore[to_parser(arg)]
       end
-      
+
       # Create a new one-or-more parser.
       #
       # @overload one_or_more(parser)
@@ -144,7 +144,29 @@ module Rattler
       def one_or_more(arg)
         OneOrMore[to_parser(arg)]
       end
-      
+
+      # Create a new list parser.
+      #
+      # @overload list(term_parser, sep_parser)
+      #   @return [List] a new list parser
+      # @overload list(term_arg, sep_arg)
+      #   @return [List] a new list parser using args to define a match parsers
+      #   @see #match
+      def list(term_arg, sep_arg)
+        List[to_parser(term_arg), to_parser(sep_arg)]
+      end
+
+      # Create a new list1 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
+      #   @see #match
+      def list1(term_arg, sep_arg)
+        List1[to_parser(term_arg), to_parser(sep_arg)]
+      end
+
       # Create a new assert parser.
       #
       # @overload assert(parser)
@@ -156,7 +178,7 @@ module Rattler
       def assert(arg)
         Assert[to_parser(arg)]
       end
-      
+
       # Create a new disallow parser.
       #
       # @overload disallow(parser)
@@ -168,12 +190,12 @@ module Rattler
       def disallow(arg)
         Disallow[to_parser(arg)]
       end
-      
+
       # @return the eof parser
       def eof
         Eof[]
       end
-      
+
       # Create a new symantic action that dispatches to a method.
       #
       # @overload dispatch_action(parser)
@@ -185,9 +207,9 @@ module Rattler
       def dispatch_action(arg, attrs={})
         DispatchAction[to_parser(arg), attrs]
       end
-      
+
       # alias action dispatch_action
-      
+
       # Create a new symantic action that evaluates ruby code.
       #
       # @overload direct_action(parser, code)
@@ -199,7 +221,7 @@ module Rattler
       def direct_action(arg, code)
         DirectAction[to_parser(arg), code]
       end
-      
+
       # Create a new token parser or token rule.
       #
       # @overload token(rule_name, &block)
@@ -216,7 +238,7 @@ module Rattler
           Token[to_parser(arg)]
         end
       end
-      
+
       # Create a new skip parser.
       #
       # @overload skip(parser)
@@ -228,7 +250,7 @@ module Rattler
       def skip(arg)
         Skip[to_parser(arg)]
       end
-      
+
       # Create a new labeled parser.
       #
       # @overload label(parser)
@@ -240,89 +262,89 @@ module Rattler
       def label(name, arg)
         Label[name, to_parser(arg)]
       end
-      
+
       # @return [Fail] a parser that always fails
       def fail(message)
         Fail[:expr, message]
       end
-      
+
       # @return [Fail] a parser that fails the entire rule
       def fail_rule(message)
         Fail[:rule, message]
       end
-      
+
       # @return [Fail] a parser that fails the entire parse
       def fail_parse(message)
         Fail[:parse, message]
       end
-      
+
       # @return [Match] a parser matching any character
       def any
         match /./
       end
-      
+
       # @return [Match] a parser matching the POSIX +alnum+ character class
       def alnum
         match :ALNUM
       end
-      
+
       # @return [Match] a parser matching the POSIX +alpha+ character class
       def alpha
         match :ALPHA
       end
-      
+
       # @return [Match] a parser matching the POSIX +blank+ character class
       def blank
         match :BLANK
       end
-      
+
       # @return [Match] a parser matching the POSIX +cntrl+ character class
       def cntrl
         match :CNTRL
       end
-      
+
       # @return [Match] a parser matching the POSIX +digit+ character class
       def digit
         match :DIGIT
       end
-      
+
       # @return [Match] a parser matching the POSIX +graph+ character class
       def graph
         match :GRAPH
       end
-      
+
       # @return [Match] a parser matching the POSIX +lower+ character class
       def lower
         match :LOWER
       end
-      
+
       # @return [Match] a parser matching the POSIX +print+ character class
       def print
         match :PRINT
       end
-      
+
       # @return [Match] a parser matching the POSIX +punct+ character class
       def punct
         match :PUNCT
       end
-      
+
       # @return [Match] a parser matching the POSIX +space+ character class
       def space
         match :SPACE
       end
-      
+
       # @return [Match] a parser matching the POSIX +upper+ character class
       def upper
         match :UPPER
       end
-      
+
       # @return [Match] a parser matching the POSIX +xdigit+ character class
       def xdigit
         match :XDIGIT
       end
-      
+
       private
-      
+
       def to_parser(o)
         case o
         when Parser then o
@@ -331,7 +353,7 @@ module Rattler
         else match(o)
         end
       end
-      
+
     end
   end
 end

data/lib/rattler/parsers.rb

@@ -14,7 +14,7 @@ module Rattler
   # @author Jason Arhart
   #
   module Parsers
-    
+
     autoload :Parser, 'rattler/parsers/parser'
     autoload :Rules, 'rattler/parsers/rules'
     autoload :Rule, 'rattler/parsers/rule'
@@ -24,6 +24,8 @@ module Rattler
     autoload :Optional, 'rattler/parsers/optional'
     autoload :ZeroOrMore, 'rattler/parsers/zero_or_more'
     autoload :OneOrMore, 'rattler/parsers/one_or_more'
+    autoload :List, 'rattler/parsers/list'
+    autoload :List1, 'rattler/parsers/list1'
     autoload :Apply, 'rattler/parsers/apply'
     autoload :Assert, 'rattler/parsers/assert'
     autoload :Disallow, 'rattler/parsers/disallow'
@@ -39,7 +41,7 @@ module Rattler
     autoload :Combining, 'rattler/parsers/combining'
     autoload :MatchJoining, 'rattler/parsers/match_joining'
     autoload :ActionCode, 'rattler/parsers/action_code'
-    
+
     class <<self
       # Define parse rules with the given block
       #
@@ -49,6 +51,6 @@ module Rattler
         ParserDSL.rules(&block)
       end
     end
-    
+
   end
 end