proxeze 1.1.1 → 1.2.0

data/README.rdoc

@@ -121,14 +121,16 @@ The special case to this is that class methods defined in Object are not proxied
 Note: I don't recommend overriding the #hash method on your class, this serves only as an example.
 
 == Method Interceptions
-Proxeze has the ability to surround instance method calls with _before_ and _after_ callbacks. This support was lifted straight from proxy_machine (https://github.com/tulios/proxy_machine).
+Proxeze has the ability to surround instance method calls with _before_ and _after_ callbacks. This support was lifted straight from proxy_machine (https://github.com/tulios/proxy_machine). Unlike proxy_machine, all callbacks receive the same set of parameters:
+a reference to the object, the arguments passed, the symbol of the called method, and the result of execution (this result could be nil,
+and necessarily *will* be nil in _before_ and _before_all_ interceptions).
 
 === Defining callbacks at the method level
                      
 ==== before
 
   p = Proxeze.for [0, 1, 2, 3] do
-    before :reverse do |obj, args|
+    before :reverse do |obj, args, mid, result|
       obj << obj.length
     end
   end  
@@ -138,24 +140,20 @@ Proxeze has the ability to surround instance method calls with _before_ and _aft
 ==== after
                
   p = Proxeze.for [4, 2, 3] do
-    after :reverse do |obj, result, args|
+    after :reverse do |obj, args, mid, result|
       result.sort
     end
   end
 
-  p.reverse => [4, 3, 2] # We reordered the list
-                  
-You will always receive the arguments passed to the original method.               
+  p.reverse => [4, 3, 2] # We reordered the list       
                
 === Defining callbacks for all method calls
 
 ==== before_all
-This callback will receive a reference of the object, the symbol of the called method and the
-original arguments passed.
 
   logged = nil
   p = Proxeze.for [0, 1, 2, 3] do
-    before_all do |obj, method, args|
+    before_all do |obj, args, method, result|
       logged = "before #{method} on #{obj.inspect} with args[#{args.inspect}]"
     end
   end
@@ -169,12 +167,10 @@ original arguments passed.
   logged      # => before unshift on [0, 1, 2, 3] with args[[9]]
 
 ==== after_all
-This callback will receive a reference of the object, the result of execution (this result could be nil), 
-the symbol of the called method and the arguments passed.
 
   logged = nil
   p = Proxeze.for [1, 2, 3] do
-    after_all do |obj, result, method, args|
+    after_all do |obj, args, method, result|
       logged = "after #{method} on #{obj.inspect} with args[#{args.inspect}], result is now [#{result}]"
       result
     end
@@ -187,14 +183,14 @@ the symbol of the called method and the arguments passed.
 
 === Registering a class to perform a callback
                        
-The constructor will receive the object, in case of an :after it will receive the result too.
-You need to have a :call method. Proxeze will create a new instance of the class every time it
-needs to use it. You could use this feature with the before_all and after_all too.
+The initializer will receive an extra parameter, the type of the callback (one of #before, #before_all, #after, or #after_all).
+In addition it also receives the object, the arguments passed to the method, the method called, and a result (which is populated for #after and 
+#after_all hooks). You will also need to define a #call method. Proxeze will create a new instance of the class every time it needs to use it.
 
   # Example of class
   class SortPerformer
-    def initialize object, result = nil, method = nil, args = nil
-      @object = object; @result = result; @method = method, @args = args
+    def initialize callback_type, object, args = nil, method = nil, result = nil
+      @object = object; @args = args; @method = method; @result = result
     end
                              
     def call; @object.sort! end

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/lib/proxeze/class_methods.rb

@@ -14,8 +14,8 @@ module Proxeze
     # The after_all hook will receive 4 arguments:
     # target, result, method id, and any arguments
     # to the method that was called.
-    def after_all &blk
-      insert_into_callback_chain :hook => :after_all, :blk => blk
+    def after_all *args, &blk
+      insert_into_callback_chain :hook => :after_all, :blk => blk, :args => args
     end
 
     # The before hook will receive 2 arguments:
@@ -28,8 +28,8 @@ module Proxeze
     # The before_all hook will receive 3 arguments:
     # target, method id, and any arguments to the
     # method that is being called.
-    def before_all &blk
-      insert_into_callback_chain :hook => :before_all, :blk => blk
+    def before_all *args, &blk
+      insert_into_callback_chain :hook => :before_all, :blk => blk, :args => args
     end
     
     private

data/lib/proxeze/delegator_blocks.rb

@@ -12,12 +12,12 @@ def Delegator.delegating_block mid
       before_all = self.class.hooks[:before_all]
       before = self.class.hooks[:before] ? self.class.hooks[:before][mid] : nil
 
-      execute_call(before_all, target, mid, args)
-      execute_call(before, target, args)
+      execute_call(before_all, :before_all, target, args, mid)
+      execute_call(before, :before, target, args, mid)
 
       result = target.__send__(mid, *args, &block)
-      result_after = execute_call(after, target, result, args)
-      result_after_all = execute_call(after_all, target, result, mid, args)
+      result_after = execute_call(after, :after, target, args, mid, result)
+      result_after_all = execute_call(after_all, :after_all, target, args, mid, result)
       return result_after_all if result_after_all
       return result_after if result_after
       result

data/lib/proxeze/instance_methods.rb

@@ -19,16 +19,16 @@ module Proxeze
       self.class.after mid, *args, &blk
     end
 
-    def after_all &blk
-      self.class.after_all &blk
+    def after_all *args, &blk
+      self.class.after_all *args, &blk
     end
 
     def before mid, *args, &blk
       self.class.before mid, *args, &blk
     end
 
-    def before_all &blk
-      self.class.before_all &blk
+    def before_all *args, &blk
+      self.class.before_all *args, &blk
     end
 
     private               
@@ -37,13 +37,13 @@ module Proxeze
         result = nil
         if executor.respond_to? :each
           executor.each do |e|
-            result = e.send :call, *args if proc?(e)
+            result = e.send :call, *args[1..-1] if proc?(e)
             result = e.send(:new, *args).call if class?(e) 
           end
           return result
         end                    
 
-        return executor.send :call, *args if proc?(executor)
+        return executor.send :call, *args[1..-1] if proc?(executor)
         return executor.send(:new, *args).call if class?(executor) 
       end
 

data/proxeze.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxeze}
-  s.version = "1.1.1"
+  s.version = "1.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jason Rogers"]

data/spec/proxeze_spec.rb

@@ -177,8 +177,8 @@ describe Proxeze do
   it "should run 'before' callbacks" do
     baz_method_args = nil
     Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
-      before :baz do |*args|
-        baz_method_args = args.last
+      before :baz do |target, args, mid, result|
+        baz_method_args = args
       end
     end
     instance = ClassWhereinWeMeetBeforeBlocks.new
@@ -191,9 +191,8 @@ describe Proxeze do
   it "should run 'before_all' callbacks" do
     callbacks = {}
     Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
-      before_all do |*args|
-        target, mid, arguments = *args
-        callbacks[mid] = arguments
+      before_all do |target, args, mid, result|
+        callbacks[mid] = args
       end
     end
     instance = ClassWhereinWeMeetBeforeBlocks.new
@@ -210,9 +209,9 @@ describe Proxeze do
   it "should run 'after' callbacks" do
     callbacks = {}
     Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
-      after :foo do |*args|
-        callbacks[:foo] = args.last
-        args[-2]
+      after :foo do |target, args, mid, result|
+        callbacks[mid] = args
+        result
       end
     end
     instance = ClassWhereinWeMeetBeforeBlocks.new
@@ -227,8 +226,7 @@ describe Proxeze do
   it "should run 'after_all' callbacks" do
     callbacks = {}
     Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
-      after_all do |*args|
-        target, result, mid, arguments = *args
+      after_all do |target, arguments, mid, result|
         callbacks[mid] = result
         result * 2
       end
@@ -246,14 +244,13 @@ describe Proxeze do
   
   it "should be able to add hooks to a proxied instance" do
     a = Proxeze.for [0, 1, 3, 2, 5, 4] do
-      before :reverse do |target, mid, arguments|
+      before :reverse do |target, arguments, mid|
         target << target.length
       end
     end
     a.reverse.should == [6, 4, 5, 2, 3, 1, 0]
 
-    a.after :sort do |*args|
-      target, result, arguments = *args
+    a.after :sort do |target, arguments, mid, result|
       result << result.length
     end
     a.sort.should == [0, 1, 2, 3, 4, 5, 6, 7]
@@ -267,7 +264,7 @@ describe Proxeze do
   
   it "should accept a class for the callbacks" do
     class SortPerformer
-      def initialize object, result = nil, method = nil, args = nil
+      def initialize callback_type, object, args = nil, method = nil, result = nil
         @object = object; @result = result; @method = method, @args = args
       end
 
@@ -278,4 +275,46 @@ describe Proxeze do
     end
     p.reverse.should == [1, 2, 3]
   end
+  
+  it "should accept a class for before_all and after_all callbacks" do
+    class MyClass
+      attr_accessor :foo
+      def inspect
+        'an instance of MyClass'
+      end
+    end
+
+    class DebugLogInterceptor
+      def self.logger
+        @logger ||= []
+        @logger
+      end
+      
+      def initialize callback_type, object, args = nil, method = nil, result = nil
+        @callback_type = callback_type
+        @object = object
+        @result = result
+        @method = method
+        @args = args
+      end
+      
+      def call
+        self.class.logger << log_message
+      end
+
+      def log_message
+        "#{@callback_type}: #{@method} on #{@object.inspect} with args[#{@args.inspect}], result is [#{@result}]"
+      end
+    end
+
+    Proxeze.proxy MyClass do
+      after_all  DebugLogInterceptor
+      before_all DebugLogInterceptor
+    end
+
+    o = MyClass.new
+    o.foo = 2
+    DebugLogInterceptor.logger.should == ["before_all: foo= on an instance of MyClass with args[[2]], result is []", 
+                                          "after_all: foo= on an instance of MyClass with args[[2]], result is [2]"]
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: proxeze
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors: 
 - Jason Rogers
@@ -192,7 +192,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2385236588266356416
+      hash: 1901228362628821152
       segments: 
       - 0
       version: "0"