forwarder2 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2321eef417bac1725fd34fb39d99d5a8ce187abd
+  data.tar.gz: 5b4e950db43bd7a004750bbb5987746a56a9e6d3
+SHA512:
+  metadata.gz: dd4327158ec4ab363e588e7661bb87629a32275dfbc20eb1e3ab9d407f35fc2f394594d26d7c8e717cd24a2b3c0b369195feec998c5f4f21d40647ba9d679d31
+  data.tar.gz: 6d2754e5d8fee19b6356197c3a448a9e92cd18496dc25b246e7b622cab941b63796ebdcfd1a831a3ded3ce7bf460060c16ac4dfa267f06a347faf2378190e4cf

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Robert Dober
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,493 @@
+# Forwarder2
+
+This implementation is for, and needs, Ruby 2.
+For Ruby 1.9 please see https://github.com/RobertDober/Forwarder19.
+For Ruby 1.8.7 please see https://github.com/RobertDober/Forwarder.
+
+## Abstract
+
+Ruby's core Forwardable gets the job done(barely), but produces most unreadable code.
+
+This is a nonintrusive (as is Forwardable) module that allows to delegate methods to instance variables,
+objects returned by instance\_methods, other methods of the same receiver, the receiver itself, a chain of messages or
+an arbitrary object. Paramters can be provided in the forwarding definition (parially or totally.
+
+It also defines after and before filters.  and some more sophisticated use cases}
+
+## License
+
+This software is released under the very liberal MIT license as indicated in the attached file LICENSE.
+If you do not have the LICENSE file delivered the terms of the license are referred to here:
+http://www.opensource.org/licenses/mit-license.html
+
+## Performance
+
+Execution time is that of 85~95% of Forwardable by evalling strings whenever possible.
+
+
+## Simple Delegation As In Forwardable
+
+```ruby
+
+forward <a_message>, to: <target>
+forward <a_message>, to: <target>, as: <translation>
+```
+
+These two forms of the `forward` method, (and *only* these two forms) are directly implemented with
+`def_delegator` method of `Forwardable`, as follows:
+
+```ruby
+def_delegator <target> <a_message>
+def_delegator <translation> <a_message>
+```
+
+Furthermore the `forward_all` method is translated to the `def_delegators` method in the following form,
+thusly
+
+```ruby
+forward_all msg1, msg2, msg3, ..., to: target
+```
+is implemented as 
+
+```ruby
+def_delegators target, msg1, msg2, msg3, ...
+```
+
+### Additional Features
+
+* Parameters (partial or total application)
+* Custom And Chained Targets
+* AOP Filters
+* Helpers
+
+
+## Parameters
+
+
+### Passing One Parameter
+
+Assuming a class `ArrayWrapper` and that their instances wrap the array object via the instance variable
+`@ary` the Smalltalk method `second` can be implemented as follows.
+
+```ruby
+require 'forwarder'
+class ArrayWrapper
+  extend Forwarder
+  forward :second, to: :@ary, as: :[], with: 1
+  ...
+end
+```
+
+The `with` keyword paramter is thus used to provide the first slice of arguments that will be provided
+to the forwarded invocation. This slice will be extended by the actual parameters of the invocation
+of the proxy method (e.g. the instance method defined by the `forward` method itself).
+
+### Passing More Parameters
+
+If `with:` is passed an array, it is splatted into the invocation, thus allowing us to pass more than
+one parameter. This becomes clearer with an example.
+
+```ruby
+
+   forward :add_whitespace_to_punctuation,
+           to:   :name,
+           as:   :gsub!,
+           with: [ /[,.]\b/, '\& ' ]
+```
+
+### A Useful Shorthand
+
+As I found myself using the following idioms all the time
+
+```ruby
+
+  forward :some_method, to: :@some_hash, as: :[], with: :some_method
+  forward :other_method, to: :hash, as: :[], with: :other_key
+
+```
+
+I conceived the `to_hash` shortcut for these. Strictly spoken (and not striktly spoken
+too) this is a gross generalisation of the usecase as if they target had to be a `Hash`
+all the time. This is not the case of course, we are just forwarding a message with a
+parameter...
+
+Here is how the above idioms can be expressed by means of the `to_hash` target:
+
+```ruby
+
+   forward :some_method, to_hash: :@some_hash
+   forward :other_method, to_hash: :hash, as: :other_key
+
+```
+
+Concerning jargon we are doing something a little bit confusing here. In all cases we have
+an implicit translation (which is `:[]` of course). In the second case we have an explicit
+translation (being `:other_key`) too. The explicit translation is transformed into the first,
+and only argument, as we do not allow explicit arguments for `to_hash:` targets.
+
+However you still can use the `forward_all` version and a `to_hash:` chain target, here is
+an example:
+
+```ruby
+
+   class Params
+     extend Forwarder
+     forward_all :count, :limit, to_hash: [:@params, :mandatory]
+     forward :pretend?, to_hash: [:@params, :optional], as: :dry_run
+   end
+
+```
+
+AOP is not supported for `to_hash:` targets in this version, this might change in the future
+as use cases are imaginable (e.g. an after filter for the `:pretend?` method, applying !! to
+the result).
+
+### Partial Application
+
+This example gives us the oppurtunity to look at a use case for partial applications. Let us assume that
+we do not always use whitespaces, than we can leave the second paramter to be provided by the invocation
+of the defined forwarder proxy.
+
+```ruby
+   forward :add_something_to_punctuation,
+           to:   :name,
+           as:   :gsub!,
+           with: /([,.])\b/
+```
+
+We can achieve the same as above with the following invocation
+
+```ruby
+   o = Name.new( "the,quick, fox." )
+   o.add_something_to_punctuation( '\1 ' )
+  # name: "the, quick, fox." )
+```
+
+but we can also add a hyphen after interpunctations with this invocation 
+
+```ruby
+   o = Name.new( "the,quick, fox." )
+   o.add_something_to_punctuation( '\1- ' )
+  # name: "the,- quick,- fox." )
+```
+
+But more importantely we can forward to the partial application, thus using the 
+partial application as a mean of composition
+
+```ruby
+   forward :add_ws_to_punctuation,
+           to_object: :self,
+           as: :add_something_to_punctuation,
+           with: '\1 '
+
+   forward :add_hypen_to_punctuation,
+           to_object: self,
+           as: :add_something_to_punctuation,
+           with_block: ->(*grps){ "#{grps.first}- " }
+ 
+```
+
+### Passing One Array
+
+If a real array shall be passed in as one parameter it can be wrapped into an array of one element,
+or the `with_ary:` keyword parameter can be used.
+
+Example:
+
+```ruby
+  forward :append_suffix, to: :@ary, as: :concat, with: [%w{ my suffix }]
+  forward :append_suffix, to: :@ary, as: :concat, with_ary: %w{ my suffix }
+```
+
+### Passing A Block
+
+In case of the necessity to provide a block to the forwarded invocation, it can be specified as the
+block parameter of the `forward` invocation itself.
+
+The following example uses inject to compute a sum of elements
+
+```ruby
+  forward :sum, to: :elements, as: :inject do |s,e| s+e end
+```
+
+Please note however that common patterns like this one can benefit of the provided
+helpers, in our case it is Integer.sum.
+
+```ruby
+require 'forwarder/helpers/integer/sum'
+...
+  forward :sum, to: :elements, as: :inject &Integer.sum
+# or
+  forward :sum, to: :elements, as: :inject, with_block: Integer.sum
+...
+```
+
+Accounting for different tastes a block can be provided as a block parameter or 
+as a `lambda` to the `with_block:` keyword parameter. The later is taking preference
+over the former, which no defined usage of the block in this case (at least for
+the time being).
+
+### Selective Helpers
+
+As we do not want to be intrusive the helpers
+have to be requested explicitly.
+
+This can be done in three levels of granularity:
+
+* Per helper
+
+`require 'forwarder/helpers/integer/sum'`
+
+* All helpers
+
+`require 'forwarder/helpers'`
+
+* Per monkey patched class
+
+`require 'forwarder/helpers/integer'`
+
+## Custom And Chained Targets
+
+So far the `to:` keyword was followed by a symbol or string denoting a _symbolic receiver_, that is
+an instance_variable or method with the denoted name. Custom and Chain Targets are implementing a
+different story.
+
+### Chain Targets
+
+Chain Targets are also expressed with the `to:` keyword parameter, but by passing an array of _symbolic receivers_.
+This array will resolve to the final target by sending each message to the result of the preceding message. 
+The following example should make this clearer:
+
+
+```ruby
+  forward :size, to: %w{@content children}
+```
+
+which could have been implemented by hand as follows:
+
+```ruby
+  def size
+    @content.children.size
+  end
+```
+
+### Custom Targets
+
+Allow the user to define a target that cannot be expressed as a _symbolic receiver_.
+
+Custom targets are expressed by the means of the `to_object:` keyword parameter.
+
+
+I want to give two examples here, the first
+using `self`, which evaluates to the module in which `forward` is invoked of course, and might
+thus be used to forward to class instance methods, as in the following example:
+
+```ruby
+class Callback
+  def self.instances; @__instances__ ||= [] end
+    
+  def self.register an_instance
+    instances << an_instance
+  end
+
+  extend Forwarder
+  forward :register, to_object: self
+
+  def initialize
+    register self
+  end
+end
+```
+
+But when looking closely one can see that the `self.register` method is just another delegation, thus the whole code
+can be rewritten even more concesily as:
+
+```ruby
+class Callback
+  class << self
+    extend Forwarder
+    forward :<<, to: :instances
+  
+    def instances; @__instances__ ||= [] end
+  end
+
+  extend Forwarder
+  forward :register, to_object: self, as: :<<
+end
+```
+
+The second example is a forward to the instance itself, for that purpose the symbol :self
+can be used. The followin is, again, an implementation of Smalltalk's `second` method. But
+here we are defining it on `Array` itself, not a wrapper.
+
+
+```ruby
+class Array
+  extend Forwarder
+  forward :second, to_object: :self, as: :[], with: 1
+```
+
+However the same could be accomplished by using the object/identity helper and the default
+target implementation.
+
+```ruby
+require 'forwarder/helpers/object/identity'
+class Array
+  extend Forwarder
+  forward :second, to: :identity, as: :[], with: 1
+```
+
+#### Custom Targets And Closures
+
+Another application of custom targets would be to hide a enclosed object, but as in the first
+example above, such an object cannot be defined on instance level, but only on class level.
+Assuming that the class itself does not need access to the object enclosed by the closure, one
+could easily implement an instance count for a class as follows:
+
+
+```ruby
+
+  container = []
+  forward :register, to_object: container, as: :<<, with: :sentinel
+  forward :instance_count, to_object: container, as: :size
+
+```
+
+## AOP Filters
+
+Before and After filters are implemented in this version.
+
+The respective `before:` and
+`after:` keyword parameters expect lambdas as paramters, but by specifying the `:use_block`
+value the block parameter of the `forward` method can be _abused_ for this purpose.
+
+The following examples all operate on a class wrapping a hash instance via the `hash` attribute
+reader. Our first goal is to implement a `max_value` method, that will return the maxium value
+of all values for given keys.
+
+### After Filter
+
+The lambda provided by `after:` is applied to the return value of the forwarded invocation.
+The following three examples all implement the `max_value` method correctly.
+
+
+```ruby
+  forward :max_value, to: :hash, as: :values_at, after: lambda{ |x| x.max }
+  forward :max_value, to: :hash, as: :values_at, after: :use_block do | x | 
+    x.max 
+  end
+  require 'forwarder/helpers/kernel/sendmsg'
+  forward :max_value, to: :hash, as: :values_at, after: sendmsg( :max )
+```
+
+N.B. The `Kernel#sendmsg` method is my reply to the hated - by me that is at least - `Symbol#to_proc` kludge and its
+limitations, I will talk about it more in the Helpers section.
+
+### Before Filter.
+
+Our next goal is to implement a method `value_of_max` that returns the value for the greatest of
+all provided keys.
+
+For this we will use a before filter, its lambda is applied to the arguments
+of the implemented forwarder and the result will be passed in to the forwarded invocation. The pass in
+will use a splash if appropriate.
+
+
+```ruby
+  forward :value_of_max, to: :hash, as: :[], before: lambda{ |*args| args.max }
+  require 'forwarder/helpers/kernel/sendmsg'
+  forward :value_of_max, to: :hash, as: :[], before: sendmsg( :max )
+```
+
+## Helpers
+
+*N.B.* These are no longer part of Forwarder19, but have been moved into the gemdependency lab419_core.
+
+Helpers define two type of methods. Firstly methods that return lambdas for frequently used
+block patterns, e.g. `Integer.sum`. Secondly methods that are convenient to use inside `forward`
+invocations, but not necessarily only there, e.g. `Kernel#sendmsg` or `Object#identity`.
+
+### Functional Helpers
+
+I see this second group, as small as it is, as an important enhancement for the functional
+programming style. The possibilty to nullify a block that is necessarily used in a chain
+of functional calls by passing in `{|x| x.identity}`, `sendmsg(:identity)` or even the 
+hated `&:identity` is a recurring pattern. 
+
+**Warning:** I will become evangelic now.
+
+I do not like the `Symbol#to_proc` kludge, and that for two reasons. The first is pragamatic.
+You cannot pass parameters, and that sucks. Why can I express `map(&:succ)` but not `map(&:+, 2)`.
+Well the answer is clear, Ruby's syntax does not support it.
+
+The second reason is on philosophical grounds. It feels wrong that Symbol shall be responsable
+of transforming itself into a lambda.
+
+Thus I created a helper in Kernel that takes the responsability, and doing so
+with a clear name, expressing intent. This helper is `Kernel#sendmsg`.
+
+
+```ruby
+  map do |ele|
+   ele.hello "World"
+  end
+```
+
+is the same as
+
+
+```ruby
+  map( &sendmsg( :hello, "World") )
+```
+
+Furthermore it might be usuful to keep the returned `lambda` around, please compare
+
+```ruby
+  adder = sendmsg( :+ )
+```
+versus 
+
+```ruby
+  adder = :+.to_proc
+```
+
+
+Mapping with a `Symbol` might not only be conveniently expressed as sending a message to each
+element, sometimes a different meaning might be appropriate as in the example below:
+
+
+```ruby
+  map do | ele |
+    some_method ele
+  end
+```
+
+A different helper can do this job without any ambiguity:
+
+
+```ruby
+  map( &applying( :some_method ) )
+```
+
+### Commonly Used Pattern Helpers
+
+This group of helpers is just to avoid to rewrite lambdas you/one/whoever/I have written zillions of times. Here is a short list of examples
+the API doc should give you enough information if you look for something specific.
+
+#### Integer.sum
+
+```ruby
+  class Integer
+    def self.sum
+      ->(a, b){ a + b }
+    end
+  end
+```
+
+#### Integer#inc
+
+```ruby
+  class Integer
+    alias_method :inc, :succ # should have used forward ;)
+  end
+```

