object-proxy 0.1.0 → 0.2.0

data/Gemfile

@@ -1,12 +1,12 @@
 source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
-   gem "hash-utils", ">= 0.12.0"
+   gem "hash-utils", ">= 0.12.1"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.5.2"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.5.2"
   gem "riot", ">= 0.12.1"
 end

data/Gemfile.lock

@@ -2,21 +2,23 @@ GEM
   remote: http://rubygems.org/
   specs:
     git (1.2.5)
-    hash-utils (0.12.0)
-    jeweler (1.5.2)
-      bundler (~> 1.0.0)
+    hash-utils (1.1.0)
+      ruby-version
+    jeweler (1.6.4)
+      bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    rake (0.8.7)
-    riot (0.12.3)
+    rake (0.9.2)
+    riot (0.12.5)
       rr
-    rr (1.0.2)
+    rr (1.0.4)
+    ruby-version (0.3.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0.0)
-  hash-utils (>= 0.12.0)
-  jeweler (~> 1.5.2)
+  bundler (>= 1.0.0)
+  hash-utils (>= 0.12.1)
+  jeweler (>= 1.5.2)
   riot (>= 0.12.1)

data/README.md

@@ -2,22 +2,22 @@ Object Proxy
 ============
 
 **object-proxy** provides proxy objects intended for intercepting calls 
-to instance methods. Works as intermediate layer between caller and 
-called. Allows to invoke an handler both before method call and adjust 
-its  arguments and after call and post-proccess result. Aimed as tool 
-for instant adapting the complex objects without complete deriving and 
-extending whole classes in cases, where isn't possible to derive them 
-as homogenic functional units or where it's simply impractical to 
-derive them.
+to instance methods. It's aimed as tool for instant adapting the complex 
+objects without complete deriving and extending whole classes in cases, 
+where isn't possible to derive them as homogenic functional units or 
+where it's simply impractical to derive them. Provides four base 
+proxy types.
+
+### Standard Proxy
+Works as intermediate layer between caller and called. Allows to invoke 
+an handler both before method call and adjust its  arguments and after 
+call and post-proccess result. 
 
 See some slightly stupid example:
 
         require "object-proxy"
 
-
-        # OP[...] is shortcut, it creates the proxy object instance
-        
-        s = OP["1 2 3 4"]
+        s = OP::proxy("1 2 3 4")
         s.before_split do |args|
             args = [" "]
         end
@@ -30,6 +30,75 @@ See some slightly stupid example:
         p out
         
 Will print out `[2, 3, 4, 5]`.
+
+### Fake Proxy
+Simply fakes interface of an class, but with empty methods. Necessary 
+methods can be individually overwritten by custom callbacks. It's 
+equivalent to manual deriving class and reseting all its methods 
+to nothing.
+
+See some slightly stupid example:
+
+        pr = OP::fake(String, [:kind_of?]) do   # we will use #kind_of? below, 
+                                                #   so we need say, we don't want to reset it
+                                                
+            define_method :to_s do  # let's say, '#to_s' will return
+                "alfa beta"         #   fixed value
+            end
+        end
+
+        pr.to_s == "alfa beta"      # '#to_s' returns fixed value
+        pr.inspect.nil?             # '#inspect' and all others are reset
+                                    #   and return nil
+                                    
+        pr.kind_of? String          # but object still seems to be String :-)
+        
+### Tracking Proxy
+It's similar to *standard proxy*, but points all callbacks to single 
+callback set (single for before call callbacks and single for after call
+callbacks). Also doesn't allow to modify arguments and postprocess 
+results.
+
+See some slightly stupid example:
+    
+        calls = [ ]
+        s = OP::track("a,b,c,d")
+        
+        s.before_call do |name|     # sets 'before_call' handler
+            # track call names to array
+            calls << name 
+        end
+        
+        s << ",1,2,3"
+        s.gsub!(",", " ")
+        s.split(" ")
+        
+        p calls
+        
+Will print out `[:<<, :gsub!, :split]`.
+
+### Catching Proxy
+Catches all method calls and forwards them to the `#method_call` handler which 
+calls wrapped object by default, but can be overriden, so calls can be 
+fully controlled.
+
+See some slightly stupid example:
+
+        s = OP::catch("foo")
+        
+        s.method_call do |name, args, block|
+            if name == :to_s
+                s.wrapped.send(name, *args, &block)
+            else
+                :nothing
+            end
+        end
+        
+        p s.replace("beta")   # will print ":nothing" out
+        s.to_s                # will print "foo" out
+        
+But object still seems to be `String`.
+
         
 Contributing
 ------------

data/Rakefile

@@ -1,6 +1,7 @@
 # encoding: utf-8
 require 'rubygems'
 require 'bundler'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -8,15 +9,16 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-require 'rake'
 
+require 'rake'
 require 'jeweler'
+
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "object-proxy"
   gem.homepage = "http://github.com/martinkozak/object-proxy"
   gem.license = "MIT"
-  gem.summary = "Provides proxy objects intended for intercepting calls to instance methods. Works as intermediate layer between caller and called. Allows to invoke an handler both before method call and adjust its arguments and after call and post-proccess result. Aimed as tool for instant adapting the complex objects without complete deriving and extending whole classes in cases, where isn\'t possible to derive them as homogenic functional units or where it's simply impractical to derive them."
+  gem.summary = "Provides collection of four proxy objects intended for intercepting calls to instance methods. Works as intermediate layer between caller and called. Allows to invoke an handler both before method call and adjust its arguments and after call and post-proccess result. Aimed as tool for instant adapting the complex objects without complete deriving and extending whole classes in cases, where isn\'t possible to derive them as homogenic functional units or where it's simply impractical to derive them."
   gem.email = "martinkozak@martinkozak.net"
   gem.authors = ["Martin Kozák"]
   # Include your dependencies below. Runtime dependencies are required when using your gem,
@@ -25,13 +27,3 @@ Jeweler::Tasks.new do |gem|
   #  gem.add_development_dependency 'rspec', '> 1.2.3'
 end
 Jeweler::RubygemsDotOrgTasks.new
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "hash-utils #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/object-proxy.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 # (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
 
-require "hash-utils/symbol"
-require "hash-utils/object"
+require "hash-utils/symbol" # >= 0.13.0
+require "hash-utils/object" 
 
 ##
 # Main ObjectProxy class.
@@ -11,23 +11,26 @@ require "hash-utils/object"
 module ObjectProxy
 
     ##
-    # Creates proxy object.
+    # Creates proxy object. "Proxy object" means, it calls handler
+    # if defined before and after each method call.
     #
     # @param [Object] object proxied object 
     # @return [Class] anonymous proxy class with before and after 
     #   handlers functionality
+    # @since 0.2.0
     #
 
-    def self.create(object)
+    def self.proxy(object)
         cls = Class::new(object.class)
         cls.instance_eval do
         
             # Eviscerates instances methods and replace them by
+            #   before and after handlers invoker
             public_instance_methods.each do |method|
-                if not method.in? [:object_id, :__send__, :initialize]
+                if not method.in? [:object_id, :__send__]
                     define_method method do |*args, &block|
-                        before = ("before_" << method.to_s).to_sym
-                        after = ("after_" << method.to_s).to_sym
+                        before = method.prepend("before_")
+                        after = method.prepend("after_")
                         
                         # before handler
                         if @handlers.include? before
@@ -56,7 +59,7 @@ module ObjectProxy
             # Event handlers assigning interceptor
             define_method :method_missing do |name, *args, &block|
                 if name.start_with? "before_", "after_"
-                    self.register_handler(name, block)
+                    self.register_handler(name, &block)
                 end
             end
             
@@ -70,21 +73,182 @@ module ObjectProxy
         
         return cls::new(object)
     end
-end
-
-##
-# Shortcut module to [ObjectProxy].
-#
     
-module OP
-
     ##
-    # Alias for +ObjectProxy#create+.
-    # @see ObjectProxy
+    # Alias for +ObjectProxy::proxy+.
+    #
+    # @return [Class]
+    # @since 0.2.0
     #
     
     def self.[](object)
-        ObjectProxy::create(object)
+        self::proxy(object)
+    end
+        
+    ##
+    # Alias for +ObjectProxy::proxy+.
+    #
+    # @return [Class]
+    # @since 0.1.0
+    #
+    
+    def self.create(object)
+        self::proxy(object)
     end
     
