proxy_machine 0.0.3 → 0.0.4

data/README.rdoc

@@ -1,3 +1,5 @@
+= proxy_machine
+
 == Description
   
 A cool proxy implementation pattern in ruby
@@ -35,8 +37,10 @@ Callafters:
 === Defining callbefores and callafters in all method calls
 
 Callbefores:
+This callback will receive a reference of the object, the symbol of the called method and the
+arguments passed.
 
-  p = proxy_for [1, 2, 3], :before_all => lambda {|obj| puts 'before all'}
+  p = proxy_for [1, 2, 3], :before_all => lambda {|obj, method, args| puts 'before all'}
   p.reverse => before all
                [3, 2, 1]
   
@@ -44,8 +48,10 @@ Callbefores:
             3
 
 Callafters:
+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.
                
-  p = proxy_for [1, 2, 3], :after_all => lambda {|obj, result| puts result}
+  p = proxy_for [1, 2, 3], :after_all => lambda {|obj, result, method, args| puts result}
   p.reverse => [1, 2, 3]
                [1, 2, 3] # puts
                
@@ -54,14 +60,14 @@ Callafters:
 
 === 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.
+The constructor will receive the object, in case of a callafter 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.
+every time it need to use it. You could use this feature with the before_all and after_all too.
 
   # Example of class
   class SortPerformer
-    def initialize object, result = nil
-      @object = object; @result = result
+    def initialize object, result = nil, method = nil, args = nil
+      @object = object; @result = result; @method = method, @args = args
     end
                              
     def call; @object.sort! end
@@ -72,22 +78,115 @@ every time it need to use it.
   }
   
   p.reverse => [1, 2, 3]
-                      
-=== How to detect that the object is a proxy?
-             
-The beautiful way
+
+=== Controlling the method execution with regexp
+                       
+For before_all and after_all you could use regexp to configure whicth methods will be affected.
+  
+  # Example of class
+  class MyRegexMethods                    
+    attr_accessor :value
+    def get_value1; @value ? @value : 'get' end
+    def get_value2; @value ? @value : 'get' end
+    def another_method; @value ? @value : 'another' end
+    def crazy_one; @value ? @value : 'crazy' end
+  end
+   
+  p = proxy_for MyRegexMethods.new, :before_all => {
+    :call1 => [/^get_/, lambda {|obj, method, args| obj.value = 'gotcha!' }],
+  }
+  
+  p.get_value1 => gotcha!
+  p.get_value2 => gotcha!
+  p.another_method => 'another
+  proxy.crazy_one => 'crazy'
+
+You could use many definitions if you want, the calls will happen in alphabetical order of the keys.  
+
+  p = proxy_for MyRegexMethods.new, :before_all => {
+    :call2 => [/value/, lambda {|obj, method, args| obj.value = "#{obj.value}works"}],
+    :call1 => [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
+  }
+  
+  p.get_value1 => it_works
+  p.get_value2 => it_works
+  p.another_method => another
+  p.crazy_one => crazy
+
+It is also possible to use classes instead of procs.
+            
+  # Example of class
+  class Change2Performer
+    def initialize object, result = nil, method = nil, args = nil
+      @object = object; @result = result; @method = method, @args = args
+    end
+    
+    def call; @object.value = "#{@object.value}works" end
+  end
+  
+  p = proxy_for MyRegexMethods.new, :before_all => {
+    :call2 => [/value/, Change2Performer],
+    :call1 => [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
+  }
+  
+  p.get_value1 => it_works
+  p.get_value2 => it_works
+  p.another_method => another
+  p.crazy_one => crazy
   
+=== How to detect that the object is a proxy?
+
+The beautiful way:
+
   o1 = [1, 2, 3]
   o1.proxied? => false
-  
+
   o2 = proxy_for [1, 2, 3] 
   o2.proxied? => true
-  
-Other way
-  
+
+Other way:
+
   p = proxy_for [1, 2, 3]
   defined? p.proxied_class?
+                
+=== Getting access to the original object
+                                
+Call original_object method in the proxy object.
+
+  proxy = proxy_for [1, 2, 3]
+  proxy.proxied? => true
+  proxy.original_object.proxied? => false
+  
+=== Special options
+
+1 - allow_dinamic: Allow execute methods based on method missing, that do not exists actually.
+When allow_dinamic is enabled, proxy_machine will not check if this method really exists.
+Default is false.
 
+  # Example of class
+  class MyClass
+    attr_accessor :value
+    def method_missing(symbol, *args); 'nice!'; end
+  end
+  
+  p = proxy_for MyClass.new, :allow_dinamic => true, :before => {
+    :magic_method => lambda {|obj| obj.value = 'other value' }
+  }
+  
+  p.magic_method => 'other value'
+  
+2 - avoid_original_execution: When this option is enabled, proxy_machine will not call the original method.
+Default is false.
+  
+  p = proxy_for [3, 2, 1], 
+    :avoid_original_execution => true,
+    :before => {
+      :empty? => lambda {|obj| obj.sort!}
+    }
+    
+  p.empty? => nil
+  p.original_object => [1, 2, 3]
+                      
 === Trying it in irb
 
   irb
@@ -126,4 +225,8 @@ Other way
                   :size => lambda {|obj| puts "before: #{obj.inspect}"}
                 }, :after => {
                   :size => lambda {|obj, result| puts "after: #{obj.inspect}: result => #{result}"}
-                }
+                }
+
+== Copyright
+
+Copyright (c) 2010 Túlio Ornelas. See LICENSE for details.                

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/init.rb

@@ -1,5 +1 @@
-require 'proxy_machine'
-include ProxyMachine
-
-require 'kernel'
-require 'object'
+require 'proxy_machine'

data/lib/proxy_machine/proxy.rb

@@ -2,61 +2,100 @@ module ProxyMachine
   
   class Proxy < BasicObject
 
-    def initialize object, calls = nil
+    def initialize object, params = nil
       @object = object                    
       @before = @before_all = @after = @after_all = nil
+      @allow_dinamic = false
+      @avoid_original_execution = false
       
-      if calls                  
-        @before = calls[:before]
-        @before_all = calls[:before_all]
-        @after = calls[:after]
-        @after_all = calls[:after_all]
+      if params
+        @allow_dinamic = params[:allow_dinamic]
+        @avoid_original_execution = params[:avoid_original_execution]
+        @before = params[:before]
+        @before_all = params[:before_all]
+        @after = params[:after]
+        @after_all = params[:after_all]
       end
     end
                             
     def method_missing(symbol, *args)
       @symbol = symbol        
-      method = symbol.to_s
-      raise NoMethodError.new(method) unless @object.methods.member?(method)
-                                       
-      execute_call(@before_all, @object)
+      @method = symbol.to_s
+                                             
+      raise NoMethodError.new(@method) unless @allow_dinamic or @object.methods.member?(@method)
+      
+      execute_call(@before_all, @object, symbol, args)
       execute_call(@before, @object)
-
-      @result = @object.send(method, *args)
+                              
+      @result = @avoid_original_execution ? nil : @object.send(@method, *args)
 
       result_after = execute_call(@after, @object, @result)
-      result_after_all = execute_call(@after_all, @object, @result)
-         
+      result_after_all = execute_call(@after_all, @object, @result, symbol, args)
+
       return result_after_all if result_after_all
       return result_after if result_after
       @result
     end
     
     def proxied_class?; true end
-    
+    def original_object; @object end
+      
     private               
     def execute_call container, *args
       executor = get_executor(container)
       
+      result = nil
+      if executor.class == Array
+        executor.each do |e|
+          result = e.send :call, *args if proc?(e)
+          result = e.send(:new, *args).send :call if class?(e) 
+        end
+        return result
+      end                    
+      
       return executor.send :call, *args if proc?(executor)
       return executor.send(:new, *args).send :call if class?(executor) 
     end
     
     def get_executor container
-      if container
-        return container if proc?(container) or class?(container)
-        return container[@symbol]
+      return nil unless container                              
+      
+      # The content is a proc or a class
+      return container if proc?(container) or class?(container)
+      
+      # The content is a hash with an array filled with a regex and a proc or a class
+      if hash?(container) and regexp?(container)
+        matched = regexp_elements(container).select {|array| get_regexp(array) =~ @method}
+        return matched.collect {|array| get_proc_or_class(array)} unless matched.empty?
       end
+      
+      # Lets assume that the content of the key is a proc
+      container[@symbol]
     end
                 
-    def proc? block
-      block and block.class == Proc
+    def regexp_elements hash
+      elements = hash.keys.sort.collect {|key| array_with_regex?(hash[key]) ? hash[key] : nil}
+      compacted_array = elements.compact
+      compacted_array.nil? ? [] : compacted_array
+    end
+    
+    def get_regexp array
+      array.detect {|element| element.class == Regexp}
     end
     
-    def class? param
-      param and param.class == Class
+    def get_proc_or_class array
+      array.detect {|element| proc?(element) or class?(element)}
+    end  
+    
+    def array_with_regex? array
+      array.class == Array and array.size == 2 and not get_regexp(array).nil?
     end
     