data/lib/forwarder.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+require 'forwarder/params'
+
+module Forwarder
+  
+  # How forward works:
+  # The parameters are analyzied by the Params object by means of the `prepare_forward`
+  # method. The `prepare_forward` method makes have use of the Argument object which
+  # implements a query API for what the given arguments allow the forwarder to do.
+  # And eventually the `forward!` method realises the delegation
+  def forward *args, &blk
+    params = Forwarder::Params.new self
+    params.prepare_forward( *args, &blk )
+    params.forward!
+  end
+
+  def forward_all *args, &blk
+    opts   = args.pop
+    args.each do | arg |
+      forward( arg, opts, &blk)
+    end
+  end
+end # module Forwarder

data/lib/forwarder/arguments.rb

@@ -0,0 +1,184 @@
+require 'forwarder/evaller'
+
+module Forwarder
+  class Arguments
+    attr_reader :args, :message, :target
+
+    def all?
+      !args? && !lambda? && @__all__
+    end
+
+    def after
+      @after ||= @params[:after]
+    end
+
+    def after?
+      after
+    end
+
+    def aop?
+      @__aop__ ||= !aop_values.empty?
+    end
+
+    def args?
+      !!args
+    end
+
+    def before
+      @before ||= @params[:before] || @params[:before_with_block]
+    end
+
+    def before?
+      before
+    end
+
+    def before_with_block?
+      !!@params[:before_with_block]
+    end
+
+
+    def chain?
+      @params[ :to_chain ]
+    end
+
+    def complete_args *args
+      (self.args || []) + args
+    end
+
+    def custom_target?
+      @params[:to_object]
+    end
+
+#     def delegatable?
+#       !aop? && !custom_target? && !all? && !chain? && !args && !lambda?
+#     end
+
+    def evaluable?
+      !lambda? &&
+        !aop? &&
+        ( !args || args.all?{|a| Evaller.evaluable? a } ) &&
+        ( !custom_target? || Evaller.evaluable?( custom_target? ) )
+    end
+
+    def lambda default=nil
+      lambda? || default
+    end
+
+    def lambda?
+      @lambda
+    end
+
+    def must_not_compile?
+      lambda? || aop? || custom_target?
+    end
+
+    # This is always nil unless we are a custom_target, in which case
+    # default is returned if target is :self, else target is returned
+    def object_target default
+      return unless custom_target?
+      target == :self ? default : target
+    end
+
+    def serialized_params
+      Evaller.serialize args
+    end
+      
+    def to_hash?
+      @__to_hash__ ||= @params[ :to_hash ]
+    end
+
+    def translation alternative=nil, &blk
+      @params[ :as ].tap do | tltion |
+        break alternative unless tltion
+        break tltion unless blk
+        blk.( tltion ) 
+      end
+    end
+
+    private
+    def aop_values
+      @__aop_values__ ||= @params.values_at( :after, :before, :before_with_block ).compact
+    end
+
+    def check_for_incompatibilities!
+      raise ArgumentError, "cannot provide translations for forward_all" if @__all__ && translation
+      raise ArgumentError, "cannot provide arguments for forward_all" if @__all__ && args?
+    end
+
+    def initialize *args, &blk
+      @message = args.shift
+      raise ArgumentError, "need one message and a hash of kwd params, plus an optional block" unless args.size == 1 && args.first.is_a?( Hash )
+      @params = args.first
+      set_message
+      set_target
+      set_args blk
+      check_for_incompatibilities!
+      translate_to_hash
+    end
+
+    def set_args blk
+      set_lambda blk
+      hw = @params.has_key? :with
+      ha = @params.has_key? :with_ary
+      raise ArgumentError, "cannot use :with and :with_ary parameter" if hw && ha
+      unless to_hash?
+        set_args_normal if hw
+        set_args_ary if ha
+      end
+    end
+
+    def set_args_ary
+      @args = [ @params[:with_ary] ]
+      raise ArgumentError, ":with_ary needs an array parameter" unless Array === @args.first
+    end
+
+    def set_args_normal
+      case arg = @params[:with]
+      when Array
+        @args = arg.dup rescue arg
+      else
+        @args = [ (arg.dup rescue arg) ]
+      end
+    end
+
+    def set_message
+      case @message
+      when Array
+        @__all__ = true
+      end
+    end
+
+    def set_lambda blk
+
+      if use_block?
+        @after  = blk if @params[:after] == :use_block
+        @before = blk if @params[:before] == :use_block || @params[:before_with_block] == :use_block
+        @lambda = @params[:with_block]
+      else
+        raise ArgumentError, "cannot use :with_block and a block" if
+          @params[:with_block] && blk
+
+        @lambda = @params.fetch :with_block, blk
+      end
+    end
+
+    def set_target
+      [:to, :to_chain, :to_object, :to_hash].each do | tgt_kwd |
+        tgt = @params[ tgt_kwd ]
+        next unless tgt
+
+        raise ArgumentError, "more than one target specified." if @target
+        @target = tgt 
+      end
+      raise ArgumentError, "no target specified." unless @target
+    end
+
+    def translate_to_hash
+      return unless @params[:to_hash]
+      raise ArgumentError, "cannot provide arguments for to_hash:" if @params.has_key?( :with ) || @params.has_key?( :with_ary )
+    end
+    def use_block?
+      aop_values.include?( :use_block )
+    end
+  end # class Arguments
+end # module Forwarder

