proxeze 1.0.0 → 1.1.0

data/README.rdoc

@@ -4,7 +4,7 @@ A basic proxy/delegate framework for Ruby that will allow you to wrap any object
 
 == Details
 
-When Proxeze proxies an object, it creates a delegate class under its namespace (using Ruby's built-in Delegate class) that mirrors your class. It overrides your class' #new method so that when you create instances of your class, you get back the proxy object instead. In this way, you don't have to change the way you instantiate your objects, but you get the benefit of the proxy pattern. When proxying a class, Proxeze will also proxy most class methods (see Proxying Classes below).
+When Proxeze proxies an object it creates a delegate class under its namespace (using Ruby's built-in Delegate class) that mirrors your class. It overrides your class' #new method so that when you create instances of your class you get back the proxy object instead. In this way, you don't have to change the way you instantiate your objects, but you get the benefit of the proxy pattern. When proxying a class Proxeze will also proxy most class methods (see Proxying Classes below).
 
 == How does that help me?
 
@@ -13,60 +13,62 @@ Examples tell it best... In this example we have a tree structure of Categories.
   class Category
     attr_accessor :categories
     attr_reader   :name
-    
     def initialize name
       @name = name
       @categories = []
     end
   end
-  
-  # now every time we instantiate Category, we will get back a Proxeze::Category instance
+
+  # now every time we instantiate Category, we
+  # will get back a Proxeze::Category instance
   Proxeze.proxy Category
-  
-  c1, c2, c3 = Category.new('1'), Category.new('2'), Category.new('3')
-  c1.categories = [c2, c3]
-  c2.categories << Category.new('4')
-  c2.categories << Category.new('5')
-  c6 = Category.new('6')
-  c2.categories << c6
-  c6.categories << Category.new('7')
-  c6.categories << Category.new('8')
-  
-  # now we have a tree like this:
-  #          c1
-  #       ___||___
-  #       ||    ||
-  #       c2    c3
-  #   ____||____
-  #   ||  ||  ||
-  #   c4  c5  c6
-  #        ___||___
-  #        ||    ||
-  #        c7    c8
-  
-Let's say we need to be able to hide c6 and its children at some point, to do that we can run the following code:
 
+  # Controls the visibility of the categories
   module Visibility
     def visible?
       @visible = true if @visible.nil?
       @visible
     end
-    
+
     def be_invisible!
       @visible = false
       categories.each {|e| e.be_invisible!}
       self
     end
-    
+
     def be_visible!
       @visible = true
       categories.each {|e| e.be_visible!}
       self
     end
+
+    Proxeze::Category.send :include, self
   end
-  Proxeze::Category.send :include, Visibility
-  
+
+  # instantiate Category objects as we normally would
+  c1            = Category.new('1')
+  c1.categories = [Category.new('2'), Category.new('3')]
+  c2            = c1.categories.first
+  c2.categories = [Category.new('4'), Category.new('5'), Category.new('6')]
+  c6            = c2.categories.last
+  c6.categories = [Category.new('7'), Category.new('8')]
+
   c6.be_invisible!
+
+  # before we hide c6 and its children   |    after hiding c6
+  # we have a tree like this:            |    our tree becomes:
+  # ------------------------------------ + --------------------
+  #                c1                    +            c1
+  #             ___||___                 +         ___||___
+  #             ||    ||                 +         ||    ||
+  #             c2    c3                 +         c2    c3
+  #         ____||____                   +     ____||____
+  #         ||  ||  ||                   +     ||      ||
+  #         c4  c5  c6                   +     c4      c5
+  #              ___||__                 +
+  #              ||    |                 +
+  #              c7    c8                +
+  #                                      |
   
 So, we've added behavior to the proxied objects, but not the Category objects themselves.
 
@@ -118,6 +120,9 @@ 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).
+
 == Supported Ruby versions
 This code has been tested on 1.8.7, 1.9.2, and JRuby 1.5.6. I haven't bothered to test it on anything else, but I strongly suspect it will work just fine on any Ruby implementation greater than 1.8.6.
 

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/proxeze.rb

@@ -1,4 +1,6 @@
-require 'delegate'
+require 'proxeze/delegator_blocks'
+require 'proxeze/instance_methods'
+require 'proxeze/class_methods'
 
 module Proxeze
   if RUBY_VERSION =~ /1\.9/
@@ -35,28 +37,28 @@ module Proxeze
   # all subsequent calls to #new on that class will return
   # an instance of a proxied class (in the Proxeze namespace),
   # thereby allowing seemless integration with existing
-  # classes.
+  # classes and object creation.
   # 
-  # Typically, only the Proxeze.for method should pass in
-  # redefine_new_method=false here.
-  def self.proxy target_class, opts = {}
+  # Typically, only the Proxeze>>#for method should pass in
+  # :redefine_new_method => false here.
+  def self.proxy target_class, opts = {}, &callback_blk
     options = default_proxy_options.merge opts
-    cls_name = target_class.name.gsub( '::', '' )
+    cls_name = class_name_for(target_class)
     unless self.class_defined? cls_name
       cls = DelegateClass target_class
-      cls.send :include, self
+      cls.send :include, Copying
+      cls.send :include, Hooks
+      cls.send :extend, ClassHooks
       self.const_set cls_name, cls
-
+      
       excluded_class_methods = object_methods + [:new, :public_api, :delegating_block] + options[:exclude_class_methods]
       (class_methods_from(target_class) - excluded_class_methods + options[:include_class_methods]).each do |method|
-        blk = class_delegating_block(method, target_class)
+        blk = Delegator.delegating_block_for_method_and_target(method, target_class)
         (class << cls; self; end).instance_eval do
           define_method(method, &blk)
         end
       end
     end
-    
-    cls = self.const_get cls_name
 
     # we have to collect the methods as Strings here because
     # 1.9 changed the implementation to return Symbols instead of Strings
@@ -71,35 +73,35 @@ module Proxeze
       }, __FILE__, __LINE__
     end
     
-    self.const_get cls_name
+    cls = self.const_get cls_name
+    unless callback_blk.nil?
+      # (class << cls; self; end).instance_eval &callback_blk
+      cls.instance_eval &callback_blk
+    end
+    cls
   end
   
   def self.default_proxy_options
     {:redefine_new_method => true, :exclude_class_methods => [], :include_class_methods => []}
   end
   
-  def self.class_delegating_block mid, target
-    lambda do |*args, &block|
-      begin
-        target.__send__(mid, *args, &block)
-      ensure
-        $@.delete_if {|t| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:/o =~ t} if $@
-      end
-    end
-  end
-  
   # create a proxy object for the given object
-  def self.for object
-    self.proxy( object.class, :redefine_new_method => false ).new( object )
+  def self.for object, &callback_blk
+    proxy = self.proxy( object.class, :redefine_new_method => false ).new( object )
+    proxy.class.hooks.clear
+    cls = (class << proxy; self; end)
+    cls.send :include, Copying unless cls.ancestors.include?(Copying)
+    cls.send :include, Hooks unless cls.ancestors.include?(Hooks)
+    cls.send :extend, ClassHooks unless cls.ancestors.include?(ClassHooks)
+    unless callback_blk.nil?
+      proxy.instance_eval &callback_blk
+    end
+    proxy
   end
   
-  # create a new proxy around a clone of my delegate object
-  def clone
-    Proxeze.for __getobj__.clone
-  end
-
-  # create a new proxy object for my delegate
-  def new_proxy
-    Proxeze.for __getobj__
-  end
+  private
+    def self.class_name_for target_class
+      name = target_class.name ? target_class.name : "#{target_class}"
+      name.gsub( 'Class:', '' ).gsub( /[:<>#]/, '' )
+    end
 end

data/lib/proxeze/class_methods.rb

@@ -0,0 +1,47 @@
+module Proxeze
+  module ClassHooks
+    def hooks
+      @hooks ||= {:after => {}, :after_all => {}, :before => {}, :before_all => {}}
+    end
+    
+    # The after hook will receive 3 arguments:
+    # target, result, and any arguments to the
+    # method that was called.
+    def after mid, *args, &blk
+      insert_into_callback_chain :hook => :after, :mid => mid, :args => args, :blk => blk
+    end
+
+    # 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
+    end
+
+    # The before hook will receive 2 arguments:
+    # target and any arguments to the method that
+    # is being called.
+    def before mid, *args, &blk
+      insert_into_callback_chain :hook => :before, :mid => mid, :args => args, :blk => blk
+    end
+
+    # 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
+    end
+    
+    private
+      def insert_into_callback_chain options={}
+        hook, mid, args, blk = options[:hook], options[:mid], options[:args], options[:blk]
+        callback = blk.nil? ? args : blk
+        if mid
+          self.hooks[hook] ||= {}
+          self.hooks[hook][mid] = callback
+        else
+          self.hooks[hook] = callback
+        end
+      end
+  end
+end

data/lib/proxeze/delegator_blocks.rb

@@ -0,0 +1,89 @@
+require 'delegate'
+
+def Delegator.delegating_block mid
+  lambda do |*args, &block|
+    target = self.__getobj__
+    begin
+      mid    = mid.to_sym
+      method = mid.to_s
+
+      after_all = self.class.hooks[:after_all]
+      after = self.class.hooks[:after] ? self.class.hooks[:after][mid] : nil
+      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)
+
+      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)
+      return result_after_all if result_after_all
+      return result_after if result_after
+      result
+    ensure
+      $@.delete_if {|t| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:/o =~ t} if $@
+    end
+  end
+end
+
+def Delegator.delegating_block_for_method_and_target mid, target
+  lambda do |*args, &block|
+    begin
+      target.__send__(mid, *args, &block)
+    ensure
+      $@.delete_if {|t| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:/o =~ t} if $@
+    end
+  end
+end
+
+unless RUBY_VERSION =~ /1\.9/
+  def DelegateClass(superclass)
+    klass = Class.new
+    methods = superclass.public_instance_methods(true)
+    methods -= ::Kernel.public_instance_methods(false)
+    methods |= ["to_s","to_a","inspect","==","=~","==="]
+    klass.module_eval {
+      def initialize(obj)  # :nodoc:
+        @_dc_obj = obj
+      end
+      def method_missing(m, *args, &block)  # :nodoc:
+        unless @_dc_obj.respond_to?(m)
+          super(m, *args, &block)
+        end
+        @_dc_obj.__send__(m, *args, &block)
+      end
+      def respond_to?(m, include_private = false)  # :nodoc:
+        return true if super
+        return @_dc_obj.respond_to?(m, include_private)
+      end
+      def __getobj__  # :nodoc:
+        @_dc_obj
+      end
+      def __setobj__(obj)  # :nodoc:
+        raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+        @_dc_obj = obj
+      end
+      def clone  # :nodoc:
+        new = super
+        new.__setobj__(__getobj__.clone)
+        new
+      end
+      def dup  # :nodoc:
+        new = super
+        new.__setobj__(__getobj__.clone)
+        new
+      end
+    }
+    for method in methods
+      begin
+        klass.module_eval do
+          define_method method, Delegator.delegating_block(method)
+        end
+      rescue SyntaxError
+        raise NameError, "invalid identifier %s" % method, caller(3)
+      end
+    end
+    return klass
+  end
+end

data/lib/proxeze/instance_methods.rb

@@ -0,0 +1,89 @@
+module Proxeze
+  module Copying
+    # create a new proxy around a clone of my delegate object
+    def clone
+      hooks = self.class.hooks
+      clone = Proxeze.for __getobj__.clone
+      clone.class.hooks.merge hooks
+      clone
+    end
+
+    # create a new proxy object for my delegate
+    def new_proxy
+      Proxeze.for __getobj__
+    end
+  end
+
+  module Hooks
+    def after mid, *args, &blk
+      self.class.after mid, *args, &blk
+    end
+
+    def after_all &blk
+      self.class.after_all &blk
+    end
+
+    def before mid, *args, &blk
+      self.class.before mid, *args, &blk
+    end
+
+    def before_all &blk
+      self.class.before_all &blk
+    end
+
+    private               
+      def execute_call container, *args
+        executor = get_executor(container)
+        result = nil
+        if executor.respond_to? :each
+          executor.each do |e|
+            result = e.send :call, *args 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(:new, *args).call if class?(executor) 
+      end
+
+      def get_executor container
+        return nil unless container                              
+
+        # The content is a proc or a class
+        return container if proc?(container) or class?(container)
+
+        # The content is an array with an array filled with a regex and a proc or a class
+        if array?(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
+
+        hash?(container) ? container[@method_symbol] : container
+      end
+
+      def regexp_elements array
+        elements = array.collect {|sub_array| array_with_regex?(sub_array) ? sub_array : nil}
+        compacted_array = elements.compact
+        compacted_array.nil? ? [] : compacted_array
+      end
+
+      def get_regexp array
+        array.detect {|element| element.class == Regexp}
+      end
+
+      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 array? param; param and param.class == Array end
+      def hash? param; param and param.class == Hash end
+      def regexp? array; array and not regexp_elements(array).empty? end
+  end
+end

data/proxeze.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxeze}
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jason Rogers"]
-  s.date = %q{2011-02-05}
+  s.date = %q{2011-02-19}
   s.description = %q{A basic proxy/delegate framework for Ruby that will allow you to wrap any object with a proxy instance. For more information about the Proxy and Delegate patterns, check out http://en.wikipedia.org/wiki/Proxy_pattern and http://en.wikipedia.org/wiki/Delegation_pattern respectively.}
   s.email = %q{jacaetevha@gmail.com}
   s.extra_rdoc_files = [
@@ -32,7 +32,11 @@ Gem::Specification.new do |s|
     "examples/sinatra/views/index.haml",
     "examples/sinatra/views/layout.haml",
     "lib/proxeze.rb",
+    "lib/proxeze/class_methods.rb",
+    "lib/proxeze/delegator_blocks.rb",
+    "lib/proxeze/instance_methods.rb",
     "proxeze.gemspec",
+    "run-rvm-specs",
     "spec/definitions.rb",
     "spec/proxeze_spec.rb",
     "spec/spec_helper.rb"

data/run-rvm-specs

@@ -0,0 +1,2 @@
+#!/bin/bash
+rvm jruby,1.8.7,1.9.2 specs

data/spec/definitions.rb

@@ -52,6 +52,14 @@ class ClassWithOverriddenObjectMethod
   def self.hash; 17; end
 end
 
+class ClassWhereinWeMeetBeforeBlocks
+  def foo; 1; end
+  def bar; 2.0; end
+  def baz arg
+    (arg.to_f / foo) * bar
+  end
+end
+
 class Category
   attr_accessor :categories
   attr_reader   :name

data/spec/proxeze_spec.rb

@@ -1,6 +1,12 @@
 require File.dirname(__FILE__) + '/spec_helper'
 require 'definitions'
 
+class Symbol
+  def <=> other
+    self.to_s <=> other.to_s
+  end
+end
+
 shared_examples_for "all wrapped classes" do
   it "should wrap the class>>#new method so we get an instance of the proxy instead" do
     Proxeze.proxy Testing::NestedClass
@@ -167,4 +173,110 @@ describe Proxeze do
     Proxeze::ClassWithOverriddenObjectMethod.should respond_to(:hash)
     Proxeze::ClassWithOverriddenObjectMethod.hash.should == 17
   end
+  
+  it "should run 'before' callbacks" do
+    baz_method_args = nil
+    Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
+      before :baz do |*args|
+        baz_method_args = args.last
+      end
+    end
+    instance = ClassWhereinWeMeetBeforeBlocks.new
+    instance.foo.should == 1
+    instance.bar.should == 2.0
+    instance.baz(2).should == 4.0
+    baz_method_args.should == [2]
+  end
+
+  it "should run 'before_all' callbacks" do
+    callbacks = {}
+    Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
+      before_all do |*args|
+        target, mid, arguments = *args
+        callbacks[mid] = arguments
+      end
+    end
+    instance = ClassWhereinWeMeetBeforeBlocks.new
+    instance.foo.should == 1
+    instance.bar.should == 2.0
+    instance.baz(2).should == 4.0
+    
+    callbacks.keys.sort.should == [:bar, :baz, :foo]
+    callbacks[:foo].should == []
+    callbacks[:bar].should == []
+    callbacks[:baz].should == [2]
+  end
+
+  it "should run 'after' callbacks" do
+    callbacks = {}
+    Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
+      after :foo do |*args|
+        callbacks[:foo] = args.last
+        args[-2]
+      end
+    end
+    instance = ClassWhereinWeMeetBeforeBlocks.new
+    instance.foo.should == 1
+    instance.bar.should == 2.0
+    instance.baz(2).should == 4.0
+    
+    callbacks.keys.sort.should == [:foo]
+    callbacks[:foo].should == []
+  end
+
+  it "should run 'after_all' callbacks" do
+    callbacks = {}
+    Proxeze.proxy( ClassWhereinWeMeetBeforeBlocks ) do
+      after_all do |*args|
+        target, result, mid, arguments = *args
+        callbacks[mid] = result
+        result * 2
+      end
+    end
+    instance = ClassWhereinWeMeetBeforeBlocks.new
+    instance.foo.should == 2
+    instance.bar.should == 4.0
+    instance.baz(2).should == 8.0
+    
+    callbacks.keys.sort.should == [:bar, :baz, :foo]
+    callbacks[:foo].should == 1
+    callbacks[:bar].should == 2.0
+    callbacks[:baz].should == 4.0
+  end
+  
+  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 |*args|
+        target, mid, arguments = *args
+        target << target.length
+      end
+    end
+    a.reverse.should == [6, 4, 5, 2, 3, 1, 0]
+
+    a.after :sort do |*args|
+      target, result, arguments = *args
+      result << result.length
+    end
+    a.sort.should == [0, 1, 2, 3, 4, 5, 6, 7]
+    
+    # make sure that other instances of Arrays don't get the
+    # behavior added to the proxied instances above
+    [0, 1, 3, 2, 5, 4].sort.reverse.should == [5, 4, 3, 2, 1, 0]
+    [1, 3, 2].reverse.should == [2, 3, 1]
+    Proxeze.for([1, 3, 2]).reverse.should == [2, 3, 1]
+  end
+  
+  it "should accept a class for the callbacks" do
+    class SortPerformer
+      def initialize object, result = nil, method = nil, args = nil
+        @object = object; @result = result; @method = method, @args = args
+      end
+
+      def call; @object.sort! end
+    end
+    p = Proxeze.for [1, 2, 3] do
+      after :reverse, SortPerformer
+    end
+    p.reverse.should == [1, 2, 3]
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: proxeze
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Jason Rogers
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-05 00:00:00 -05:00
+date: 2011-02-19 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -170,7 +170,11 @@ files:
 - examples/sinatra/views/index.haml
 - examples/sinatra/views/layout.haml
 - lib/proxeze.rb
+- lib/proxeze/class_methods.rb
+- lib/proxeze/delegator_blocks.rb
+- lib/proxeze/instance_methods.rb
 - proxeze.gemspec
+- run-rvm-specs
 - spec/definitions.rb
 - spec/proxeze_spec.rb
 - spec/spec_helper.rb
@@ -188,7 +192,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4275161442413397534
+      hash: 1558564409570473253
       segments: 
       - 0
       version: "0"