+    def proc? block; block and block.class == Proc end
+    def class? param; param and param.class == Class end
+    def hash? param; param and param.class == Hash end
+    def regexp? hash; hash and not regexp_elements(hash).empty? end
+
   end
   
 end

data/lib/proxy_machine.rb

@@ -5,9 +5,9 @@ module ProxyMachine
   end unless defined?(BasicObject)
   
 end
-                            
-require 'proxy_machine/proxy'
-include ProxyMachine
-
+                    
 require 'kernel'
-require 'object'
+require 'object'
+require 'symbol'                            
+require 'proxy_machine/proxy'
+include ProxyMachine

data/lib/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  include Comparable
+
+  def <=>(other)    
+    self.to_s <=> other.to_s
+  end
+end

data/proxy_machine.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxy_machine}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   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-19}
+  s.date = %q{2010-10-25}
   s.description = %q{A cool proxy implementation pattern in ruby}
   s.email = %q{ornelas.tulio@gmail.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
      "lib/object.rb",
      "lib/proxy_machine.rb",
      "lib/proxy_machine/proxy.rb",
+     "lib/symbol.rb",
      "proxy_machine.gemspec",
      "spec/proxy_spec.rb"
   ]

data/spec/proxy_spec.rb

@@ -54,21 +54,38 @@ describe Proxy do
   end
   
   context 'for all methods' do
+    class AllMethodsClass
+      attr_accessor :method, :args
+      def do_something; 50 end
+    end             
     
     it 'should add a callbefore' do
       array = [3, 2, 1]
-      proxy = Proxy.new array, :before_all => lambda {|obj| obj.sort!}
+      proxy = Proxy.new array, :before_all => lambda {|obj, method, args| obj.sort!}
       proxy.should_not be_nil
       proxy.reverse.should == [3, 2, 1]
       proxy.max.should == 3
       proxy.first.should == 1
       proxy.to_s.should == "123"
     end
+    
+    it 'should provide method name and arguments for the block in callbefore' do
+      obj = AllMethodsClass.new
+      proxy = proxy_for obj, :before_all => lambda {|obj, method, args|
+        obj.method = method
+        obj.args = args
+      }
+      
+      proxy.should_not be_nil
+      proxy.do_something.should == 50
+      proxy.original_object.method.should == :do_something
+      proxy.original_object.args.should be_empty
+    end
 
     it 'should add a callafter' do
       array = [1, 2, 3]
       