data/lib/forwarder/compiler.rb

@@ -0,0 +1,63 @@
+require 'forwarder/evaller'
+module Forwarder
+  # The compiler's responsability is to create a string representation of
+  # the delegation method, or to nil if no such string representation exists
+  # and delegation has to be done dynamically.
+  class Compiler
+    attr_reader :arguments
+
+    
+    def compile
+      # Cannot compile because of intrinsic uncompilable traits of arguments
+      return if arguments.must_not_compile?
+
+      # To Hash can always compile
+      return compile_to_hash if arguments.to_hash?
+
+      # Cannot compile only because the arguments.args cannot be compiled
+      @compiled_args = Evaller.serialize arguments.args
+      return unless @compiled_args
+
+      # Can compile :)))
+      return compile_to_all if arguments.message.is_a? Array
+      compile_one
+    end
+
+    private
+
+    def compile_one
+      tltion = arguments.translation arguments.message
+      "def #{arguments.message} *args, &blk; " +
+        "#{self.class.compile_target arguments.target}.#{tltion}( " +
+        @compiled_args +
+        "*args, &blk ) end"
+    end
+
+    def compile_to_all
+      arguments.message.map{ |msg|
+        "def #{msg} *args, &blk; #{arguments.target}.#{msg}( *args, &blk ) end"
+      }.join("\n")
+    end
+
+    def compile_to_hash
+      target = arguments.to_hash?
+      target = target.join(".") if Array === target
+      [arguments.message]
+        .flatten
+        .map do | msg |
+          # N.B. that the expression between [] is always a Symbol
+          "def #{msg}; #{target}[ #{(arguments.translation||msg).to_sym.inspect} ] end"
+        end.join("\n")#.tap do |x| debugger end
+    end
+
+    def initialize args
+      @arguments = args 
+    end
+    
+    class << self
+      def compile_target target
+        [ target ].flatten.join( "." )
+      end
+    end
+  end # class Compiler
+end # module Forwarder

