forwarder19 0.1.0

data/LICENSE

@@ -0,0 +1,10 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 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,430 @@
+# Forwarder19
+
+This implementation is for, and needs, Ruby 1.9.2 or later. 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
+
+Performance is _normal_, as it is for 'Forwardable' however the goal is to have delegated methods
+to run about as twice as fast as methods created by 'Forwardable.def_delegator'. This seems to be
+a realistic goal as can be seen here: https://github.com/RobertDober/Forwarder19/blob/dev/bm/study.rb
+
+
+## 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/, '\& ' ]
+```
+
+### 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_whitespace_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_whitespace_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_whitespace_to_punctuation( '\1- ' )
+  # name: "the,- quick,- fox." )
+```
+
+### 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( &applyto( :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/arguments.rb

@@ -0,0 +1,145 @@
+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]
+    end
+
+    def before?
+      before
+    end
+
+    def chain?
+      @params[ :to_chain ]
+    end
+
+    def custom_target?
+      @params[:to_object]
+    end
+
+    def delegatable?
+      !aop? && !custom_target? && !all? && !chain? && !args && !lambda?
+    end
+
+    def complete_args *args
+      (self.args || []) + args
+    end
+
+    def lambda default=nil
+      lambda? || default
+    end
+
+    def lambda?
+      @lambda
+    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 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 ).compact
+    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
+    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
+      set_args_normal if hw
+      set_args_ary if ha
+    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
+      else
+        @args = [ 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
+        @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].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 use_block?
+      aop_values.include?( :use_block )
+    end
+  end # class Arguments
+end # module Forwarder

data/lib/forwarder/helpers.rb

@@ -0,0 +1,4 @@
+require 'forwarder/helpers/proc'
+require 'forwarder/helpers/integer'
+require 'forwarder/helpers/kernel'
+require 'forwarder/helpers/object'

data/lib/forwarder/meta.rb

@@ -0,0 +1,71 @@
+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
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          args = a.before.(*args) if a.before?
+          sr
+            .( self, a.target )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ).tap do | result |
+              break a.after.( result ) if a.after?
+            end
+        end
+      end
+    end
+
+    def forward_chain
+      a = arguments
+      sr = symbolic_receiver
+      forwardee.module_eval do
+        define_method a.message do |*args, &blk|
+          args = a.before.(*args) if a.before?
+          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 = a.before.(*args) if a.before?
+          a.object_target( self )
+            .send( a.translation( a.message ), *a.complete_args(*args), &a.lambda( blk ) ).tap do | result |
+              break a.after.( result ) if a.after?
+            end
+        end
+      end
+      
+    end
+
+    private
+    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,70 @@
+require 'forwarder/arguments'
+require 'forwarder/meta'
+module Forwarder
+  class Params
+    attr_reader :forwardee, :arguments
+    def forward!
+      return if delegate
+      return if delegate_all
+      return if delegate_chain  
+      return if delegate_object
+      general_delegate
+    end
+
+    def prepare_forward *args, &blk
+      @arguments = Arguments.new( *args, &blk ) 
+    end
+    
+    private
+
+    def delegate
+      return unless arguments.delegatable? 
+      delegate_to_forwardee
+      true
+    end
+
+    def delegate_all
+      return unless arguments.all?
+      delegate_all_to_forwardee
+      true
+    end
+
+    def delegate_all_to_forwardee
+      forwardee.extend Forwardable
+      forwardee.def_delegators( arguments.target, *arguments.message )
+    end
+
+
+    def delegate_chain
+      return unless arguments.chain?
+      delegate_to_chain
+      true
+    end
+
+    def delegate_to_chain
+      Meta.new( forwardee, arguments ).forward_chain
+    end
+
+    def delegate_object
+      return unless arguments.custom_target?
+      Meta.new( forwardee, arguments ).forward_object
+      true
+    end
+      
+    def delegate_to_forwardee
+      forwardee.extend Forwardable
+      arguments.translation do | tltion |
+        forwardee.def_delegator arguments.target, tltion, arguments.message
+      end or
+        forwardee.def_delegator arguments.target, arguments.message
+    end
+
+    def initialize forwardee
+      @forwardee = forwardee
+    end
+
+    def general_delegate
+      Meta.new( forwardee, arguments ).forward
+    end
+  end # class Params
+end # module Forwarder

data/lib/forwarder/version.rb

@@ -0,0 +1,3 @@
+module Forwarder
+  VERSION = '0.1.0'
+end # module Forwarder

data/lib/forwarder.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+require 'forwarder/params'
+
+module Forwarder
+  
+  def forward *args, &blk
+    params = Forwarder::Params.new self
+    params.prepare_forward( *args, &blk )
+    params.forward!
+  end
+
+  def forward_all *args, &blk
+    params = Forwarder::Params.new self
+    opts   = args.pop
+    params.prepare_forward( args, opts, &blk )
+    params.forward!
+  end
+end # module Forwarder

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: forwarder19
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Robert Dober
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lab419_core
+  requirement: &82223890 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *82223890
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &82223620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: *82223620
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &82223370 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *82223370
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &82223140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *82223140
+- !ruby/object:Gem::Dependency
+  name: maruku
+  requirement: &82222910 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *82222910
+- !ruby/object:Gem::Dependency
+  name: wirble
+  requirement: &82222680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :development
+  prerelease: false
+  version_requirements: *82222680
+description: ! 'Ruby''s core Forwardable gets the job done(barely) and produces most
+  unreadable code. Furthermore it is about twice as slow (1.9.2-p290) or thrice as
+  slow (1.9.3-p0) as it needs to be.
+
+  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 some AOP support as after and before filters.
+
+  Performance will be pushed to 2~3 times of Fowardable with the 0.2 branch of this
+  gem'
+email: robert.dober@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/forwarder/arguments.rb
+- lib/forwarder/meta.rb
+- lib/forwarder/params.rb
+- lib/forwarder/helpers.rb
+- lib/forwarder/version.rb
+- lib/forwarder.rb
+- LICENSE
+- README.md
+homepage: https://github.com/RobertDober/Forwarder
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Delegation And AOP Filters For It
+test_files: []
+has_rdoc: