chubas-peeping 1.0.0 → 1.1.0

data/README.markdown

@@ -59,16 +59,17 @@ produces output:
 
 ## Tests
 
-The library comes with its rspec test suite, located in folder _tests_ 
+The library comes with its rspec test suite, located in folder _spec_
 
 ## Updates
 
+15 Jul 09 - Finished hook behavior specification. Version 1.1.0 released
+
 ## TODO
 
-- Add option to eval in the context of the caller with instance_exec
-- Selective remove for existing hooks
-- Add option to either replace or wrap singleton method hooks when instance method hooks are already defined
-- Accept options for wrapping, replacing or adding hooks at custom positions in the bubble chain
-- Gem packaging
+( Several previously marked TODO's are not anymore. Peeping it's not aimed at being a full framework )
+
+- Refactor classes (lot of ugly things there)
+- Add option to override ot keep instance hooks when defining singleton hooks
 
   [1]: http://rdoc.info/projects/chubas/peeping

data/VERSION

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

data/lib/peeping/exceptions.rb

@@ -3,4 +3,5 @@ module Peeping
   class UndefinedMethodException    < Exception; end
   class NotAClassException          < Exception; end
   class AlreadyDefinedHookException < Exception; end
+  class UndefinedHookException      < Exception; end
 end

data/lib/peeping/hooks/class_hooks.rb