+    ##
+    # Creates fake object. "Fake object" means, all methods are replaced
+    # by empty functions or defined bodies.
+    #
+    # Original class public instance functions are aliased to form: 
+    # +native_<name of function>+.
+    #
+    # @param [Class] cls class for fake
+    # @param [Proc] block block with definitions of custom methods 
+    #   which will be run in private context of the faked class
+    # @return [Class] anonymous class faked object
+    # @since 0.2.0
+    #
+    
+    def self.fake(cls, omit = [ ], &block)
+        cls = Class::new(cls)
+        cls.instance_eval do
+            omit.concat([:object_id, :__send__])
+            
+            # Eviscerates instances methods and replace them by
+            #   before and after handlers invoker
+            public_instance_methods.each do |method|
+                if not method.in? omit
+                    alias_method method.prepend("native_"), method
+                    define_method method do |*args, &block| end
+                end
+            end
+        end
+        
+        if not block.nil?
+            cls.instance_eval(&block)
+        end
+        
+        return cls
+    end
+    
+    ##
+    # Creates "tracker object". Works by similar way as standard proxy
+    # objects, but rather than invoking individual handlers for each 
+    # method call invokes single handler before and single after call
+    # which receives except arguments or result the method name.
+    #
+    # Also doesn't support customizing the arguments or result.
+    #
+    # @param [Object] object proxied object 
+    # @return [Class] anonymous proxy class with before and after 
+    #   handlers functionality
+    # @since 0.2.0
+    #
+    
+    def self.track(object)
+        cls = Class::new(object.class)
+        cls.instance_eval do
+        
+            # Eviscerates instances methods and replace them by 
+            # +#on_method+ invoker
+            
+            public_instance_methods.each do |method|
+                if not method.in? [:object_id, :__send__]
+                    define_method method do |*args, &block| 
+                        if not @before_call.nil?
+                            @before_call.call(method, args, block)
+                        end
+                        
+                        result = @wrapped.send(method, *args, &block)
+                        
+                        if not @after_call.nil?
+                            @after_call.call(method, result)
+                        end
+                        
+                        return result
+                    end
+                end
+            end
+            
+            # Adds constructor
+            
+            define_method :initialize do |wrapped|
+                @wrapped = wrapped
+                @before_call = nil
+                @after_call = nil
+            end
+            
+            # Defines handler assigners
+            
+            define_method :before_call do |&block|
+                @before_call = block
+            end
+            
+            define_method :after_call do |&block|
+                @after_call = block
+            end
+            
+        end
+        
+        return cls::new(object)
+    end
+
+    ##
+    # Creates "catching object". It means, it catches all method calls
+    # and forwards them to +#method_call+ handler which calls wrapped object
+    # by default, but can be overriden, so calls can be controlled.
+    #
+    # @param [Object] object proxied object 
+    # @return [Class] anonymous proxy class
+    # @since 0.2.0
+    #
+
+    def self.catch(object)
+        cls = Class::new(object.class)
+        cls.instance_eval do
+          
+            # Eviscerates instances methods and replace them by 
+            # +#handle_call+ invoker
+            
+            public_instance_methods.each do |method|
+                if not method.in? [:object_id, :__send__]
+                    define_method method do |*args, &block|
+                        @method_call.call(method, args, block)
+                    end
+                end
+            end
+            
+            # Adds constructor
+            
+            define_method :initialize do |wrapped|
+                @wrapped = wrapped
+                @method_call = Proc::new do |method, args, block|
+                    @wrapped.send(method, *args, &block)
+                end
+            end
+            
+            # Defines handler assigner
+            
+            define_method :method_call do |&block|
+                @method_call = block
+            end
+            
+            # Adds wrapped accessor
+
+            define_method :wrapped do
+                @wrapped
+            end
+                        
+        end
+        
+        return cls::new(object)
+    end    
 end
+
+##
+# Alias for {ObjectProxy}.
+#
+
+OP = ObjectProxy
+

data/object-proxy.gemspec

@@ -4,13 +4,13 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{object-proxy}
-  s.version = "0.1.0"
+  s.name = "object-proxy"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Martin Kozák"]
-  s.date = %q{2011-03-20}
-  s.email = %q{martinkozak@martinkozak.net}
+  s.authors = ["Martin Koz\u{e1}k"]
+  s.date = "2011-10-19"
+  s.email = "martinkozak@martinkozak.net"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md"
@@ -27,30 +27,30 @@ Gem::Specification.new do |s|
     "object-proxy.gemspec",
     "test"
   ]
