kinda-hookable 0.0.2

data/README.rdoc

@@ -0,0 +1,14 @@
+Author:: Manuel Vila (mailto:mvila@3base.com)
+License:: Don't know yet
+
+= Hookable
+
+Patch any method with before, after and around hooks.
+
+== Installation
+
+  $ sudo gem install kinda-hookable --source http://gems.github.com
+
+== Usage
+
+Still very alpha and documentation will come later.

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,62 @@
+--- !ruby/object:Gem::Specification 
+name: kinda-hookable
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Manuel Vila
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07: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: 
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/kinda/hookable
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Patch any method with before, after and around hooks
+test_files: 
+- test/hookable_test.rb