data/lib/forwarder/evaller.rb

@@ -0,0 +1,59 @@
+module Forwarder
+  module Evaller extend self
+
+    NotSerializable = Class.new RuntimeError
+
+    def evaluable? an_object, cache={}
+      !!_serialize_one( an_object, cache )
+    rescue NotSerializable
+      false
+    end
+
+    def serialize args
+      return "" if args.nil? || args.empty?
+      serialize_without_arg_suffix( args ).join(", ") + ", "
+    rescue NotSerializable
+      nil
+    end
+
+    def serialize_without_arg_suffix args, cache={}
+      args.map{ | arg |
+        _serialize_one arg, cache
+      }
+    end
+
+    private
+    def _serialize_hash hsh, cache
+      hsh.inject [] do | r, (k, v) |
+        k = _serialize_one k, cache
+        v = _serialize_one v, cache
+        r << "#{k} => #{v}"
+      end.join( ", ")
+    end
+
+    def _serialize_one arg, cache
+      case arg
+      when String
+        "'" + arg + "'"
+      when Symbol, Fixnum, NilClass, FalseClass, TrueClass
+        arg.inspect
+      else
+        _serialize_object arg, cache
+      end
+    end
+
+    def _serialize_object arg, cache
+      oid = arg.object_id
+      raise NotSerializable if cache[oid]
+      cache[oid]=true
+      case arg
+      when Array
+        ["[ ", serialize_without_arg_suffix( arg, cache ).join(", "), " ]"].join
+      when Hash
+        [ "{ ", _serialize_hash( arg, cache ), " }" ].join
+      else
+        raise NotSerializable
+      end
+    end
+  end # module Evaller
+end # module Forwarder

