rattler 0.5.0 → 0.6.0

data/lib/rattler/grammar/rattler.rtlr

@@ -1,183 +0,0 @@
-require 'rattler/grammar'
-
-grammar Rattler::Grammar::Metagrammar
-
-include Rattler::Parsers
-
-%whitespace (SPACE+ / comment)* {
-
-  grammar           <-  heading rules EOF                                       <Grammar>
-
-  heading           <-  requires module_decl? includes                          { heading *_ }
-
-  requires          <-  (~`require` @(!eol .)+ ~eol)*                           { { :requires => _ } }
-
-  module_decl       <-  ~`parser` constant (~'<' constant)? ~eol                { parser_decl *_ }
-                      / ~`grammar` constant ~eol                                { { :grammar_name => _ } }
-
-  includes          <-  (~`include` constant ~eol)*                             { { :includes => _ } }
-
-  rules             <-  (directive / rule / block_close)+                       <RuleSet>
-
-  directive         <-  ws_directive / wc_directive / inline_directive
-
-  ws_directive      <-  ws_decl ~'{'                                            { start_ws _ }
-                      / ws_decl                                                 { set_ws _ }
-
-  ws_decl           <-  ~`%whitespace` unattributed
-
-  wc_directive      <-  wc_decl ~'{'                                            { start_wc _ }
-                      / wc_decl                                                 { set_wc _ }
-
-  wc_decl           <-  ~`%word_character` unattributed
-
-  inline_directive  <-  ~`%inline` ~'{'                                         { start_inline }
-                      / ~`%inline`                                              { set_inline }
-
-  block_close       <-  ~'}'                                                    { end_block }
-
-  rule              <-  identifier ~'<-' expression                             { rule *_ }
-
-  unattributed      <-  unattributed ~'/' terms                                 <Choice>
-                      / terms
-
-  expression        <-  expression ~'/' attributed                              <Choice>
-                      / attributed
-
-  attributed        <-  attributed? ~'<' node_action? literal? ~'>'             <DispatchAction>
-                      / attributed? ~'{' action ~'}'                            <DirectAction>
-                      / attributed? ~'~' ~'{' action ~'}'                       <SideEffect>
-                      / attributed? ~'&' ~'{' action ~'}'                       <SemanticAssert>
-                      / attributed? ~'!' ~'{' action ~'}'                       <SemanticDisallow>
-                      / attributed_terms
-
-  node_action       <-  @(name (~'.' var_name)?)
-
-  action            <-  @(( '{' [^}]* '}'
-                          / [^{}]         )*)
-
-  attributed_terms  <-  attributed term                                         <Sequence>
-                      / terms
-
-  terms             <-  terms term                                              <Sequence>
-                      / term
-
-  term              <-  fail_expr / labeled / labelable
-
-  fail_expr         <-  (`fail` / `fail_rule` / `fail_parse`) fail_arg          <Fail>
-
-  fail_arg          <-  ~'(' literal ~')'
-                      / literal
-
-  labeled           <-  var_name ~':' labelable                                 <Label>
-
-  labelable         <-  list
-                      / list_term
-
-  list              <-  list_term ~('*' ',') list_term                          { list0 *_ }
-                      / list_term ~('+' ',') list_term                          { list1 *_ }
-                      / list_term repeat_count ~',' list_term                   <ListParser>
-
-  list_term         <-  prefixed
-                      / prefixable
-                      / fail 'term expected'
-
-  prefixed          <-  ~'&' prefixable                                         <Assert>
-                      / ~'!' prefixable                                         <Disallow>
-                      / ~'~' prefixable                                         <Skip>
-                      / ~'@' prefixable                                         <Token>
-
-  prefixable        <-  suffixed / primary
-
-  suffixed          <-  primary ~'?'                                            { optional _ }
-                      / primary ~'*' !','                                       { zero_or_more _ }
-                      / primary ~'+' !','                                       { one_or_more _ }
-                      / primary repeat_count !','                               <Repeat>
-
-  repeat_count      <-  @DIGIT+ ~'..' @DIGIT+                                   { _.map {|s| s.to_i } }
-                      / @DIGIT+ ~'..'                                           { [_.to_i, nil] }
-                      / @DIGIT+                                                 { [_.to_i] * 2 }
-
-  primary           <-  ~'(' expression ~')'
-                      / atom
-
-  atom              <-  ~`EOF`                                                  <Eof>
-                      / ~`E`                                                    <ESymbol>
-                      / posix_class                                             { posix_class _ }
-                      / identifier !'<-'                                        <Apply>
-                      / literal                                                 { literal _ }
-                      / word_literal                                            { word_literal _ }
-                      / class                                                   { char_class _ }
-                      / back_reference                                          <BackReference>
-                      / ~'.'                                                    { Match[/./] }
-                      / fail 'atom expected'
-
-%inline
-
-  posix_class       <-  `ALNUM`
-                      / `ALPHA`
-                      / `ASCII`
-                      / `BLANK`
-                      / `CNTRL`
-                      / `DIGIT`
-                      / `GRAPH`
-                      / `LOWER`
-                      / `PRINT`
-                      / `PUNCT`
-                      / `SPACE`
-                      / `UPPER`
-                      / `XDIGIT`
-                      / `WORD`
-                      / fail 'posix_class expected'
-
-  literal           <-  @('"' ('\\' . / [^"])* '"')
-                      / @("'" ('\\' . / [^'])* "'")
-                      / @('%(' ('\\' . / [^)])* ')')
-                      / @('%{' ('\\' . / [^}])* '}')
-                      / @('%[' ('\\' . / [^\]])* ']')
-                      / @('%<' ('\\' . / [^>])* '>')
-                      / @('%' q:PUNCT ('\\' . / !$q .)* $q)
-
-  word_literal      <-  @("`" ('\\' . / [^`])* "`")
-
-  class             <-  @('[' (!']' range)+  ']')
-
-  name              <-  var_name
-                      / constant
-
-  identifier        <-  !`EOF` @(ALPHA WORD*)
-
-  back_reference    <-  @('$' LOWER WORD*)
-
-  var_name          <-  @(LOWER WORD*)
-
-  constant          <-  @((UPPER WORD* '::')* UPPER WORD*)
-
-  const_name        <-  @(UPPER WORD*)
-}
-
-  range             <-  @(  '[:' posix_name ':]'
-                          / class_char ('-' class_char)?)
-
-  posix_name        <-  `alnum`
-                      / `alpha`
-                      / `ascii`
-                      / `blank`
-                      / `cntrl`
-                      / `digit`
-                      / `graph`
-                      / `lower`
-                      / `print`
-                      / `punct`
-                      / `space`
-                      / `upper`
-                      / `xdigit`
-
-  class_char        <-  @(  '\\' [0-3] [0-7] [0-7]
-                          / '\\x' XDIGIT XDIGIT
-                          / '\\' .
-                          / [^\\\]] )
-
-  eol               <-  ~(BLANK* (EOF / ';' / ("\r"? "\n") / comment))
-
-  comment           <-  ~('#' [^\n]*)

data/lib/rattler/parsers/assert_code.rb

@@ -1,31 +0,0 @@
-#
-# = 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/direct_action.rb

@@ -1,85 +0,0 @@
-#
-# = rattler/parsers/direct_action.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
-require 'rattler/parsers'
-
-module Rattler::Parsers
-  #
-  # +DirectAction+ decorates a parser to peform a symantic action on success by
-  # evaluating ruby code.
-  #
-  # @author Jason Arhart
-  #
-  class DirectAction < Parser
-    include Combining
-
-    def self.[](child, code)
-      self.new(child, :code => code.strip)
-    end
-
-    # @private
-    def self.parsed(results, *_) #:nodoc:
-      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
-    # of applying the symantic action, otherwise return a false value.
-    #
-    # @param (see Parser#parse_labeled)
-    #
-    # @return the result of applying the symantic action, or a false value if
-    #   the parse failed.
-    def parse(scanner, rules, scope = {})
-      if result = parse_child(child, scanner, rules, scope) {|_| scope = _ }
-        if not child.capturing?
-          apply([])
-        elsif result.respond_to?(:to_ary)
-          apply(result, scope)
-        else
-          apply([result], scope)
-        end
-      end
-    end
-
-    def bindable_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)
-      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(code_scope, [results.inspect]))
-      else
-        eval(bind(code_scope, results.map {|_| _.inspect }))
-      end
-    end
-
-  end
-end

data/lib/rattler/parsers/disallow_code.rb

@@ -1,31 +0,0 @@
-#
-# = 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

@@ -1,121 +0,0 @@
-#
-# = rattler/parsers/dispatch_action.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
-require 'rattler/parsers'
-
-module Rattler::Parsers
-  #
-  # +DispatchAction+ decorates a parser to peform a symantic action on success
-  # by dispatching to a method.
-  #
-  # @author Jason Arhart
-  #
-  class DispatchAction < Parser
-    include Combining
-
-    # @private
-    @@node_defaults = {
-      :target => 'Rattler::Runtime::ParseNode',
-      :method => 'parsed'
-    }
-
-    # @private
-    def self.parsed(results, *_) #:nodoc:
-      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
-        a
-      end
-    end
-
-    # @private
-    def self.parse_attrs_arg(arg) #:nodoc:
-      case arg
-      when Hash
-        arg
-      when /^\s*(.+?)\s*\.\s*(.+?)\s*$/
-        { :target => $1, :method => $2 }
-      else
-        { :target => arg.to_s.strip }
-      end
-    end
-
-    # Create a new parser that decorates a parser to peform a symantic
-    # on success.
-    #
-    # @overload initialize(parser, opts={})
-    #   @param [Parser] parser
-    #   @option opts [String] target ('Rattler::Runtime::ParseNode') the
-    #     object on which to invoke a method as the symantic action
-    #   @option opts [String] method ('parsed') the name of the method to
-    #     invoke as the symantic action
-    #
-    # @overload initialize(method_spec)
-    #   @param [String] method_spec a specification of the target and optional
-    #     method name separated by "."
-    #
-    def initialize(children, attrs_arg={})
-      super(children, self.class.parse_attrs_arg(attrs_arg))
-      @@node_defaults.each {|k, v| attrs[k] ||= v } unless attrs[:code]
-      @method_name = attrs[:method]
-      @target_attrs = attrs[:target_attrs] || {}
-    end
-
-    # the name of the method used as the symantic action
-    attr_reader :method_name, :target_attrs
-
-    # If the wrapped parser matches at the parse position, return the result
-    # of applying the symantic action, otherwise return a false value.
-    #
-    # @param (see Parser#parse_labeled)
-    #
-    # @return the result of applying the symantic action, or a false value if
-    #   the parse failed.
-    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, scope)
-        else
-          apply([result], scope)
-        end
-      end
-    end
-
-    def bindable_code
-      @bindable_code ||= NodeCode.new(target, method_name, target_attrs)
-    end
-
-    def bind(scope, bind_args)
-      bindable_code.bind(scope, bind_args)
-    end
-
-    private
-
-    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