chubas-peeping 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.idea

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ruben Medellin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,74 @@
+# peeping
+
+Like aspect-oriented, but cooler!
+
+## Motivation
+
+This library intends to provide a simple yet flexible way for defining hook calls for your methods,
+without trying to be a complete aspect-oriented programming framework implementation.
+
+## Installation
+
+Just point to the root directory of the library in your require path and include `peeping.rb` (Gem packaging soon)
+
+## Usage
+
+For defining hooks, use the methods of `Peeping::Peep` class
+
+    include Peeping
+
+    class Foo
+      def some_instance_method
+        puts "Hi there!"
+      end
+      def self.some_class_method
+        puts "Cool!"
+      end
+    end
+
+    foo = Foo.new
+
+    Peep.hook_class!(Foo, :some_class_method,
+            :before => Proc.new{ puts "Before class method" },
+            :after  => Proc.new{ puts "After class method" })
+    Peep.hook_instances!(Foo, :some_instance_method,
+            :before => Proc.new{ puts "Before instance method" },
+            :after  => Proc.new{ puts "After instance method" })
+    Peep.hook_object!(foo, :some_instance_method,
+            :before => Proc.new{ puts "Before singleton instance method" },
+            :after  => Proc.new{ puts "After singleton instance method" })
+
+    Foo.some_class_method
+    Foo.new.some_instance_method
+    foo.some_instance_method
+
+produces output:
+
+     Before class method
+     Cool!
+     After class method
+     Before instance method
+     Hi there!
+     After instance method
+     Before singleton instance method
+     Hi there!
+     After singleton instance method
+
+
+[See documentation online][1] and TODO notes for more info
+
+## Tests
+
+The library comes with its rspec test suite, located in folder _tests_ 
+
+## Updates
+
+## 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
+
+  [1]: http://rdoc.info/projects/chubas/peeping

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    
+    gem.name      = "peeping"
+    gem.email     = "ruben.medellin.c@gmail.com"
+    gem.summary   = %Q{Lightweight AOP framework for managing method hooks}
+    gem.description  = <<-DESCRIPTION
+      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.
+    DESCRIPTION
+
+    gem.homepage  = "http://github.com/chubas/peeping"
+    gem.authors   = ["Ruben Medellin"]
+
+    gem.requirements << 'none'
+    gem.require_path = 'lib'
+
+    gem.has_rdoc     = true
+    gem.test_files   = Dir.glob('spec/*.rb')
+
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+task :default => :test
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))  
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  elsif File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "peeping #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/peeping.rb

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

data/lib/peeping/exceptions.rb

@@ -0,0 +1,6 @@
+module Peeping
+  class InvalidHooksException       < Exception; end
+  class UndefinedMethodException    < Exception; end
+  class NotAClassException          < Exception; end
+  class AlreadyDefinedHookException < Exception; end
+end

data/lib/peeping/hook.rb

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

data/lib/peeping/peeping.rb

@@ -0,0 +1,314 @@
+# Peeping is sort of an aspect-oriented programming module -- just without the fancy name
+# It allows to hook class, instance and singleton methods for adding -and nicely managing-
+# before and after procedures.
+#
+# Author::    Ruben Medellin  (mailto:ruben.medellin.c@gmail.com)
+# License::   Distributes under the same terms as Ruby
+
+require 'peeping/util'
+require 'peeping/hook'
+require 'peeping/exceptions'
+
+# Wraps classes and modules for the +peeping+ library
+module Peeping
+
+  # This class defines the methods for hooking and unhooking methods, as well as contains the variables that
+  # 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
+
+    #--
+    ## ======================================================
+    ## =============== Instance hooks section ===============
+    ## ======================================================
+    #++
+
+    # 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!
+    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
+

data/lib/peeping/util.rb

@@ -0,0 +1,13 @@
+#--
+# Utility methods
+
+class Object
+
+  # In case it has not been defined before 
+  def metaclass
+    class << self
+      self
+    end
+  end unless method_defined?(:metaclass)
+end
+#++

data/spec/helpers/test_helpers.rb

