hookable 0.0.5

data/README.rdoc

@@ -0,0 +1,11 @@
+= Hookable
+
+Patch any method with before, after and around hooks.
+
+== Installation
+
+  $ sudo gem install hookable --source http://gemcutter.org
+
+== Usage
+
+Still very alpha, documentation will come later.

data/Rakefile

@@ -0,0 +1,20 @@
+require "rake/testtask"
+
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.test_files = Dir["test/*_test.rb"]
+end
+
+Rake::RDocTask.new do |t|
+  t.title = "Hookable Documentation"
+  t.main = "README.rdoc"
+  t.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  t.rdoc_dir = "doc"
+end

data/lib/hookable.rb

@@ -0,0 +1,141 @@
+require 'rubygems'
+require 'kinda-core'
+
+module Kinda
+  module Hookable
+    include Core
+
+    ClassMethods = inheritable_extend do
+      [:before, :after, :around].each do |kind|
+        define_method(kind) do |method_name, &block|
+          add_hook(kind, method_name, &block)
+        end
+      end
+
+      alias_method :on, :after
+
+      def method_hooked?(method_name)
+        self_and_ancestors.each do |ancestor|
+          ancestor.is_a?(Module) ? next : break unless ancestor.respond_to?(:hooked_methods)
+          return true if ancestor.hooked_methods.include?(method_name)
+        end
+        false
+      end
+
+      protected
+
+      def hooked_methods
+        @hooked_methods ||= Hash.new do |hash, method_name|
+          hash[method_name] = Hookable::HookedMethod.new(self, method_name)
+        end
+      end
+
+      def patch_method(method_name)
+        return if Thread.current[:__adding_method__]
+        # puts "Patching method ##{method_name} in #{self.inspect}"
+        original_method = instance_method(method_name)
+        Thread.current[:__adding_method__] = true
+        define_method(method_name) do |*args, &block|
+          singleton_class_send(:exec_method, method_name, original_method, self, *args, &block)
+        end
+        Thread.current[:__adding_method__] = false
+        hooked_methods[method_name].method_patched = true
+      end
+
+      private
+
+      def add_hook(kind, method_name, &block)
+        hooked_methods[method_name.to_sym].hooks[kind] << block
+        patch_method_if_necessary(method_name.to_sym)
+      end
+
+      def exec_method(method_name, original_method, original_self, *args, &block)
+        result = nil
+
+        chained_hooks = [] << lambda do |*args, &block|
+          find_hooks(method_name, :before).each do |hook|
+            original_self.call_with_this(hook, *args, &block)
+          end
+          result = original_method.bind(original_self).call(*args, &block) if original_method
+          find_hooks(method_name, :after).each do |hook|
+            original_self.call_with_this(hook, *args, &block)
+          end
+        end
+
+        hooks = find_hooks(method_name, :around)
+        hooks.each_index do |index|
+          chained_hooks << lambda do |*args, &block|
+            original_self.call_with_this(hooks[index], chained_hooks[index], *args, &block)
+          end
+        end
+        chained_hooks.last.call(*args, &block)
+
+        result
+      end
+    
+      def find_hooks(method_name, kind)
+        hooks = []
+        self_and_ancestors.each do |ancestor|
+          ancestor.is_a?(Module) ? next : break unless ancestor.respond_to?(:hooked_methods)
+          next unless ancestor.hooked_methods.include?(method_name)
+          next unless ancestor.hooked_methods[method_name].hooks.include?(kind)
+          hooks.concat(ancestor.hooked_methods[method_name].hooks[kind])
+        end
+        hooks
+      end
+      
+      def method_added(method_name)
+        super
+        if method_hooked?(method_name)
+          patch_method(method_name)
+        end
+      end
+
+      def patch_method_if_necessary(method_name)
+        self_and_ancestors.each do |ancestor|
+          ancestor.is_a?(Module) ? next : break unless ancestor.respond_to?(:patch_method)
+          method_defined_in_this_class = ancestor.instance_method(method_name).owner == ancestor rescue false
+          if method_defined_in_this_class
+            ancestor.patch_method(method_name) unless ancestor.hooked_methods[method_name].method_patched
+            break
+          end
+        end
+      end
+    end
+
+    ###
+
+    delegate_to_class ClassMethods.public_instance_methods
+    delegate_to_class :singleton_method_added => :method_added
+
+    def respond_to?(method_name, include_private=false)
+      super || method_hooked?(method_name)
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      if method_hooked?(method_name)
+        singleton_class_send(:exec_method, method_name, nil, self, *args, &block)
+      else
+        super
+      end
+    end
+    
+    ###
+  
+    class HookedMethod
+      attr_reader :klass, :name
+      attr_accessor :method_patched
+  
+      def initialize(klass, name)
+        @klass = klass
+        @name = name
+      end
+
+      def hooks
+        @hooks ||= Hash.new { |hash, kind| hash[kind] = [] }
+      end
+    end
+  end
+end