-  s.homepage = %q{http://github.com/martinkozak/object-proxy}
+  s.homepage = "http://github.com/martinkozak/object-proxy"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{Provides proxy objects intended for intercepting calls to instance methods. Works as intermediate layer between caller and called. Allows to invoke an handler both before method call and adjust its arguments and after call and post-proccess result. Aimed as tool for instant adapting the complex objects without complete deriving and extending whole classes in cases, where isn't possible to derive them as homogenic functional units or where it's simply impractical to derive them.}
+  s.rubygems_version = "1.8.11"
+  s.summary = "Provides collection of four proxy objects intended for intercepting calls to instance methods. Works as intermediate layer between caller and called. Allows to invoke an handler both before method call and adjust its arguments and after call and post-proccess result. Aimed as tool for instant adapting the complex objects without complete deriving and extending whole classes in cases, where isn't possible to derive them as homogenic functional units or where it's simply impractical to derive them."
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<hash-utils>, [">= 0.12.0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_runtime_dependency(%q<hash-utils>, [">= 0.12.1"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.5.2"])
       s.add_development_dependency(%q<riot>, [">= 0.12.1"])
     else
-      s.add_dependency(%q<hash-utils>, [">= 0.12.0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<hash-utils>, [">= 0.12.1"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.5.2"])
       s.add_dependency(%q<riot>, [">= 0.12.1"])
     end
   else
-    s.add_dependency(%q<hash-utils>, [">= 0.12.0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<hash-utils>, [">= 0.12.1"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.5.2"])
     s.add_dependency(%q<riot>, [">= 0.12.1"])
   end
 end

data/test

@@ -7,7 +7,7 @@ require "object-proxy"
 require "riot"
 
 context "ObjectProxy" do
-    asserts("proxying") do 
+    asserts("#create") do 
         s = OP["a,b,c,d"]
 
         s.register_handler(:"before_<<") do |args|
@@ -21,4 +21,43 @@ context "ObjectProxy" do
 
         (s << ",1,2,3" == "alfa beta") and (s == "a,b,c,d,A,B,C")
     end
+    asserts("#fake") do
+        pr = OP::fake(String) do
+            define_method :to_s do 
+                "alfa beta"
+            end
+        end
+        
+        pr = pr::new
+        (pr.to_s == "alfa beta") and pr.inspect.nil?
+    end
+    asserts("#track") do
+        log = [ ]
+        s = OP::track("a,b,c,d")
+        s.before_call do |name|
+            log << name
+        end
+        s.after_call do |name|
+            log << name
+        end
+        s.gsub!(",", "")
+        
+        (log == [:gsub!, :gsub!]) and (s == "abcd")
+    end
+    asserts("#catch") do
+        s = OP::catch("alfa")
+        log = [ ]
+        
+        s.method_call do |name, args, block|
+            if name == :to_s
+                log << name
+                s.wrapped.send(name, *args, &block)
+            end
+        end
+        
+        s.replace("beta")
+        s.to_s
+        
+        (log == [:to_s]) and (s.to_s == "alfa")
+    end
 end

metadata

@@ -1,72 +1,68 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: object-proxy
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.2.0
   prerelease: 
-  version: 0.1.0
 platform: ruby
-authors: 
-- "Martin Koz\xC3\xA1k"
+authors:
+- Martin Kozák
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-20 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: hash-utils
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &11263140 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.12.0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.1
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *11263140
+- !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &11261480 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: *11261480
+- !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &11245700 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  version_requirements: *11245700
+- !ruby/object:Gem::Dependency
   name: riot
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &11244320 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.12.1
   type: :development
   prerelease: false
-  version_requirements: *id004
+  version_requirements: *11244320
 description: 
 email: martinkozak@martinkozak.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE.txt
 - README.md
-files: 
+files:
 - .document
 - Gemfile
 - Gemfile.lock
@@ -77,36 +73,38 @@ files:
 - lib/object-proxy.rb
 - object-proxy.gemspec
 - test
-has_rdoc: true
 homepage: http://github.com/martinkozak/object-proxy
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -571804892751824176
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -3593374203948999823
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Provides proxy objects intended for intercepting calls to instance methods. Works as intermediate layer between caller and called. Allows to invoke an handler both before method call and adjust its arguments and after call and post-proccess result. Aimed as tool for instant adapting the complex objects without complete deriving and extending whole classes in cases, where isn't possible to derive them as homogenic functional units or where it's simply impractical to derive them.
+summary: Provides collection of four proxy objects intended for intercepting calls
+  to instance methods. Works as intermediate layer between caller and called. Allows
+  to invoke an handler both before method call and adjust its arguments and after
+  call and post-proccess result. Aimed as tool for instant adapting the complex objects
+  without complete deriving and extending whole classes in cases, where isn't possible
+  to derive them as homogenic functional units or where it's simply impractical to
+  derive them.
 test_files: []
-