@@ -0,0 +1,150 @@
+require 'peeping/hooks/hooking'
+
+module Peeping
+  module ClassMethodHooks
+
+    #--
+    # Extend class and instance methods to the base class
+    #++
+    def self.included(base) #:nodoc:
+      base.extend Peeping::ClassMethodHooks::ClassMethods
+      base.class_eval do
+        include Peeping::ClassMethodHooks::InstanceMethods
+      end
+    end
+  
+    module ClassMethods
+
+      include Hooking
+      
+      # Holds the hooks declared for class methods
+      CLASS_METHOD_HOOKS      = {}
+
+      # Returns true if hooks given for class methods of the class +klass+ exist
+      def is_class_hooked?(klass)
+        CLASS_METHOD_HOOKS.has_key?(klass) and not CLASS_METHOD_HOOKS[klass].empty?
+      end
+
+      # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
+      def hooked_class_methods_for(klass)
+        CLASS_METHOD_HOOKS[klass] || {}
+      end
+
+      # Adds +hooks+ hooks to the given +klass+ class methods +hooked_methods+
+      # This parameter can be either a symbol or an array of symbols.
+      #
+      # Possible thrown exceptions:
+      # NotAClassException::          When the specified parameter +klass+ is not a class
+      # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is effectively not a defined class method
+      # AlreadyDefinedHookException:: When a hook for this class and specified method exists
+      # InvalidHooksException::       When hooks contains keys other than :before and :after calls
+      def hook_class!(klass, hooked_methods, hooks)
+
+        hooked_methods = [hooked_methods] if hooked_methods.is_a? Symbol
+
+        validate_hooks(hooks)     # Validate hooks
+        validate_is_class(klass)  # Validate class
+
+        hooked_methods.each do |hooked_method|    # Validate methods defined
+          validate_has_method_defined(klass.metaclass, hooked_method)
+        end
+
+        hooked_methods.each do |hooked_method|
+          CLASS_METHOD_HOOKS[klass] ||= {}
+          new_hooked_method_name = "#{CLASS_HOOK_METHOD_PREFIX}#{hooked_method}"
+
+          if CLASS_METHOD_HOOKS[klass].has_key?(hooked_method)
+            raise AlreadyDefinedHookException.new("Hook signature present for #{hooked_method} in #{klass.metaclass}")
+          end
+          if klass.metaclass.method_defined?(new_hooked_method_name)
+            raise AlreadyDefinedHookException.new("Method #{new_hooked_method_name} hook already defined for #{hooked_method} in #{klass.metaclass}")
+          end
+
+          CLASS_METHOD_HOOKS[klass][hooked_method] = {}
+
+          hooks.each do |where, callback|
+            CLASS_METHOD_HOOKS[klass][hooked_method][where] = callback
+          end
+
+          hook_key = klass.name
+          before_hook_call = <<-BEFORE_HOOK_CALL
+            before_hook_callback = Peeping::Peep.hooked_class_methods_for(#{hook_key})[:"#{hooked_method}"][:before]
+            before_hook_callback.call(self, *args) if before_hook_callback
+          BEFORE_HOOK_CALL
+
+          after_hook_call = <<-AFTER_HOOK_CALL
+            after_hook_callback = Peeping::Peep.hooked_class_methods_for(#{hook_key})[:"#{hooked_method}"][:after]
+            after_hook_callback.call(self, proxied_result) if after_hook_callback
+          AFTER_HOOK_CALL
+
+          class_eval_call = Proc.new do
+            eval <<-REDEF
+              alias :"#{new_hooked_method_name}" :"#{hooked_method}"
+              def #{hooked_method}(*args, &block)
+                #{before_hook_call}
+                proxied_result = if block_given?
+                  __send__("#{new_hooked_method_name}", *args, &block)
+                else
+                  __send__("#{new_hooked_method_name}", *args)
+                end
+                #{after_hook_call}
+                proxied_result
+              end
+            REDEF
+          end
+          klass.metaclass.class_eval(&class_eval_call)
+        end
+      end
+
+      # Removes hook class methods as well as returns the hooked methods to their original definition
+      def unhook_class!(klass, methods = :all, hooks = :all)
+        methods = (methods == :all) ? CLASS_METHOD_HOOKS[klass].keys : (methods.is_a?(Symbol) ? [methods] : methods)
+        raise ArgumentError("Valid arguments: :before, :after or :all") unless [:before, :after, :all].include?(hooks)
+
+        # Validate all methods exist before doing anything 
+        methods.each do |method|
+          raise UndefinedHookException.new("No hook defined for class method #{method})") unless CLASS_METHOD_HOOKS[klass][method]
+        end
+
+        methods.each do |method|
+          if hooks == :all
+            klass.metaclass.class_eval <<-REDEF_OLD_METHOD
+              alias :"#{method}" :"#{CLASS_HOOK_METHOD_PREFIX}#{method}"
+              undef :"#{CLASS_HOOK_METHOD_PREFIX}#{method}"
+            REDEF_OLD_METHOD
+            CLASS_METHOD_HOOKS[klass].delete(method)
+          else
+            unless CLASS_METHOD_HOOKS[klass][method][hooks]
+              raise UndefinedHookException.new("No hook defined for class method #{method}) at #{hooks.inspect}")
+            end
+            CLASS_METHOD_HOOKS[klass][method].delete(hooks)
+            CLASS_METHOD_HOOKS[klass].delete(method) if CLASS_METHOD_HOOKS[klass][method].empty?
+          end
+        end
+
+        CLASS_METHOD_HOOKS.delete(klass) if methods == :all or (CLASS_METHOD_HOOKS[klass] || {}).empty?
+
+      end
+
+      def clear_all_class_hooks!
+        CLASS_METHOD_HOOKS.each do |klass, hooked_methods|
+          hooked_methods.each do |hooked_method, callbacks|
+            redefined_method = "#{CLASS_HOOK_METHOD_PREFIX}#{hooked_method}"
+            klass.metaclass.class_eval <<-UNDEF_EVAL
+              if method_defined?(:"#{redefined_method}")
+                alias :"#{hooked_method}" :"#{redefined_method}"
+                undef :"#{redefined_method}"
+              end
+            UNDEF_EVAL
+          end
+        end
+        CLASS_METHOD_HOOKS.clear
+      end
+
+    end
+
+    module InstanceMethods
+    end
+
+  end
+end

data/lib/peeping/hooks/hooking.rb

@@ -0,0 +1,42 @@
+require 'peeping/exceptions'
+
+module Peeping
+  module Hooking
+
+    HOOKED_METHOD_PREFIX = '__peeping__hooked'
+
+    # Prefix for hooked class methods
+    CLASS_HOOK_METHOD_PREFIX      = "#{HOOKED_METHOD_PREFIX}__class__method__"
+
+    # Prefix for hooked class methods
+    INSTANCE_HOOK_METHOD_PREFIX   = "#{HOOKED_METHOD_PREFIX}__instance__method__"
+
+    # Prefix for hooked class methods
+    SINGLETON_HOOK_METHOD_PREFIX  = "#{HOOKED_METHOD_PREFIX}__singleton__method__"
+
+    private
+
+    # Validates that the array consists only in the keys :before or/and :after
+    #--
+    # TODO: Add extensibility for possible keys. Ideas: warn_on_override, :dont_override, :execute_in_place
+    #++
+    def validate_hooks(hooks)
+      raise InvalidHooksException.new("At least an :after or a :before hook are expected") if hooks.empty?
+      unknown_keys = hooks.keys - [:before, :after]
+      raise InvalidHooksException.new("Unknown keys #{unknown_keys.join(', ')}") unless unknown_keys.empty?
+    end
+
+    # Validates that the passed object is a class
+    def validate_is_class(klass)
+      raise NotAClassException.new("#{klass} is not a Class") unless klass.is_a? Class
+    end
+
+    # Validates that the the method that will be hooked for the given object is defined.
+    def validate_has_method_defined(holding_class, method)
+      unless holding_class.method_defined?(method)
+        raise UndefinedMethodException.new("Undefined method #{method.inspect} for #{holding_class}")
+      end
+    end
+
+  end
+end

data/lib/peeping/hooks/instance_hooks.rb

@@ -0,0 +1,145 @@
+require 'peeping/hooks/hooking'
+
+module Peeping
+  module InstanceMethodHooks
+
+    def self.included(base)
+      base.extend Peeping::InstanceMethodHooks::ClassMethods
+      base.class_eval do
+        include Peeping::InstanceMethodHooks::InstanceMethods
+      end
+    end
+
+    module ClassMethods
+
+      include Hooking
+
+      # Holds the hooks defined for instance methods
+      INSTANCE_METHOD_HOOKS   = {}   
+
+      # Returns true if hooks given for instance methods of the class +klass+ exist
+      def are_instances_hooked?(klass)
+        INSTANCE_METHOD_HOOKS.has_key?(klass)
+      end
+
+      # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
+      def hooked_instance_methods_for(klass)
+        INSTANCE_METHOD_HOOKS[klass] || {}
+      end
+
+      # Adds +hooks+ hooks to the given +klass+ instance methods +hooked_methods+
+      # This parameter can be either a symbol or an array of symbols.
+      #
+      # Possible thrown exceptions:
+      # NotAClassException::          When the specified parameter +klass+ is not a class
+      # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is effectively not a defined instance method
+      # AlreadyDefinedHookException:: When a hook for this class and specified instance method exists
+      # InvalidHooksException::       When hooks contains keys other than :before and :after calls
+      def hook_instances!(klass, hooked_methods, hooks)
+        hooked_methods = [hooked_methods] if hooked_methods.is_a? Symbol
+
+        #=== Validations ===
+        validate_hooks(hooks)
+        validate_is_class(klass)
+        hooked_methods.each { |hooked_method| validate_has_method_defined(klass, hooked_method) }
+
+        hooked_methods.each do |hooked_method|
+          INSTANCE_METHOD_HOOKS[klass] ||= {}
+          hooked_method_name = "#{INSTANCE_HOOK_METHOD_PREFIX}#{hooked_method}"
+
+          if INSTANCE_METHOD_HOOKS[klass].has_key?(hooked_method)
+            raise AlreadyDefinedHookException.new("Hook signature present for #{hooked_method} in #{klass}")
+          end
+          if klass.method_defined?(hooked_method_name)
+            raise AlreadyDefinedHookException.new("Method #{hooked_method_name} hook already defined for #{hooked_method} in #{klass}")
+          end
+
+          INSTANCE_METHOD_HOOKS[klass][hooked_method] = {}
+
+          hooks.each do |where, callback|
+            INSTANCE_METHOD_HOOKS[klass][hooked_method][where] = callback
+          end
+
+          hook_key = klass.name
+          before_hook_call = <<-BEFORE_HOOK_CALL
+            before_hook_callback = Peeping::Peep.hooked_instance_methods_for(#{hook_key})[:"#{hooked_method}"][:before]
+            before_hook_callback.call(self, *args) if before_hook_callback
+          BEFORE_HOOK_CALL
+
+          after_hook_call = <<-AFTER_HOOK_CALL
+            after_hook_callback = Peeping::Peep.hooked_instance_methods_for(#{hook_key})[:"#{hooked_method}"][:after]
+            after_hook_callback.call(self, proxied_result) if after_hook_callback
+          AFTER_HOOK_CALL
+
+          class_eval_call = Proc.new do
+            eval <<-REDEF
+              alias :"#{hooked_method_name}" :"#{hooked_method}"
+              def #{hooked_method}(*args, &block)
+                #{before_hook_call}
+                proxied_result = if block_given?
+                  __send__("#{hooked_method_name}", *args, &block)
+                else
+                  __send__("#{hooked_method_name}", *args)
+                end
+                #{after_hook_call}
+                proxied_result
+              end
+            REDEF
+          end
+          klass.class_eval(&class_eval_call)
+        end
+        
+      end
+
+      # Removes hook instance methods as well as returns the hooked methods to their original definition
+      def unhook_instances!(klass, methods = :all, hooks = :all)
+        methods = (methods == :all) ? INSTANCE_METHOD_HOOKS[klass].keys : (methods.is_a?(Symbol) ? [methods] : methods)
+        raise ArgumentError("Valid arguments: :before, :after or :all") unless [:before, :after, :all].include?(hooks)
+
+        # Validate all methods exist before doing anything
+        methods.each do |method|
+          raise UndefinedHookException.new("No hook defined for instance method #{method})") unless INSTANCE_METHOD_HOOKS[klass][method]
+        end
+
+        methods.each do |method|
+          if hooks == :all
+            klass.class_eval <<-REDEF_OLD_METHOD
+              alias :"#{method}" :"#{INSTANCE_HOOK_METHOD_PREFIX}#{method}"
+              undef :"#{INSTANCE_HOOK_METHOD_PREFIX}#{method}"
+            REDEF_OLD_METHOD
+            INSTANCE_METHOD_HOOKS[klass].delete(method)
+          else
+            unless INSTANCE_METHOD_HOOKS[klass][method][hooks]
+              raise UndefinedHookException.new("No hook defined for instance method #{method}) at #{hooks.inspect}")
+            end
+            INSTANCE_METHOD_HOOKS[klass][method].delete(hooks)
+            INSTANCE_METHOD_HOOKS[klass].delete(method) if INSTANCE_METHOD_HOOKS[klass][method].empty?
+          end
+        end
+
+        INSTANCE_METHOD_HOOKS.delete(klass) if methods == :all or (INSTANCE_METHOD_HOOKS[klass] || {}).empty?
+
+      end
+
+      def clear_all_instance_hooks!
+        INSTANCE_METHOD_HOOKS.each do |klass, hooked_methods|
+          hooked_methods.each do |hooked_method, callbacks|
+            redefined_method = "#{INSTANCE_HOOK_METHOD_PREFIX}#{hooked_method}"
+            klass.class_eval <<-UNDEF_EVAL
+              if method_defined?(:"#{redefined_method}")
+                alias :"#{hooked_method}" :"#{redefined_method}"
+                undef :"#{redefined_method}"
+              end
+            UNDEF_EVAL
+          end
+        end
+        INSTANCE_METHOD_HOOKS.clear
+      end
+
+    end
+
+    module InstanceMethods
+    end
+
+  end
+end

data/lib/peeping/hooks/singleton_hooks.rb

@@ -0,0 +1,165 @@
+require 'peeping/hooks/hooking'
+
+module Peeping
+  module SingletonMethodHooks
+
+    #--
+    # Extend class and instance methods to the base class
+    #++
+    def self.included(base) #:nodoc:
+      base.extend Peeping::SingletonMethodHooks::ClassMethods
+      base.class_eval do
+        include Peeping::SingletonMethodHooks::InstanceMethods
+      end
+    end
+
+    module ClassMethods
+
+      include Hooking
+
+      # Holds the hooks defined for instance methods
+      SINGLETON_METHOD_HOOKS   = {}  
+
+      # Returns true if hooks given for singleton methods of the class +klass+ exist
+      def is_hooked?(object)
+        SINGLETON_METHOD_HOOKS.has_key?(object)
+      end
+
+      # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
+      def hooked_singleton_methods_for(object)
+        SINGLETON_METHOD_HOOKS[object] || {}
+      end
+
+      # Adds +hooks+ hooks to the given +object+ singleton methods +hooked_methods+
+      # This parameter can be either a symbol or an array of symbols.
+      #
+      # Possible thrown exceptions:
+      # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is not a defined method for object +object+
+      # AlreadyDefinedHookException:: When a hook for this object and specified instance method exists.
+      #                               Note that this error *will not* be raised if an instance method hook exists for this
+      #                               method in the object's class. It will override it.
+      # InvalidHooksException::       When hooks contains keys other than :before and :after calls
+      def hook_object!(object, hooked_methods, hooks)
+        hooked_methods = [hooked_methods] if hooked_methods.is_a? Symbol
+
+        validate_hooks(hooks)                     # Validate hooks
+
+        hooked_methods.each do |hooked_method|    # Validate methods defined
+          validate_has_method_defined(object.metaclass, hooked_method)
+        end
+
+        hooked_methods.each do |hooked_method|
+          SINGLETON_METHOD_HOOKS[object] ||= {}
+          hooked_method_name = "#{SINGLETON_HOOK_METHOD_PREFIX}#{hooked_method}"
+
+          if SINGLETON_METHOD_HOOKS[object].has_key?(hooked_method)
+            raise AlreadyDefinedHookException.new("Hook signature present for #{hooked_method} in #{object.metaclass}")
+          end
+          if object.metaclass.method_defined?(hooked_method_name)
+            raise AlreadyDefinedHookException.new("Method #{hooked_method_name} hook already defined for #{hooked_method} in #{where_to_eval}")
+          end
+
+          SINGLETON_METHOD_HOOKS[object][hooked_method] = {}
+
+          hooks.each do |where, callback|
+            SINGLETON_METHOD_HOOKS[object][hooked_method][where] = callback
+          end
+
+          hook_key = 'self'
+          before_hook_call = <<-BEFORE_HOOK_CALL
+
+            before_hook_callback = ((Peeping::Peep.hooked_singleton_methods_for(#{hook_key})||{})[:"#{hooked_method}"] || {})[:before]
+            instance_before_hook_callback = ((Peeping::Peep.hooked_instance_methods_for(self.class) || {})[:"#{hooked_method}"] || {})[:before]
+
+            before_hook_callback ||= instance_before_hook_callback                      
+            before_hook_callback.call(self, *args) if before_hook_callback
+          BEFORE_HOOK_CALL
+
+          after_hook_call = <<-AFTER_HOOK_CALL
+            after_hook_callback = ((Peeping::Peep.hooked_singleton_methods_for(#{hook_key})||{})[:"#{hooked_method}"] || {})[:after]
+            instance_after_hook_callback = ((Peeping::Peep.hooked_instance_methods_for(self.class) || {})[:"#{hooked_method}"] || {})[:after]
+
+            after_hook_callback ||= instance_after_hook_callback  
+            after_hook_callback.call(self, proxied_result) if after_hook_callback
+          AFTER_HOOK_CALL
+
+          should_override_instance_call = true # TODO: Optionalize
+          class_eval_call = Proc.new do
+            eval <<-REDEF
+              if #{should_override_instance_call} and method_defined?(:"#{INSTANCE_HOOK_METHOD_PREFIX}#{hooked_method}")
+                alias :"#{hooked_method_name}" :"#{INSTANCE_HOOK_METHOD_PREFIX}#{hooked_method}"
+              else
+                alias :"#{hooked_method_name}" :"#{hooked_method}"
+              end
+              def #{hooked_method}(*args, &block)
+                #{before_hook_call}
+                proxied_result = if block_given?
+                  __send__("#{hooked_method_name}", *args, &block)
+                else
+                  __send__("#{hooked_method_name}", *args)
+                end
+                #{after_hook_call}
+                proxied_result
+              end
+            REDEF
+          end
+          object.metaclass.class_eval(&class_eval_call)
+        end
+      end
+
+      # Removes hook singleton methods as well as returns the hooked methods to their original definition
+      def unhook_object!(object, methods = :all, hooks = :all)
+        methods = (methods == :all) ? SINGLETON_METHOD_HOOKS[object].keys : (methods.is_a?(Symbol) ? [methods] : methods)
+        raise ArgumentError("Valid arguments: :before, :after or :all") unless [:before, :after, :all].include?(hooks)
+
+        # Validate all methods exist before doing anything
+        methods.each do |method|
+          raise UndefinedHookException.new("No hook defined for class method #{method})") unless SINGLETON_METHOD_HOOKS[object][method]
+        end
+
+        methods.each do |method|
+          if hooks == :all
+            object.metaclass.class_eval <<-REDEF_OLD_METHOD
+              alias :"#{method}" :"#{SINGLETON_HOOK_METHOD_PREFIX}#{method}"
+              undef :"#{SINGLETON_HOOK_METHOD_PREFIX}#{method}"
+            REDEF_OLD_METHOD
+            SINGLETON_METHOD_HOOKS[object].delete(method)
+          else
+            unless SINGLETON_METHOD_HOOKS[object][method][hooks]
+              raise UndefinedHookException.new("No hook defined for singleton method #{method}) at #{hooks.inspect}")
+            end
+            SINGLETON_METHOD_HOOKS[object][method].delete(hooks)
+            SINGLETON_METHOD_HOOKS[object].delete(method) if SINGLETON_METHOD_HOOKS[object][method].empty?
+          end
+        end
+
+        SINGLETON_METHOD_HOOKS.delete(object) if methods == :all or (SINGLETON_METHOD_HOOKS[object] || {}).empty?
+      end
+
+      def clear_all_singleton_hooks!
+        SINGLETON_METHOD_HOOKS.each do |object, hooked_methods|
+          hooked_methods.each do |hooked_method, callbacks|
+            redefined_singleton_method  = "#{SINGLETON_HOOK_METHOD_PREFIX}#{hooked_method}"
+            redefined_instance_method   = "#{INSTANCE_HOOK_METHOD_PREFIX}#{hooked_method}"
+            object.metaclass.class_eval <<-UNDEF_EVAL
+              if method_defined?(:"#{redefined_singleton_method}")
+                if method_defined?(:"#{redefined_instance_method}")
+                  alias :"#{hooked_method}" :"#{redefined_instance_method}"
+                else
+                  alias :"#{hooked_method}" :"#{redefined_singleton_method}"
+                end
+                undef :"#{redefined_singleton_method}"
+              end
+            UNDEF_EVAL
+          end
+        end
+        SINGLETON_METHOD_HOOKS.clear
+      end
+
+    end
+
+    module InstanceMethods
+    end
+
+  end
+end

data/lib/peeping/peeping.rb

@@ -9,6 +9,10 @@ require 'peeping/util'
 require 'peeping/hook'
 require 'peeping/exceptions'
 
+require 'peeping/hooks/class_hooks'
+require 'peeping/hooks/instance_hooks'
+require 'peeping/hooks/singleton_hooks'
+
 # Wraps classes and modules for the +peeping+ library
 module Peeping
 
@@ -16,299 +20,22 @@ module Peeping
   # hold the hook definitions
   class Peep
 
-    #--
-    ## ========== Holder variables section ==========
-    #++
-
-    # Holds the hooks declared for class methods
-    CLASS_METHOD_HOOKS      = {}
-
-    # Holds the hooks defined for instance methods
-    INSTANCE_METHOD_HOOKS   = {}
-
-    # Holds the hooks defined for singleton methods
-    SINGLETON_METHOD_HOOKS  = {}
-
-    #--
-    ## ===================================================
-    ## =============== Class hooks section ===============
-    ## ===================================================
-    #++
-
-    # Returns true if hooks given for class methods of the class +klass+ exist
-    def self.is_class_hooked?(klass)
-      CLASS_METHOD_HOOKS.has_key?(klass)
-    end
-
-    # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
-    def self.hooked_class_methods_for(klass)
-      CLASS_METHOD_HOOKS[klass] || {}
-    end
-
-    # Adds +hooks+ hooks to the given +klass+ class methods +hooked_methods+
-    # This parameter can be either a symbol or an array of symbols.
-    #
-    # Possible thrown exceptions:
-    # NotAClassException::          When the specified parameter +klass+ is not a class
-    # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is effectively not a defined class method
-    # AlreadyDefinedHookException:: When a hook for this class and specified method exists
-    # InvalidHooksException::       When hooks contains keys other than :before and :after calls
-    def self.hook_class!(klass, hooked_methods, hooks)
-      define_method_hooks!(klass, hooked_methods, hooks, :class, CLASS_METHOD_HOOKS)
-    end
-
-    # Removes hook class methods as well as returns the hooked methods to their original definition
-    def self.unhook_class!(klass)
-      klass.metaclass.class_eval do
-        instance_methods.grep(/^__proxied_class_method_/).each do |proxied_method|
-          proxied_method =~ (/^__proxied_class_method_(.*)$/)
-          original = $1
-          eval "alias #{original} #{proxied_method}"
-          eval "undef #{proxied_method}"
-        end
-      end
-      CLASS_METHOD_HOOKS.delete(klass)
-    end
+    include ClassMethodHooks
+    include InstanceMethodHooks
+    include SingletonMethodHooks
 
     #--
-    ## ======================================================
-    ## =============== Instance hooks section ===============
-    ## ======================================================
+    #===== GLOBAL FUNCTIONS =====
     #++
 
-    # Returns true if hooks given for instance methods of the class +klass+ exist
-    def self.are_instances_hooked?(klass)
-      INSTANCE_METHOD_HOOKS.has_key?(klass)
-    end
-
-    # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
-    def self.hooked_instance_methods_for(klass)
-      INSTANCE_METHOD_HOOKS[klass] || {}
-    end
-
-    # Adds +hooks+ hooks to the given +klass+ instance methods +hooked_methods+
-    # This parameter can be either a symbol or an array of symbols.
-    #
-    # Possible thrown exceptions:
-    # NotAClassException::          When the specified parameter +klass+ is not a class
-    # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is effectively not a defined instance method
-    # AlreadyDefinedHookException:: When a hook for this class and specified instance method exists
-    # InvalidHooksException::       When hooks contains keys other than :before and :after calls
-    def self.hook_instances!(klass, hooked_methods, hooks)
-      define_method_hooks!(klass, hooked_methods, hooks, :instance, INSTANCE_METHOD_HOOKS)
-    end
-
-    # Removes hook instance methods as well as returns the hooked methods to their original definition
-    def self.unhook_instances!(klass)
-      klass.class_eval do
-        instance_methods.grep(/^__proxied_instance_method_/).each do |proxied_method|
-          proxied_method =~ (/^__proxied_instance_method_(.*)$/)
-          original = $1
-          eval "alias #{original} #{proxied_method}"
-          eval "undef #{proxied_method}"
-        end
-      end
-      INSTANCE_METHOD_HOOKS.delete(klass)
-    end
-
-    #--
-    ## =======================================================
-    ## =============== Singleton hooks section ===============
-    ## =======================================================
-    #++
-
-    # Returns true if hooks given for singleton methods of the class +klass+ exist
-    def self.is_hooked?(object)
-      SINGLETON_METHOD_HOOKS.has_key?(object)
-    end
-
-    # Returns a hash containing all hooked methods for class +klass+ as keys, or an empty hash if don't exist
-    def self.hooked_singleton_methods_for(object)
-      SINGLETON_METHOD_HOOKS[object] || {}
-    end
-
-    # Adds +hooks+ hooks to the given +object+ singleton methods +hooked_methods+
-    # This parameter can be either a symbol or an array of symbols.
-    #
-    # Possible thrown exceptions:
-    # UndefinedMethodException::    When one of the symbols in +hooked_methods+ param is not a defined method for object +object+
-    # AlreadyDefinedHookException:: When a hook for this object and specified instance method exists.
-    #                               Note that this error *will not* be raised if an instance method hook exists for this
-    #                               method in the object's class. It will override it.
-    # InvalidHooksException::       When hooks contains keys other than :before and :after calls
-    def self.hook_object!(object, hooked_methods, hooks)
-      define_method_hooks!(object, hooked_methods, hooks, :singleton, SINGLETON_METHOD_HOOKS)
-    end
-
-    # Removes hook singleton methods as well as returns the hooked methods to their original definition
-    def self.unhook_object!(object)
-      object.metaclass.class_eval do
-        instance_methods.grep(/^__proxied_singleton_method_/).each do |proxied_method|
-          proxied_method =~ (/^__proxied_singleton_method_(.*)$/)
-          original = $1
-          eval "alias #{original} #{proxied_method}"
-          eval "undef #{proxied_method}"
-        end
-      end
-      SINGLETON_METHOD_HOOKS.delete(object)
-    end
-
-    #--
-    ## ========== Protected auxiliar methods section ==========
-    class << self
-      protected
-
-      def define_method_hooks!(what, hooked_methods, hooks, mode, container)
-        hooked_methods = [hooked_methods] if hooked_methods.is_a? Symbol
-
-        validate_hooks(hooks)                     # Validate hooks
-        validate_is_class(what, mode)             # Validate class
-
-        where_to_eval = (mode == :class or mode == :singleton) ? what.metaclass : what
-        hooked_methods.each do |hooked_method|    # Validate methods defined
-          validate_has_method_defined(where_to_eval, hooked_method, mode)
-        end
-
-        hooked_methods.each do |hooked_method|
-          container[what] ||= {}
-          hooked_method_name = "__proxied_#{mode}_method_#{hooked_method}"
-
-          if container[what].has_key?(hooked_method)
-            raise AlreadyDefinedHookException.new("Hook signature present for #{hooked_method} in #{where_to_eval}")
-          end
-          if what.respond_to?(hooked_method_name)
-            raise AlreadyDefinedHookException.new("Method #{hooked_method_name} hook already defined for #{hooked_method} in #{where_to_eval}")
-          end
-
-          container[what][hooked_method] = {}
-
-          hooks.each do |where, callback|
-            container[what][hooked_method][where] = callback
-          end
-
-          hook_key = (mode == :class or mode == :instance) ? what.name : 'self'
-          before_hook_call = if hooks.include?(:before)
-            "Peeping::Peep.hooked_#{mode}_methods_for(#{hook_key})[:\"#{hooked_method}\"][:before].call(self, *args)"
-          end
-          after_hook_call = if hooks.include?(:after)
-            "Peeping::Peep.hooked_#{mode}_methods_for(#{hook_key})[:\"#{hooked_method}\"][:after].call(self, proxied_result)"
-          end
-          should_override_instance_call = (mode == :singleton).to_s
-          class_eval_call = Proc.new do
-            eval <<-REDEF
-              if #{should_override_instance_call} and method_defined?(:"__proxied_instance_method_#{hooked_method}")
-                alias :"#{hooked_method_name}" :"__proxied_instance_method_#{hooked_method}"
-              else
-                alias :"#{hooked_method_name}" :"#{hooked_method}"
-              end
-              def #{hooked_method}(*args, &block)
-                #{before_hook_call}
-                proxied_result = if block_given?
-                  __send__("#{hooked_method_name}", *args, &block)
-                else
-                  __send__("#{hooked_method_name}", *args)
-                end
-                #{after_hook_call}
-                proxied_result
-              end
-            REDEF
-          end
-          where_to_eval.class_eval(&class_eval_call)
-        end
-      end
-
-      # Validates that the array consists only in the keys :before or/and :after
-      #--
-      # TODO: Add extensibility for possible keys. Ideas: warn_on_override, :dont_override, :execute_in_place
-      #++
-      def validate_hooks(hooks)
-        raise InvalidHooksException.new("At least an :after or a :before hook are expected") if hooks.empty?
-        unknown_keys = hooks.keys - [:before, :after]
-        raise InvalidHooksException.new("Unknown keys #{unknown_keys.join(', ')}") unless unknown_keys.empty?
-      end
-
-      # Validates that the passed object is a class in :class and :instance modes
-      def validate_is_class(what, mode)
-        if mode == :class or mode == :instance
-          raise NotAClassException.new("#{what} is not a Class") unless what.is_a? Class
-        end
-      end
-
-      # Validates that the the method that will be hooked for the given object is defined.
-      def validate_has_method_defined(holding_class, method, mode)
-        unless holding_class.method_defined?(method)
-          raise UndefinedMethodException.new("Undefined #{mode} method #{method.inspect} for #{holding_class}")
-        end
-      end
-    end
-    #++
-
-  end
-
-  ## ========== Auxiliar methods ==========
-
-  class Peep
     # Completely removes all hooks for all defined classes and objects
     def self.clear_all_hooks!
-      clear_all_class_hooks!
       clear_all_singleton_hooks!
       clear_all_instance_hooks!
+      clear_all_class_hooks!
     end
 
-    #--
-    class << self
-      protected
-
-      # TODO: Refactor lots of this
-
-      def clear_all_class_hooks!
-        Peep::CLASS_METHOD_HOOKS.each do |klass, hooked_methods|
-          hooked_methods.each do |hooked_method, callbacks|
-            klass.metaclass.class_eval <<-UNDEF_EVAL
-              if method_defined?(:"__proxied_class_method_#{hooked_method}")
-                alias :"#{hooked_method}" :"__proxied_class_method_#{hooked_method}"
-                undef :"__proxied_class_method_#{hooked_method}"
-              end
-            UNDEF_EVAL
-          end
-        end
-        Peep::CLASS_METHOD_HOOKS.clear
-      end
-
-      def clear_all_instance_hooks!
-        Peep::INSTANCE_METHOD_HOOKS.each do |klass, hooked_methods|
-          hooked_methods.each do |hooked_method, callbacks|
-            klass.class_eval <<-UNDEF_EVAL
-              if method_defined?(:"__proxied_instance_method_#{hooked_method}")
-                alias :"#{hooked_method}" :"__proxied_instance_method_#{hooked_method}"
-                undef :"__proxied_instance_method_#{hooked_method}"
-              end
-            UNDEF_EVAL
-          end
-        end
-        Peep::INSTANCE_METHOD_HOOKS.clear
-      end
-
-      def clear_all_singleton_hooks!
-        Peep::SINGLETON_METHOD_HOOKS.each do |object, hooked_methods|
-          hooked_methods.each do |hooked_method, callbacks|
-            object.metaclass.class_eval <<-UNDEF_EVAL
-              if method_defined?(:"__proxied_singleton_method_#{hooked_method}")
-                if method_defined?(:"__proxied_instance_method_#{hooked_method}")
-                  alias :"#{hooked_method}" :"__proxied_instance_method_#{hooked_method}"
-                else
-                  alias :"#{hooked_method}" :"__proxied_singleton_method_#{hooked_method}"
-                end
-                undef :"__proxied_singleton_method_#{hooked_method}"
-              end
-            UNDEF_EVAL
-          end
-        end
-        Peep::SINGLETON_METHOD_HOOKS.clear
-      end
-    end
-    #++
+  end
 
-  end    
 end
 

data/lib/peeping.rb

@@ -1,5 +1,4 @@
 libdir = File.dirname(__FILE__)
 $:.unshift(libdir) unless $:.include?(libdir)
 
-require 'peeping/peeping'
-
+require 'peeping/peeping'

data/peeping.gemspec

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{peeping}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ruben Medellin"]
+  s.date = %q{2009-07-15}
+  s.description = %q{      Add, remove and manage hooks for class, instance and singleton method calls.
+      Intended to be not a full Aspect Oriented Programming framework, but a lightweight
+      simpler one.
+}
+  s.email = %q{ruben.medellin.c@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/peeping.rb",
+     "lib/peeping/exceptions.rb",
+     "lib/peeping/hooks/class_hooks.rb",
+     "lib/peeping/hooks/hooking.rb",
+     "lib/peeping/hooks/instance_hooks.rb",
+     "lib/peeping/hooks/singleton_hooks.rb",
+     "lib/peeping/peeping.rb",
+     "lib/peeping/util.rb",
+     "peeping.gemspec",
+     "spec/helpers/test_helpers.rb",
+     "spec/hook_methods_spec.rb",
+     "spec/hooked_behavior_spec.rb",
+     "spec/selective_hook_management_spec.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/chubas/peeping}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.requirements = ["none"]
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Lightweight AOP framework for managing method hooks}
+  s.test_files = [
+    "spec/hooked_behavior_spec.rb",
+     "spec/hook_methods_spec.rb",
+     "spec/selective_hook_management_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/hooked_behavior_spec.rb

@@ -79,16 +79,17 @@ describe Peep, "when calling hook methods" do
 
   it "should always override instance method calls with singleton method calls" do
     scooby = Dog.new('scooby')
+    lassie = Dog.new('lassie')
+    
     Peep.hook_object!(
             scooby,
             :lick_owner,
-            :before => Proc.new{|object, *args| object.owner = "Shaggy" },
-            :after  => Proc.new{|object, result| result.should == "Shaggy is now all wet!" } )
-    lassie = Dog.new('lassie')
+            :before => Proc.new{|object, *args|   object.owner = "Shaggy" },
+            :after  => Proc.new{|object, result|  result.should == "Shaggy is now all wet!" } )
     Peep.hook_instances!(
             Dog,
             :lick_owner,
-            :after => Proc.new{|objetc, result| result.should == "I have no owner to lick :(" } )
+            :after  => Proc.new{|objetc, result| result.should == "I have no owner to lick :(" } )
     scooby.lick_owner
     lassie.lick_owner
   end

data/spec/selective_hook_management_spec.rb

@@ -0,0 +1,190 @@
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'peeping')
+require File.join(File.dirname(__FILE__), 'helpers', 'test_helpers')
+
+include Peeping
+
+describe Peep, "when adding and removing hooks" do
+
+  it_should_behave_like "a clean test"
+
+  it "should allow to remove class hook methods by method and location" do
+    before  = Proc.new{}
+    after   = Proc.new{}
+
+    Peep.hook_class!(Dog, [:train, :eats?], :before => before, :after => after)
+
+    hooked_class_methods = Peep.hooked_class_methods_for(Dog)
+    hooked_class_methods.should have(2).keys
+    hooked_class_methods.should include(:train)
+    hooked_class_methods.should include(:eats?)
+
+    hooked_class_methods[:train].should have(2).keys
+    hooked_class_methods[:train].should include(:before)
+    hooked_class_methods[:train].should include(:after)
+
+    Peep.unhook_class!(Dog, :train, :before)
+
+    hooked_class_methods = Peep.hooked_class_methods_for(Dog)
+    hooked_class_methods.should have(2).keys
+    hooked_class_methods.keys.should include(:train)
+    hooked_class_methods.keys.should include(:eats?)
+
+    hooked_class_methods[:train].should have(1).keys
+    hooked_class_methods[:train].should_not include(:before)
+    hooked_class_methods[:train].should include(:after)
+
+    Proc.new{ Peep.unhook_class! Dog, :no_such_hook   }.should raise_error UndefinedHookException
+    Proc.new{ Peep.unhook_class! Dog, :train, :before }.should raise_error UndefinedHookException
+
+    Peep.unhook_class!(Dog, :train, :after)
+
+    hooked_class_methods = Peep.hooked_class_methods_for(Dog)
+    hooked_class_methods.should have(1).keys
+    hooked_class_methods.keys.should_not include(:train)
+    hooked_class_methods.keys.should include(:eats?)
+
+    Peep.unhook_class!(Dog)
+
+    hooked_class_methods.should have(0).keys
+    Peep.is_class_hooked?(Dog).should == false
+  end
+
+
+  it "should allow to remove instance hook methods by method and location" do
+    before  = Proc.new{}
+    after   = Proc.new{}
+
+    Peep.hook_instances!(Dog, [:bark, :lick_owner], :before => before, :after => after)
+
+    hooked_instance_methods = Peep.hooked_instance_methods_for(Dog)
+    hooked_instance_methods.should have(2).keys
+    hooked_instance_methods.should include(:bark)
+    hooked_instance_methods.should include(:lick_owner)
+
+    hooked_instance_methods[:bark].should have(2).keys
+    hooked_instance_methods[:bark].should include(:before)
+    hooked_instance_methods[:bark].should include(:after)
+
+    Peep.unhook_instances!(Dog, :bark, :before)
+
+    hooked_instance_methods = Peep.hooked_instance_methods_for(Dog)
+    hooked_instance_methods.should have(2).keys
+    hooked_instance_methods.keys.should include(:bark)
+    hooked_instance_methods.keys.should include(:lick_owner)
+
+    hooked_instance_methods[:bark].should have(1).keys
+    hooked_instance_methods[:bark].should_not include(:before)
+    hooked_instance_methods[:bark].should include(:after)
+
+    Proc.new{ Peep.unhook_instances! Dog, :no_such_hook   }.should raise_error UndefinedHookException
+    Proc.new{ Peep.unhook_instances! Dog, :bark, :before  }.should raise_error UndefinedHookException
+
+    Peep.unhook_instances!(Dog, :bark, :after)
+
+    hooked_instance_methods = Peep.hooked_instance_methods_for(Dog)
+    hooked_instance_methods.should have(1).keys
+    hooked_instance_methods.keys.should_not include(:bark)
+    hooked_instance_methods.keys.should include(:lick_owner)
+
+    Peep.unhook_instances!(Dog)
+
+    hooked_instance_methods.should have(0).keys
+  end
+
+  it "should allow to remove singleton hook methods by method and location" do
+    before  = Proc.new{}
+    after   = Proc.new{}
+    scooby  = Dog.new('scooby')
+
+    Peep.hook_object!(scooby, [:bark, :lick_owner], :before => before, :after => after)
+
+    hooked_singleton_methods = Peep.hooked_singleton_methods_for(scooby)
+    hooked_singleton_methods.should have(2).keys
+    hooked_singleton_methods.should include(:bark)
+    hooked_singleton_methods.should include(:lick_owner)
+
+    hooked_singleton_methods[:bark].should have(2).keys
+    hooked_singleton_methods[:bark].should include(:before)
+    hooked_singleton_methods[:bark].should include(:after)
+
+    Peep.unhook_object!(scooby, :bark, :before)
+
+    hooked_singleton_methods = Peep.hooked_singleton_methods_for(scooby)
+    hooked_singleton_methods.should have(2).keys
+    hooked_singleton_methods.keys.should include(:bark)
+    hooked_singleton_methods.keys.should include(:lick_owner)
+
+    hooked_singleton_methods[:bark].should have(1).keys
+    hooked_singleton_methods[:bark].should_not include(:before)
+    hooked_singleton_methods[:bark].should include(:after)
+
+    Proc.new{ Peep.unhook_object! scooby, :no_such_hook   }.should raise_error UndefinedHookException
+    Proc.new{ Peep.unhook_object! scooby, :bark, :before  }.should raise_error UndefinedHookException
+
+    Peep.unhook_object!(scooby, :bark, :after)
+
+    hooked_singleton_methods = Peep.hooked_singleton_methods_for(scooby)
+    hooked_singleton_methods.should have(1).keys
+    hooked_singleton_methods.keys.should_not include(:bark)
+    hooked_singleton_methods.keys.should include(:lick_owner)
+
+    Peep.unhook_object!(scooby)
+
+    hooked_singleton_methods.should have(0).keys
+  end
+
+  it "should keep the instance hook method when removing any singleton hook method" do
+    scooby = Dog.new('scooby')
+    lassie = Dog.new('lassie')
+
+    before_instance_counter = 0
+    after_instance_counter  = 0
+    before_object_counter   = 0
+    after_object_counter    = 0
+
+    counters_should_be = Proc.new do |bic, aic, boc, aoc|
+      before_instance_counter.should  == bic
+      after_instance_counter.should   == aic
+      before_object_counter.should    == boc
+      after_object_counter.should     == aoc
+    end
+
+    Peep.hook_instances!(Dog, :lick_owner,
+                              :before => Proc.new{ before_instance_counter += 1},
+                              :after  => Proc.new{ after_instance_counter  += 1} )
+    Peep.hook_object!(scooby, :lick_owner,
+                              :before => Proc.new{ before_object_counter   += 1},
+                              :after  => Proc.new{ after_object_counter    += 1} )
+
+    scooby.lick_owner
+    counters_should_be[0, 0, 1, 1]
+
+    lassie.lick_owner
+    counters_should_be[1, 1, 1, 1]
+
+    Peep.unhook_object!(scooby, :lick_owner, :before)
+    scooby.lick_owner
+    counters_should_be[2, 1, 1, 2]
+    lassie.lick_owner
+    counters_should_be[3, 2, 1, 2]
+
+    Peep.unhook_instances!(Dog, :lick_owner, :after)
+    scooby.lick_owner
+    counters_should_be[4, 2, 1, 3]
+    lassie.lick_owner
+    counters_should_be[5, 2, 1, 3]
+
+    Peep.unhook_object!(scooby, :lick_owner, :after)
+    scooby.lick_owner
+    counters_should_be[6, 2, 1, 3]
+    lassie.lick_owner
+    counters_should_be[7, 2, 1, 3]
+
+    Peep.unhook_instances!(Dog, :lick_owner)
+    scooby.lick_owner
+    lassie.lick_owner
+    counters_should_be[7, 2, 1, 3]
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chubas-peeping
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Ruben Medellin
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-12 00:00:00 -07:00
+date: 2009-07-15 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,12 +31,17 @@ files:
 - VERSION
 - lib/peeping.rb
 - lib/peeping/exceptions.rb
-- lib/peeping/hook.rb
+- lib/peeping/hooks/class_hooks.rb
+- lib/peeping/hooks/hooking.rb
+- lib/peeping/hooks/instance_hooks.rb
+- lib/peeping/hooks/singleton_hooks.rb
 - lib/peeping/peeping.rb
 - lib/peeping/util.rb
+- peeping.gemspec
 - spec/helpers/test_helpers.rb
 - spec/hook_methods_spec.rb
 - spec/hooked_behavior_spec.rb
+- spec/selective_hook_management_spec.rb
 has_rdoc: true
 homepage: http://github.com/chubas/peeping
 post_install_message: 
@@ -66,3 +71,4 @@ summary: Lightweight AOP framework for managing method hooks
 test_files: 
 - spec/hooked_behavior_spec.rb
 - spec/hook_methods_spec.rb
+- spec/selective_hook_management_spec.rb

data/lib/peeping/hook.rb

@@ -1,8 +0,0 @@
-module Peeping
-
-  # PENDING
-  # This class will serve as a proxy for dynamically managing hooked methods
-  class Hook < Hash
-  end
-  
-end