data/lib/kinda-hookable.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'hookable')

data/test/hookable_test.rb

@@ -0,0 +1,567 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-hookable'
+
+class HookableClassTest < Test::Unit::TestCase
+  def setup
+    @simple_class = Class.new do
+      include Kinda::Hookable
+    end
+    
+    @simple = @simple_class.new
+  end
+  
+  def test_no_method_error
+    assert_raise NoMethodError do
+      @simple.hello
+    end
+  end
+  
+  def test_before
+    result = []
+    @simple.before(:hello) { result << 'before' }
+    @simple.hello
+    assert_equal ['before'], result
+  end
+  
+  def test_before_and_after
+    result = []
+    @simple.before(:hello) { result << 'before' }
+    @simple.after(:hello) { result << 'after' }
+    @simple.hello
+    assert_equal ['before', 'after'], result
+  end
+
+  def test_before_after_and_around
+    result = []
+    @simple.before(:hello) { result << 'before' }
+    @simple.after(:hello) { result << 'after' }
+    @simple.around(:hello) do |original_method|
+      result << 'around begin'
+      original_method.call
+      result << 'around end'
+    end
+    @simple.hello
+    assert_equal ['around begin', 'before', 'after', 'around end'], result
+  end
+  
+  def test_respond_to
+    assert @simple.respond_to?(:before)
+    @simple.before(:hello) { result << 'before' }
+    assert @simple.respond_to?(:hello)
+    assert !@simple.respond_to?(:undefined_method)
+  end
+end
+
+###
+
+class HookableClassWithAMethodTest < Test::Unit::TestCase
+  def setup
+    @simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+
+      def hello
+        @result << 'hello'
+      end
+    end
+    
+    @simple = @simple_class.new
+  end
+  
+  def test_hello
+    @simple.hello
+    assert_equal ['hello'], @simple.result
+  end
+
+  def test_before
+    @simple.before(:hello) { this.result << 'before' }
+    @simple.hello
+    assert_equal ['before', 'hello'], @simple.result
+  end
+
+  def test_two_befores
+    @simple.before(:hello) { this.result << 'before 1' }
+    @simple.before(:hello) { this.result << 'before 2' }
+    @simple.hello
+    assert_equal ['before 1', 'before 2', 'hello'], @simple.result
+  end
+
+  def test_before_after_and_around
+    @simple.before(:hello) { this.result << 'before' }
+    @simple.after(:hello) { this.result << 'after' }
+    @simple.around(:hello) do |original_method|
+      this.result << 'around begin'
+      original_method.call
+      this.result << 'around end'
+    end
+    @simple.hello
+    assert_equal ['around begin', 'before', 'hello', 'after', 'around end'], @simple.result
+  end
+
+  def test_two_arounds
+    @simple.around(:hello) do |original_method|
+      this.result << 'around 1 begin'
+      original_method.call
+      this.result << 'around 1 end'
+    end
+    @simple.around(:hello) do |original_method|
+      this.result << 'around 2 begin'
+      original_method.call
+      this.result << 'around 2 end'
+    end
+    @simple.hello
+    assert_equal ['around 2 begin', 'around 1 begin', 'hello',
+      'around 1 end', 'around 2 end'], @simple.result
+  end
+
+  def test_respond_to
+    assert @simple.respond_to?(:hello)
+  end
+end
+
+###
+
+class HookableClassWithAMethodWithParametersAndResultTest < Test::Unit::TestCase
+  def setup
+    @simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+
+      def hello(first_name, last_name)
+        greeting = "hello #{first_name} #{last_name}"
+        @result << greeting
+        greeting
+      end
+    end
+    
+    @simple = @simple_class.new
+  end
+
+  def test_hello
+    greeting = @simple.hello('Manuel', 'Vila')
+    assert_equal 'hello Manuel Vila', greeting
+    assert_equal ['hello Manuel Vila'], @simple.result
+  end
+
+  def test_before
+    @simple.before(:hello) { |first, last| this.result << "before hello #{first} #{last}" }
+    greeting = @simple.hello('Manuel', 'Vila')
+    assert_equal 'hello Manuel Vila', greeting
+    assert_equal ['before hello Manuel Vila', 'hello Manuel Vila'], @simple.result
+  end
+
+  def test_after
+    @simple.after(:hello) { |first, last| this.result << "after hello #{first} #{last}" }
+    greeting = @simple.hello('Manuel', 'Vila')
+    assert_equal 'hello Manuel Vila', greeting
+    assert_equal ['hello Manuel Vila', 'after hello Manuel Vila'], @simple.result
+  end
+
+  def test_before_and_around
+    @simple.before(:hello) { |first, last| this.result << "before hello #{first} #{last}" }
+    @simple.around(:hello) do |original_method, first, last|
+      this.result << "around hello #{first} #{last} begin"
+      original_method.call(first, last)
+      this.result << "around hello #{first} #{last} end"
+    end
+    greeting = @simple.hello('Manuel', 'Vila')
+    assert_equal 'hello Manuel Vila', greeting
+    assert_equal ['around hello Manuel Vila begin', 'before hello Manuel Vila',
+      'hello Manuel Vila', 'around hello Manuel Vila end'], @simple.result
+  end
+end
+
+###
+
+class HookableSuperClassTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+    end
+
+    @simple_class = Class.new(@super_simple_class)
+
+    @simple = @simple_class.new
+  end
+
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class.superclass], @simple.result
+  end
+
+  def test_respond_to_with_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class], @simple.result
+  end
+  
+  def test_respond_to_with_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass], @simple.result
+  end
+end
+
+###
+
+class HookableSuperClassWithAMethodTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+
+      def hello
+        @result << 'hello'
+      end
+    end
+
+    @simple_class = Class.new(@super_simple_class)
+
+    @simple = @simple_class.new
+  end
+
+  def test_respond_to
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class.superclass, 'hello'], @simple.result
+  end
+
+  def test_respond_to_with_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class, 'hello'], @simple.result
+  end
+  
+  def test_respond_to_with_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, 'hello'], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass, 'hello'], @simple.result
+  end
+end
+
+###
+
+class HookableSuperClassWithAMethodInClassTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+    end
+
+    @simple_class = Class.new(@super_simple_class) do
+      def hello
+        @result << 'hello'
+      end
+    end
+
+    @simple = @simple_class.new
+  end
+
+  def test_respond_to
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal ['hello'], @simple.result
+  end
+  
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class, 'hello'], @simple.result
+  end
+  
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, 'hello'], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass, 'hello'], @simple.result
+  end
+end
+
+###
+
+class HookableSuperClassWithAMethodInSingletonClassTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+    end
+
+    @simple_class = Class.new(@super_simple_class)
+
+    @simple = @simple_class.new
+
+    def @simple.hello
+      @result << 'hello'
+    end
+  end
+
+  def test_respond_to
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal ['hello'], @simple.result
+  end
+  
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal ['hello'], @simple.result
+  end
+  
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, 'hello'], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass, 'hello'], @simple.result
+  end
+end
+
+###
+
+class HookableModuleTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+    end
+
+    @simple_module = Module.new do
+      include Kinda::Hookable
+    end
+
+    @simple_class = Class.new(@super_simple_class)
+    @simple_class.send(:include, @simple_module)
+
+    @simple = @simple_class.new
+  end
+
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class.superclass], @simple.result
+  end
+
+  def test_respond_to_with_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_module
+    @simple_module.module_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple_module], @simple.result
+  end
+
+  def test_respond_to_with_before_in_module
+    @simple_module.module_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class], @simple.result
+  end
+  
+  def test_respond_to_with_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass], @simple.result
+  end
+end
+
+###
+
+class HookableModuleWithAMethodTest < Test::Unit::TestCase
+  def setup
+    @super_simple_class = Class.new do
+      include Kinda::Hookable
+
+      attr_accessor :result
+
+      def initialize
+        @result = []
+      end
+    end
+
+    @simple_module = Module.new do
+      include Kinda::Hookable
+
+      def hello
+        @result << 'hello'
+      end
+    end
+
+    @simple_class = Class.new(@super_simple_class)
+    @simple_class.send(:include, @simple_module)
+
+    @simple = @simple_class.new
+  end
+
+  def test_respond_to
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } } # not executed
+    @simple.hello
+    assert_equal ['hello'], @simple.result
+  end
+
+  def test_respond_to_with_before_in_superclass
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_module
+    @simple_module.module_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple_module, 'hello'], @simple.result
+  end
+
+  def test_respond_to_with_before_in_module
+    @simple_module.module_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+  
+  def test_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.hello
+    assert_equal [@simple.class, 'hello'], @simple.result
+  end
+  
+  def test_respond_to_with_before_in_class
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    assert @simple.respond_to?(:hello)
+  end
+
+  def test_before_in_singleton_class
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, 'hello'], @simple.result
+  end
+
+  def test_before_in_superclass_class_and_singleton_class
+    @super_simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple_class.class_eval { before(:hello) { this.result << self } }
+    @simple.before(:hello) { this.result << self }
+    @simple.hello
+    assert_equal [self, @simple.class, @simple.class.superclass, 'hello'], @simple.result
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: hookable
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Manuel Vila
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: kinda-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.1
+    version: 
+description: Patch any method with before, after and around hooks
+email: mvila@3base.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- lib/hookable.rb
+- lib/kinda-hookable.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/kinda/hookable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: kinda-hookable
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Patch any method with before, after and around hooks
+test_files: 
+- test/hookable_test.rb