data/lib/forwarder/meta.rb

@@ -0,0 +1,118 @@
+module Forwarder
+  # I am the workerbee defining the methods and stuff
+  class Meta
+
+    attr_reader :arguments, :forwardee
+
+    # TODO: Break AOP out of this so that we do not check @ runtime
+    def forward
+      if arguments.before_with_block?
+        forward_with_before_with_block
+      elsif arguments.aop?
+        forward_with_aop
+      else
+        forward_without_aop
+      end
+    end
+
+    def forward_chain
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          if a.before_with_block?
+            args = Array(a.before.(*args,&blk)) if a.before_with_block?
+            blk = args.pop
+          elsif a.before?
+            args = instance_exec( *args, &a.before )
+          end
+
+          tgt = a.target.inject( self ){ |r, sym| sr.( r, sym ) }
+          tgt.send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ).tap do | result |
+              break a.after.( result ) if a.after?
+            end
+            #.send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ) 
+        end
+      end
+    end
+
+    def forward_object
+      a = arguments
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          args = instance_exec( *args, &a.before ) if a.before?
+
+          a.object_target( self )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ).tap do | result |
+              break instance_exec( result, &a.after ) if a.after?
+            end
+        end
+      end
+      
+    end
+
+    private
+
+    def forward_with_aop
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          args = instance_exec( *args, &a.before ) if a.before?
+          sr
+            .( self, a.target )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ).tap do | result |
+              break instance_exec( result, &a.after ) if a.after?
+            end
+        end
+      end
+    end
+
+    def forward_without_aop
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          sr
+            .( self, a.target )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) )
+        end
+      end
+    end
+
+    def forward_with_before_with_block
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          args = Array(a.before.(*args, &blk))
+          new_blk = args.pop
+
+          sr
+            .( self, a.target )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( new_blk ) ).tap do | result |
+              break instance_exec( result, &a.after ) if a.after?
+            end
+        end
+      end
+      
+    end
+
+    def initialize forwardee, arguments
+      @forwardee = forwardee
+      @arguments = arguments
+    end
+
+    def symbolic_receiver
+      @__symbolic_receiver__ = ->(rec, sym) do
+        case "#{sym}"
+        when /\A@/
+          rec.instance_variable_get sym
+        else
+          rec.send sym
+        end 
+      end
+    end
+
+  end # class Meta
+end # module Forwarder