@@ -0,0 +1,42 @@
+require 'spec'
+
+shared_examples_for 'a clean test' do
+  before{ Peeping::Peep.clear_all_hooks! }
+  after { Peeping::Peep.clear_all_hooks! }
+end
+
+#--
+# Dummy class, used for testing
+class Dog
+
+  attr_accessor :name, :trained, :owner
+  attr_accessor :a, :b
+
+  def initialize(name)
+    @name = name
+  end
+
+  def bark(times)
+    (["woof"] * times).join(' ') + "!"
+  end
+
+  def lick_owner
+    if @owner
+      "#{@owner} is now all wet!"
+    else
+      "I have no owner to lick :("
+    end
+  end
+
+  def self.train(dog)
+    dog.trained = true
+    dog
+  end
+
+  def self.eats?(thing)
+    %w{meat bones milk}.include?(thing)
+  end
+
+end
+#++
+

data/spec/hook_methods_spec.rb

@@ -0,0 +1,139 @@
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'peeping')
+require File.join(File.dirname(__FILE__), 'helpers', 'test_helpers')
+
+
+include Peeping
+
+describe Peep, "determining if objects are hooked, and get hooks for class or object" do
+
+  it_should_behave_like "a clean test"
+
+  it "should allow me to determine wether a class is hooked" do
+    include Peeping
+    Peep.should respond_to(:is_class_hooked?)
+    Peep.should respond_to(:hooked_class_methods_for)
+  end
+
+  it "should allow me to determine if all instances of a class are hooked" do
+    Peep.should respond_to(:are_instances_hooked?)
+    Peep.should respond_to(:hooked_instance_methods_for)
+  end
+
+  it "should allow me to determine if a single object is hooked" do
+    Peep.should respond_to(:is_hooked?)
+    Peep.should respond_to(:hooked_singleton_methods_for)
+  end
+
+end
+
+describe Peep, "when hooking and unhooking objects" do
+
+  it_should_behave_like "a clean test"
+
+  it "should allow to me to hook and unhook classes" do
+    Peep.is_class_hooked?(Dog).should == false
+    Peep.hooked_class_methods_for(Dog).should be_empty
+
+    after_call = Proc.new{|klass, result| result}
+    Peep.hook_class!(Dog, :train, :after => after_call)
+
+    Peep.is_class_hooked?(Dog).should == true
+    Peep.hooked_class_methods_for(Dog).should_not be_empty
+    Peep.hooked_class_methods_for(Dog).should have(1).keys
+    Peep.hooked_class_methods_for(Dog)[:train][:after].should == after_call
+
+    Peep.unhook_class!(Dog)
+
+    Peep.is_class_hooked?(Dog).should == false
+    Peep.hooked_class_methods_for(Dog).should be_empty
+  end
+
+  it "should allow me to hook and unhook instance methods" do
+    Peep.are_instances_hooked?(Dog).should == false
+    Peep.hooked_instance_methods_for(Dog).should be_empty
+
+    after_call = Proc.new{|klass, result| result}
+    Peep.hook_instances!(Dog, :bark, :after => after_call)
+
+    Peep.are_instances_hooked?(Dog).should == true
+    Peep.hooked_instance_methods_for(Dog).should_not be_empty
+    Peep.hooked_instance_methods_for(Dog).should have(1).keys
+    Peep.hooked_instance_methods_for(Dog)[:bark][:after].should == after_call
+
+    Peep.unhook_instances!(Dog)
+
+    Peep.are_instances_hooked?(Dog).should == false
+    Peep.hooked_instance_methods_for(Dog).should be_empty
+  end
+
+  it "should allow me to hook and unhook single objects" do
+    scooby = Dog.new("scooby")
+    Peep.is_hooked?(scooby).should == false
+
+    after_call = Proc.new{|klass, result| result}
+    Peep.hook_object!(scooby, :bark, :after => after_call)
+
+    Peep.is_hooked?(scooby).should == true
+    Peep.hooked_singleton_methods_for(scooby).should_not be_empty
+    Peep.hooked_singleton_methods_for(scooby).should have(1).keys
+    Peep.hooked_singleton_methods_for(scooby)[:bark][:after].should == after_call
+
+    Peep.are_instances_hooked?(Dog).should == false
+    Peep.hooked_instance_methods_for(Dog).should be_empty
+
+    Peep.unhook_object!(scooby)
+
+    Peep.is_hooked?(scooby).should == false
+    Peep.hooked_singleton_methods_for(scooby).should be_empty
+  end
+end
+
+describe Peep, "when sending valid and unvalid parameters" do
+
+  it_should_behave_like "a clean test"
+
+  it "should only accept valid parameters for hooks" do
+    scooby        = Dog.new("scooby")
+    invalid_keys  = { :invalid => :key }
+
+    Proc.new{ Peep.hook_class! Dog, :hello, invalid_keys }.should raise_error InvalidHooksException
+    Proc.new{ Peep.hook_class! Dog, :hello, {}           }.should raise_error InvalidHooksException
+
+    Proc.new{ Peep.hook_instances! Dog, :hello, invalid_keys }.should raise_error InvalidHooksException
+    Proc.new{ Peep.hook_instances! Dog, :hello, {}           }.should raise_error InvalidHooksException
+
+    Proc.new{ Peep.hook_object! scooby, :hello, invalid_keys }.should raise_error InvalidHooksException
+    Proc.new{ Peep.hook_object! scooby, :hello, {}           }.should raise_error InvalidHooksException
+  end
+
+  it "should validate that methods are defined" do
+    p = Proc.new{|klass, result| result }
+    scooby = Dog.new("scooby")
+
+    Proc.new{ Peep.hook_class! Dog, :dance, :after => p     }.should raise_error UndefinedMethodException
+    Proc.new{ Peep.hook_instances! Dog, :dance, :after => p }.should raise_error UndefinedMethodException
+    Proc.new{ Peep.hook_object! scooby, :dance, :after => p }.should raise_error UndefinedMethodException
+  end
+
+  it "should validate that passed objects are classes for class and instance hooks" do
+    p = Proc.new{|klass, result| result}
+    Proc.new{ Peep.hook_class! :not_a_class, :hello, :after => p      }.should raise_error NotAClassException
+    Proc.new{ Peep.hook_instances! :not_a_class, :hello, :after => p  }.should raise_error NotAClassException
+  end
+
+  it "should rise an error if a hook is declared twice" do
+    p = Proc.new{|klass, result| result}
+    Peep.hook_class! Dog, :train, :after => p
+    Proc.new{ Peep.hook_class! Dog, :train, :after => p     }.should raise_error AlreadyDefinedHookException
+
+    Peep.hook_instances! Dog, :bark, :after => p
+    Proc.new{ Peep.hook_instances! Dog, :bark, :after => p  }.should raise_error AlreadyDefinedHookException
+
+    scooby = Dog.new("scooby")
+    Peep.hook_object! scooby, :bark, :after => p
+    Proc.new{ Peep.hook_object! scooby, :bark, :after => p  }.should raise_error AlreadyDefinedHookException
+  end
+
+end
+

data/spec/hooked_behavior_spec.rb

@@ -0,0 +1,165 @@
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'peeping')
+require File.join(File.dirname(__FILE__), 'helpers', 'test_helpers')
+
+include Peeping
+
+describe Peep, "when calling hook methods" do
+
+  it_should_behave_like "a clean test"
+
+  it "should evaluate class proc calls" do
+    before_class_hook_called  = false
+    after_class_hook_called   = false
+    Peep.hook_class!(
+            Dog,
+            :eats?,
+            :before => Proc.new{|*args| before_class_hook_called = true },
+            :after  => Proc.new{|*args| after_class_hook_called  = true }   )
+    Dog.eats?('french fries')
+    before_class_hook_called.should == true
+    after_class_hook_called.should  == true
+  end
+
+  it "should evaluate instance proc calls" do
+    before_instance_hook_called = false
+    after_instance_hook_called  = false
+    Peep.hook_instances!(
+            Dog,
+            :bark,
+            :before => Proc.new{|*args| before_instance_hook_called = true},
+            :after  => Proc.new{|*args| after_instance_hook_called  = true}   )
+    Dog.new('scooby').bark(10)
+    before_instance_hook_called.should == true
+    after_instance_hook_called.should  == true
+  end
+
+  it "should evaluate singleton instance proc calls" do
+    before_singleton_hook_called = false
+    after_singleton_hook_called  = false
+    scooby = Dog.new('scooby')
+    Peep.hook_object!(
+            scooby,
+            :bark,
+            :before => Proc.new{|*args| before_singleton_hook_called = true},
+            :after  => Proc.new{|*args| after_singleton_hook_called  = true}   )
+    scooby.bark(10)
+    before_singleton_hook_called.should == true
+    after_singleton_hook_called.should  == true
+  end
+
+  it "should evaluate singleton hooks for singleton methods instead of instance methods" do
+    scooby = Dog.new('scooby')
+    class << scooby
+      def eat_scooby_snacks(how_many)
+        if how_many > 5
+          @mood = :happy
+          "Scooby doobee doo!"
+        else
+          @mood = :hungry
+          "I'm hungry, give me more!"
+        end
+      end
+    end
+
+    Peep.hook_object!(
+            scooby,
+            :eat_scooby_snacks,
+            :before => (Proc.new do |object, *params|
+              object.instance_variable_get(:@mood).should == nil
+              params.should == [10]
+            end),
+            :after  => (Proc.new do |object, result|
+              object.should == scooby
+              result.should == "Scooby doobee doo!"
+              object.instance_variable_get(:@mood).should == :happy
+            end))
+    scooby.eat_scooby_snacks(10)
+  end
+
+  it "should always override instance method calls with singleton method calls" do
+    scooby = Dog.new('scooby')
+    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')
+    Peep.hook_instances!(
+            Dog,
+            :lick_owner,
+            :after => Proc.new{|objetc, result| result.should == "I have no owner to lick :(" } )
+    scooby.lick_owner
+    lassie.lick_owner
+  end
+
+end
+
+describe Peep, "when using parameters in block calls" do
+
+  it_should_behave_like "a clean test"
+
+  it "should accept the same parameters in before hooks as the hooked class methods" do
+    Peep.hook_class!(
+            Dog,
+            :eats?,
+            :before => (Proc.new do |klass, *params|
+              klass.should == Dog
+              params.should == ['meat']
+            end))
+    Dog.eats?('meat')
+  end
+
+  it "should accept the same parameters in before hooks as the hooked instance methods" do
+    scooby = Dog.new('scooby')
+    Peep.hook_instances!(
+    Dog,
+    :bark,
+    :before => (Proc.new do |object, *params|
+              object.should == scooby
+              params.should == [3]
+            end))
+    scooby.bark(3)
+  end
+
+  it "should accept the same parameters in before hooks as the hooked singleton method" do
+    scooby = Dog.new('scooby')
+    Peep.hook_object!(
+    scooby,
+    :bark,
+    :before => (Proc.new do |object, *params|
+            params.should == [4]
+            object.should == scooby
+          end))
+    scooby.bark(4)
+  end
+
+  it "should return the same object after a hooked class method call" do
+    Peep.hook_class!(
+            Dog,
+            :eats?,
+            :after => Proc.new{|klass, result| result.should == true } )
+    Dog.eats?('bones')
+  end
+
+  it "hould return the same object after a hooked instance method call" do
+    scooby = Dog.new('scooby')
+    Peep.hook_instances!(
+            Dog,
+            :bark,
+            :after => Proc.new{|klass, result| result.should == "woof woof woof!" } )
+    scooby.bark(3)
+  end
+
+  it "should return the same object after a hooked singleton method call" do
+    scooby = Dog.new('scooby')
+    Peep.hook_object!(
+            scooby,
+            :lick_owner,
+            :before =>  Proc.new{|object, *args| object.owner = "John" },
+            :after =>   Proc.new{|object, result| result.should == "John is now all wet!" })
+    scooby.lick_owner
+  end
+
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: chubas-peeping
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ruben Medellin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 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.
+email: ruben.medellin.c@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/peeping.rb
+- lib/peeping/exceptions.rb
+- lib/peeping/hook.rb
+- lib/peeping/peeping.rb
+- lib/peeping/util.rb
+- spec/helpers/test_helpers.rb
+- spec/hook_methods_spec.rb
+- spec/hooked_behavior_spec.rb
+has_rdoc: true
+homepage: http://github.com/chubas/peeping
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- none
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Lightweight AOP framework for managing method hooks
+test_files: 
+- spec/hooked_behavior_spec.rb
+- spec/hook_methods_spec.rb