-      proxy = Proxy.new array, :after_all => lambda {|obj, result|
+      proxy = Proxy.new array, :after_all => lambda {|obj, result, method, args|
         return result * 10 if result.class == Fixnum
         result
       }
@@ -80,11 +97,25 @@ describe Proxy do
       proxy.to_s.should == "123"
     end
     
+    it 'should provide method name and arguments for the block in callafter' do
+      obj = AllMethodsClass.new
+      proxy = proxy_for obj, :after_all => lambda {|obj, result, method, args|
+        obj.method = method
+        obj.args = args
+        nil
+      }
+      
+      proxy.should_not be_nil
+      proxy.do_something.should == 50
+      proxy.original_object.method.should == :do_something
+      proxy.original_object.args.should be_empty
+    end
+    
     it 'should add both, callbefore and callafter' do
       array = [3, 2, 1]
       proxy = Proxy.new array, 
-      :before_all => lambda {|obj| obj.sort!},
-      :after_all => lambda {|obj, result|
+      :before_all => lambda {|obj, method, args| obj.sort!},
+      :after_all => lambda {|obj, result, method, args|
         return result * 10 if result.class == Fixnum
         result
       }
@@ -134,8 +165,8 @@ describe Proxy do
   context 'when registering a class' do
     # Example of class
     class SortPerformer
-      def initialize object, result = nil
-        @object = object; @result = result
+      def initialize object, result = nil, method = nil, args = nil
+        @object = object; @result = result; @method = method, @args = args
       end
       
       def call; @object.sort! end
@@ -159,6 +190,219 @@ describe Proxy do
       proxy.reverse.should == [3, 2, 1]
     end
     
+    it 'should use a instance of the registered class for callbefore_all' do
+      array = [3, 2, 1]
+      proxy = proxy_for array, :before_all => SortPerformer
+
+      proxy.should_not be_nil                  
+      proxy.reverse.should == [3, 2, 1]
+    end
+    
+    it 'should use a instance of the registered class for callafter_all' do
+      array = [1, 2, 3]
+      proxy = proxy_for array, :after_all => SortPerformer
+
+      proxy.should_not be_nil                  
+      proxy.reverse.should == [1, 2, 3]
+    end
+    
+  end
+  
+  context 'with dinamic methods' do
+    class MyClass
+      attr_accessor :value
+      def method_missing(symbol, *args); @value; end
+    end
+    
+    it 'should allow dinamic methods' do
+      obj = MyClass.new
+      obj.value = "Crazy Value"
+      
+      proxy = proxy_for obj, :allow_dinamic => true, :before => {
+        :crazy_method => lambda {|obj| obj.value = "proxied value!" }
+      }
+                    
+      proxy.should_not be_nil                  
+      proxy.crazy_method.should == "proxied value!"
+    end
+    
+  end
+  
+  context 'avoiding original execution' do
+    class AvoidOriginal
+      attr_accessor :value
+      def do_something; @value = "original" end
+    end
+    
+    it 'should happen' do
+      obj = AvoidOriginal.new
+      proxy = proxy_for obj, :avoid_original_execution => true, :after_all => lambda {|obj, result, method, args|
+        "avoided"
+      }
+      
+      proxy.should_not be_nil
+      proxy.do_something.should == "avoided"
+      proxy.original_object.value.should be_nil
+    end
+  end
+    
+  context 'filtering methods by regex' do
+    class MyRegexMethods                    
+      attr_accessor :value
+      def get_value1; @value ? @value : 'get' end
+      def get_value2; @value ? @value : 'get' end
+      def another_method; @value ? @value : 'another' end
+      def crazy_one; @value ? @value : 'crazy' end
+    end
+    
+    class Change1Performer
+      def initialize object, result = nil, method = nil, args = nil
+        @object = object; @result = result; @method = method, @args = args
+      end
+      
+      def call; @object.value = 'gotcha!' end
+    end
+    
+    class Change2Performer
+      def initialize object, result = nil, method = nil, args = nil
+        @object = object; @result = result; @method = method, @args = args
+      end
+      
+      def call; @object.value = "#{@object.value}works" end
+    end
+    
+    it 'should affect just the matched methods on callbefore' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :before_all => {
+        :call1 => [/^get_/, lambda {|obj, method, args| obj.value = 'gotcha!' }],
+        :call2 => [/method$/, lambda {|obj, method, args| obj.value = 'another gotcha!' }]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
+    it 'should affect just the matched methods on callafter' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :after_all => {
+        :call1 => [/^get_/, lambda {|obj, result, method, args| obj.value = 'gotcha!' }],
+        :call2 => [/method$/, lambda {|obj, result, method, args| obj.value = 'another gotcha!'}]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
+    it 'should execute the entire matched stack on callbefore sorted by the key name' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :before_all => {
+        :call2 => [/value/, lambda {|obj, method, args| obj.value = "#{obj.value}works"}],
+        :call1 => [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 'it_works'
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 'it_works'
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
+    it 'should ensure that the last value returned is the value of the last called method' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :after_all => {
+        :call2 => [/value/, lambda {|obj, result, method, args| 2}],
+        :call1 => [/get_/, lambda {|obj, result, method, args| 1}]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 2
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 2
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
+    it 'should affect just the matched methods using a registered class' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :before_all => {
+        :call1 => [/^get_/, Change1Performer],
+        :call2 => [/method$/, lambda {|obj, method, args| obj.value = 'another gotcha!' }]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 'gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another gotcha!'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
+    it 'should execute the entire matched stack sorted by the key name using a registered class' do
+      obj = MyRegexMethods.new
+      proxy = proxy_for obj, :before_all => {
+        :call2 => [/value/, Change2Performer],
+        :call1 => [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
+      }
+      
+      proxy.should_not be_nil
+      
+      proxy.original_object.value = nil
+      proxy.get_value1.should == 'it_works'
+      
+      proxy.original_object.value = nil
+      proxy.get_value2.should == 'it_works'
+      
+      proxy.original_object.value = nil
+      proxy.another_method.should == 'another'
+      
+      proxy.original_object.value = nil
+      proxy.crazy_one.should == 'crazy'
+    end
+    
   end
   
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: proxy_machine
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - "T\xC3\xBAlio Ornelas"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-19 00:00:00 -02:00
+date: 2010-10-25 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,6 +53,7 @@ files:
 - lib/object.rb
 - lib/proxy_machine.rb
 - lib/proxy_machine/proxy.rb
+- lib/symbol.rb
 - proxy_machine.gemspec
 - spec/proxy_spec.rb
 has_rdoc: true