data/lib/forwarder/params.rb

@@ -0,0 +1,42 @@
+require 'forwarder/arguments'
+require 'forwarder/compiler'
+require 'forwarder/meta'
+
+module Forwarder
+  class Params
+    attr_reader :forwardee, :arguments
+    def forward!
+      compiled = compile_forward
+      if compiled
+        forwardee.module_eval compiled, __FILE__, __LINE__
+      else
+        general_delegate
+      end
+    end
+
+    def prepare_forward *args, &blk
+      @arguments = Arguments.new( *args, &blk ) 
+    end
+    
+    private
+
+    def compile_forward
+      compiler = Compiler.new arguments
+      compiler.compile 
+    end
+
+    def initialize forwardee
+      @forwardee = forwardee
+    end
+
+    def general_delegate
+      if arguments.chain?
+        Meta.new( forwardee, arguments ).forward_chain
+      elsif arguments.custom_target?
+        Meta.new( forwardee, arguments ).forward_object
+      else
+        Meta.new( forwardee, arguments ).forward
+      end
+    end
+  end # class Params
+end # module Forwarder

data/lib/forwarder/version.rb

@@ -0,0 +1,3 @@
+module Forwarder
+  Version = '0.2.0'
+end # module Forwarder

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: forwarder2
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Robert Dober
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: "Ruby's core Forwardable gets the job done(barely) and produces most
+  unreadable code. \n\n  Forwarder2 not only is more readable, much more feature rich,
+  but also slightly faster, meaning you can use it without performance penalty.\n\n
+  \ Additional features include: providing arguments, (partially if needed), AOP and
+  custom forwarding to hashes\n  "
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/forwarder.rb
+- lib/forwarder/arguments.rb
+- lib/forwarder/evaller.rb
+- lib/forwarder/compiler.rb
+- lib/forwarder/version.rb
+- lib/forwarder/meta.rb
+- lib/forwarder/params.rb
+- LICENSE
+- README.md
+homepage: https://github.com/RobertDober/Forwarder2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.3
+signing_key: 
+specification_version: 4
+summary: Delegation And AOP Filters For It
+test_files: []