proxy_machine 0.0.2 → 0.0.3

data/README.rdoc

@@ -12,7 +12,11 @@ A cool proxy implementation pattern in ruby
 
   p = proxy_for [1, 2, 3]
   p.reverse => [3, 2, 1]
-  
+            
+=== Defining callbefores and callafters in method level
+                     
+Callbefores:
+
   p = proxy_for [1, 2, 3], :before => {
     :reverse => lambda {|obj| puts 'before reverse'}
   }   
@@ -20,6 +24,55 @@ A cool proxy implementation pattern in ruby
   p.reverse => before reverse
                [3, 2, 1]
 
+Callafters:
+               
+  p = proxy_for [1, 2, 3], :after => {
+   :reverse => lambda {|obj, result| result.sort}
+  }   
+
+  p.reverse => [1, 2, 3] # We reordered the list
+               
+=== Defining callbefores and callafters in all method calls
+
+Callbefores:
+
+  p = proxy_for [1, 2, 3], :before_all => lambda {|obj| puts 'before all'}
+  p.reverse => before all
+               [3, 2, 1]
+  
+  p.size => before all
+            3
+
+Callafters:
+               
+  p = proxy_for [1, 2, 3], :after_all => lambda {|obj, result| puts result}
+  p.reverse => [1, 2, 3]
+               [1, 2, 3] # puts
+               
+  p.size => 3
+            3 # puts
+
+=== Registering a class to perform the callafter or callbefore
+                       
+The constructor will receive the object, in case of a callback it will receive the result too.
+You need to have a 'call' method. The ProxyMachine will create a new instance of the class
+every time it need to use it.
+
+  # Example of class
+  class SortPerformer
+    def initialize object, result = nil
+      @object = object; @result = result
+    end
+                             
+    def call; @object.sort! end
+  end
+  
+  p = proxy_for [1, 2, 3], :after => {
+    :reverse => SortPerformer
+  }
+  
+  p.reverse => [1, 2, 3]
+                      
 === How to detect that the object is a proxy?
              
 The beautiful way

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/proxy_machine/proxy.rb

@@ -1,38 +1,7 @@
 module ProxyMachine
   
   class Proxy < BasicObject
-    
-    # Examples:
-    # 1º - Creates a proxy for the informed object
-    #
-    # p = Proxy.new [1,2,3]
-    # p.size => 3
-    #
-    # 2º - A proxy with a before callback.
-    #
-    # p = Proxy.new [1,2,3], :before => {
-    #   :size => lambda {|obj| puts "before: #{obj.inspect}"}
-    # }
-    # p.size => before: [1, 2, 3]
-    #           3
-    #                   
-    # 3º - A proxy with a after callback
-    #
-    # p = Proxy.new [1,2,3], :after => {
-    #   :size => lambda {|obj, result| puts "after: #{obj.inspect}: result => #{result}"}
-    # }
-    # p.size => after: [1, 2, 3]: result => 3
-    #           3
-    #                  
-    # 4º - Both
-    #
-    # p = Proxy.new [1,2,3], 
-    #               :before => {
-    #                 :size => lambda {|obj| puts "before: #{obj.inspect}"}
-    #               }, :after => {
-    #                 :size => lambda {|obj, result| puts "after: #{obj.inspect}: result => #{result}"}
-    #               }
-    #
+
     def initialize object, calls = nil
       @object = object                    
       @before = @before_all = @after = @after_all = nil
@@ -45,42 +14,38 @@ module ProxyMachine
       end
     end
                             
-    def method_missing(symbol, *args)        
+    def method_missing(symbol, *args)
+      @symbol = symbol        
       method = symbol.to_s
       raise NoMethodError.new(method) unless @object.methods.member?(method)
                                        
-      execute_call(@before_all, symbol)
-      execute_call(@before, symbol)
+      execute_call(@before_all, @object)
+      execute_call(@before, @object)
 
-      result = @object.send(method, *args)
+      @result = @object.send(method, *args)
 
-      result_after = execute_call_with_result(@after, symbol, result)
-      result_after_all = execute_call_with_result(@after_all, symbol, result)
+      result_after = execute_call(@after, @object, @result)
+      result_after_all = execute_call(@after_all, @object, @result)
          
       return result_after_all if result_after_all
       return result_after if result_after
-      result
+      @result
     end
     
     def proxied_class?; true end
     
     private               
-    def execute_call container, method_symbol
-      if block = get_block(container, method_symbol) and proc?(block)
-        block.call(@object)
-      end
-    end
-                      
-    def execute_call_with_result container, method_symbol, result
-      if block = get_block(container, method_symbol) and proc?(block)
-        block.call(@object, result)
-      end
+    def execute_call container, *args
+      executor = get_executor(container)
+      
+      return executor.send :call, *args if proc?(executor)
+      return executor.send(:new, *args).send :call if class?(executor) 
     end
     
-    def get_block container, method_symbol
+    def get_executor container
       if container
-        return container if container.class == Proc
-        return container[method_symbol]
+        return container if proc?(container) or class?(container)
+        return container[@symbol]
       end
     end
                 
@@ -88,6 +53,10 @@ module ProxyMachine
       block and block.class == Proc
     end
     
+    def class? param
+      param and param.class == Class
+    end
+    
   end
   
 end

data/proxy_machine.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxy_machine}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["T\303\272lio Ornelas"]
-  s.date = %q{2010-10-05}
+  s.date = %q{2010-10-19}
   s.description = %q{A cool proxy implementation pattern in ruby}
   s.email = %q{ornelas.tulio@gmail.com}
   s.extra_rdoc_files = [

data/spec/proxy_spec.rb

@@ -12,6 +12,12 @@ describe Proxy do
     proxy.proxied_class?.should be_true
   end
   
+  it 'should detect a proxy object with proxied_class? method' do
+    array = [1, 2, 3]
+    proxy = Proxy.new array
+    (defined? proxy.proxied_class?).should_not be_nil
+  end
+  
   context 'for a certain method' do
   
     it 'should add a callbefore' do
@@ -113,6 +119,47 @@ describe Proxy do
     end
     
   end
+   
+  context 'for object method' do
+    
+    it 'should detect proxied objects' do
+      array1 = [1, 2, 3]
+      array1.proxied?.should be_false
+      array2 = proxy_for [1, 2, 3]
+      array2.proxied?.should be_true
+    end
+    
+  end
+  
+  context 'when registering a class' do
+    # Example of class
+    class SortPerformer
+      def initialize object, result = nil
+        @object = object; @result = result
+      end
+      
+      def call; @object.sort! end
+    end
+    
+    it 'should use a instance of the registered class for a callafter' do
+      array = [1, 2, 3]
+      proxy = proxy_for array, :after => {
+        :reverse => SortPerformer
+      }
+      proxy.should_not be_nil                  
+      proxy.reverse.should == [1, 2, 3]
+    end
+    
+    it 'should use a instance of the registered class for a callbefore' do
+      array = [3, 2, 1]
+      proxy = proxy_for array, :before => {
+        :reverse => SortPerformer
+      }
+      proxy.should_not be_nil                  
+      proxy.reverse.should == [3, 2, 1]
+    end
+    
+  end
   
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: proxy_machine
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - "T\xC3\xBAlio Ornelas"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 -03:00
+date: 2010-10-19 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency