proxeze 0.5.0 → 1.0.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 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?
 
@@ -95,6 +95,29 @@ Of course, you can proxy the class and all subsequent instances even after you'v
   a.class             # => Proxeze::A 
   a.__getobj__.class  # => A
 
+== Proxying Classes
+As we said before when you proxy a class, generally speaking, the #new method will be aliased so that all subsequent instances of the class will be proxied instances. What is the #new method? It's just an instance method of your class. What about all of the other instance methods of the class? In large part, they are available also, though there are mechanisms for making them unavailable. Consider this scenario:
+
+  class A
+    def self.foo; 1; end
+    def self.bar; 1; end
+  end
+  
+I can tell Proxeze to allow for the invocation of the #foo method, but not the #bar method like this:
+
+  Proxeze.proxy A, :exclude_class_methods => [:bar]
+  
+If you don't specify the :exclude_class_methods option, all class methods defined in your class will be available.
+
+The special case to this is that class methods defined in Object are not proxied, and there are a few class methods in the Delegate framework that are excluded. What if you've overridden a class method that is already defined in Object, like #hash? Well you can *include* that by sending the :include_class_methods option:
+
+  class A
+    def self.hash; 17; end
+  end
+  Proxeze.proxy A, :include_class_methods => [:hash]
+
+Note: I don't recommend overriding the #hash method on your class, this serves only as an example.
+
 == 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 @@
-0.5.0
+1.0.0

data/lib/proxeze.rb

@@ -5,15 +5,31 @@ module Proxeze
     def self.class_defined? name
       const_defined? name, false
     end
+
+    def self.object_methods
+      Object.methods
+    end
+    
+    def self.class_methods_from target_class
+      target_class.methods
+    end
   else
     def self.class_defined? name
       const_defined? name
     end
+
+    def self.object_methods
+      Object.methods.collect{|e| e.to_sym}
+    end
+    
+    def self.class_methods_from target_class
+      target_class.methods.collect{|e| e.to_sym}
+    end
   end
   
   # Create a proxy class for the given target class.
-  # If redefine_new_method is false, the target class' #new
-  # method will not be reimplemented.
+  # If the :redefine_new_method option is false, the
+  # target class' #new method will not be reimplemented.
   #
   # When the target class' #new method is reimplemented,
   # all subsequent calls to #new on that class will return
@@ -23,25 +39,28 @@ module Proxeze
   # 
   # Typically, only the Proxeze.for method should pass in
   # redefine_new_method=false here.
-  def self.proxy target_class, redefine_new_method = true
+  def self.proxy target_class, opts = {}
+    options = default_proxy_options.merge opts
     cls_name = target_class.name.gsub( '::', '' )
     unless self.class_defined? cls_name
       cls = DelegateClass target_class
       cls.send :include, self
       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)
+        (class << cls; self; end).instance_eval do
+          define_method(method, &blk)
+        end
+      end
     end
     
     cls = self.const_get cls_name
-    (target_class.methods - Object.methods - [:new, :public_api, :delegating_block]).each do |method|
-      blk = class_delegating_block(method, target_class)
-      (class << cls; self; end).instance_eval do
-        define_method(method, &blk)
-      end
-    end
 
     # we have to collect the methods as Strings here because
     # 1.9 changed the implementation to return Symbols instead of Strings
-    if redefine_new_method && !target_class.methods.collect{|e| e.to_s}.include?('new_with_extra_behavior')
+    if options[:redefine_new_method] && !target_class.methods.collect{|e| e.to_s}.include?('new_with_extra_behavior')
       meta = class << target_class; self; end
       meta.class_eval %Q{
         def new_with_extra_behavior *args, &blk
@@ -55,6 +74,10 @@ module Proxeze
     self.const_get cls_name
   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
@@ -67,7 +90,7 @@ module Proxeze
   
   # create a proxy object for the given object
   def self.for object
-    self.proxy( object.class, false ).new( object )
+    self.proxy( object.class, :redefine_new_method => false ).new( object )
   end
   
   # create a new proxy around a clone of my delegate object

data/proxeze.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxeze}
-  s.version = "0.5.0"
+  s.version = "1.0.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-04}
+  s.date = %q{2011-02-05}
   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 = [

data/spec/definitions.rb

@@ -43,6 +43,15 @@ class ClassWithClassMethods
   def self.foo; 1; end
 end
 
+class ClassWithClassMethods_SomeOfWhichWillBeExcluded
+  def self.foo; 1; end
+  def self.bar; 2; end
+end
+
+class ClassWithOverriddenObjectMethod
+  def self.hash; 17; end
+end
+
 class Category
   attr_accessor :categories
   attr_reader   :name

data/spec/proxeze_spec.rb

@@ -150,8 +150,21 @@ describe Proxeze do
   end
   
   it "should proxy class methods also" do
-    proxy_class = Proxeze.proxy ClassWithClassMethods
+    Proxeze.proxy ClassWithClassMethods
     Proxeze::ClassWithClassMethods.should respond_to(:foo)
     Proxeze::ClassWithClassMethods.foo.should == ClassWithClassMethods.foo
   end
+  
+  it "should not proxy class methods that are marked as excluded" do
+    Proxeze.proxy ClassWithClassMethods_SomeOfWhichWillBeExcluded, :exclude_class_methods => [:foo]
+    Proxeze::ClassWithClassMethods_SomeOfWhichWillBeExcluded.should_not respond_to(:foo)
+    Proxeze::ClassWithClassMethods_SomeOfWhichWillBeExcluded.should respond_to(:bar)
+    Proxeze::ClassWithClassMethods_SomeOfWhichWillBeExcluded.bar.should == ClassWithClassMethods_SomeOfWhichWillBeExcluded.bar
+  end
+
+  it "should proxy class methods also" do
+    Proxeze.proxy ClassWithOverriddenObjectMethod, :include_class_methods => [:hash]
+    Proxeze::ClassWithOverriddenObjectMethod.should respond_to(:hash)
+    Proxeze::ClassWithOverriddenObjectMethod.hash.should == 17
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: proxeze
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Jason Rogers
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-04 00:00:00 -05:00
+date: 2011-02-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -188,7 +188,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -744132594254975345
+      hash: -4275161442413397534
       segments: 
       - 0
       version: "0"