uberhook 0.0.2 → 0.0.3

data/README.md

@@ -6,22 +6,14 @@ The Uberhook gem allows you to define `before` and `after` hooks for your classe
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-```
-gem 'uberhook'
 ```
-
-And then execute:
-
-```
-$ bundle
+$ gem install uberhook
 ```
 
-Or install it yourself as:
+Or add the following line to your application's Gemfile and run `$ bundle` afterwards.
 
 ```
-$ gem install uberhook
+gem 'uberhook'
 ```
 
 ## Usage
@@ -30,16 +22,18 @@ $ gem install uberhook
 require 'uberhook'
 
 class Car
-  include Uberhook
+  include Uberhook::Abstract
 
-  before :drive, :start_engine
+  before :drive do
+    p 'start engine'
+  end
 
-  def drive
-    puts 'Now lets drive.'
+  after :drive do
+    p 'turn radio on'
   end
 
-  def start_engine
-    puts 'First start the engine.'
+  def drive
+    p 'drive'
   end
 end
 
@@ -47,6 +41,46 @@ beatle = Car.new
 beatle.drive
 
 # Output:
-#   First start the engine.
-#   And now lets drive.
+#   start engine
+#   drive
+#   turn radio on
+```
+
+Use the `Uberhook::Base` module to define class hooks.
+
+``` ruby
+require 'uberhook'
+
+class Dance
+  include Uberhook::Base
+
+  instance_hook :after, :step_one do
+    p 'two!'
+  end
+
+  def step_one
+    p 'one!'
+  end
+
+  class_hook :before, :rock do
+    p 'prepare'
+  end
+
+  def self.rock
+    p 'and rock'
+  end
+end
+
+waltz = Dance.new
+waltz.step_one
+
+# Output:
+#   one!
+#   two!
+
+Dance.rock
+
+# Output:
+#   prepare
+#   and rock
 ```

data/Rakefile

@@ -1,11 +1,10 @@
-require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 task :default => :test
+task :spec => :test
 
 Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
   t.warning = true
-  t.verbose = true
-end
+end

data/lib/uberhook/abstract.rb

@@ -0,0 +1,30 @@
+module Uberhook
+  module Abstract
+    def self.included(base)
+      base.send :include, Uberhook::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Define a before or after hook for a specific method.
+      #
+      # @example Define before hook.
+      #   before :foo do
+      #     p 'before callback'
+      #   end
+      #
+      # @example Define after hook.
+      #   after :foo do
+      #     p 'after callback'
+      #   end
+      #
+      # @param [ Symbol ] target The target method.
+      # @param [ Proc ] callback The callback block.
+      [:before, :after].each do |type|
+        define_method(type) do |target, &callback|
+          instance_hook(type, target, &callback)
+        end
+      end
+    end
+  end
+end

data/lib/uberhook/base.rb

@@ -0,0 +1,112 @@
+module Uberhook
+  module Base
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class << self
+          def method_added(name)
+            process_instance_method_added(name)
+          end
+
+          def singleton_method_added(name)
+            process_class_method_added(name)
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def instance_hook(type, target, &callback)
+        instance_hooks[target][type] = callback
+
+        # Define instance hook if target is defined and
+        # hook is not defined yet
+        define_instance_hook(target) if
+          method_defined?(target) and
+          instance_hooks.has_key?(target) and
+          not instance_hooks[target].has_key?(:defined)
+      end
+
+      def class_hook(type, target, &callback)
+        class_hooks[target][type] = callback
+
+        # Define class hook if target is defined and
+        # hook is not defined yet
+        define_class_hook(target) if
+          respond_to?(target) and
+          class_hooks.has_key?(target) and
+          not class_hooks[target].has_key?(:defined)
+      end
+
+      private
+
+      def instance_hooks
+        @instance_hooks ||= Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def class_hooks
+        @class_hooks ||= Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def process_instance_method_added(name)
+        return unless instance_hooks.has_key?(name) and
+          not instance_hooks[name].has_key?(:defined)
+
+        define_instance_hook(name)
+      end
+
+      def process_class_method_added(name)
+        return unless class_hooks.has_key?(name) and
+          not class_hooks[name].has_key?(:defined)
+
+        define_class_hook(name)
+      end
+
+      def define_instance_hook(target)
+        instance_hooks[target][:defined] = true
+        original_target = "#{target}_without_callbacks"
+
+        alias_method original_target, target
+        private original_target
+
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{target}(*args, &block)
+            self.class.send(:run_instance_callback, :before, :#{target}, self)
+            retval = send(:#{original_target}, *args, &block)
+            self.class.send(:run_instance_callback, :after, :#{target}, self)
+            retval
+          end
+        RUBY_EVAL
+      end
+
+      def define_class_hook(target)
+        class_hooks[target][:defined] = true
+        original_target = "#{target}_without_callbacks"
+
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          class << self
+            alias_method :#{original_target}, :#{target}
+            private :#{original_target}
+
+            def #{target}(*args, &block)
+              self.send(:run_class_callback, :before, :#{target}, self)
+              retval = send(:#{original_target}, *args, &block)
+              self.send(:run_class_callback, :after, :#{target}, self)
+              retval
+            end
+          end
+        RUBY_EVAL
+      end
+
+      def run_instance_callback(type, target, scope)
+        return unless instance_hooks[target].has_key?(type)
+        scope.instance_eval(&instance_hooks[target][type])
+      end
+
+      def run_class_callback(type, target, scope)
+        return unless class_hooks[target].has_key?(type)
+        scope.instance_eval(&class_hooks[target][type])
+      end
+    end
+  end
+end

data/lib/uberhook/version.rb

@@ -0,0 +1,3 @@
+module Uberhook
+  VERSION = '0.0.3'
+end

data/lib/uberhook.rb

@@ -1,88 +1,3 @@
-# Include the Uberhook module to define 'before' and 'after' hooks
-# for your classes and models.
-#
-#   class Car
-#     include Uberhook
-#
-#     before :drive, :start_engine
-#
-#     def drive
-#       puts 'Now lets drive.'
-#     end
-#
-#     def start_engine
-#       puts 'First start the engine.'
-#     end
-#   end
-#
-#   beatle = Car.new
-#   beatle.drive
-#
-# Output:
-#   First start the engine.
-#   Now lets drive.
-module Uberhook
-  def self.included(base)
-    base.extend ClassMethods
-    base.instance_variable_set :@hooks, {}
-  end
-
-  module ClassMethods
-    def before(target, callback)
-      register_hook :pre, target, callback
-    end
-
-    def after(target, callback)
-      register_hook :post, target, callback
-    end
-
-    def register_hook(type, target, callback)
-      if method_defined? target
-        define_hook(type, target, callback)
-      else
-        add_hook_to_waitinglist(type, target, callback)
-      end
-    end
-
-    private
-
-    def define_hook(type, target, callback)
-      alias_method "#{target}_without_callbacks", target
-      if type == :pre
-        define_method target do
-          send callback
-          send "#{target}_without_callbacks"
-        end
-      elsif type == :post
-        define_method target do
-          send "#{target}_without_callbacks"
-          send callback
-        end
-      end
-    end
-
-    def add_hook_to_waitinglist(type, target, callback)
-      @hooks[type] = {} unless @hooks[type].kind_of? Hash
-      callbacks = @hooks[type][target]
-      @hooks[type][target] = (callbacks || []) << callback
-    end
-
-    def remove_hook_from_waitinglist(type, target, callback)
-      @hooks[type][target].delete callback
-    end
-
-    def perform_method_added(name)
-      @hooks.each do |type, hook|
-        next unless hook[name]
-        hook[name].each do |callback|
-          remove_hook_from_waitinglist(type, name, callback)
-          define_hook(type, name, callback)
-        end
-      end
-    end
-
-    def method_added(name)
-      perform_method_added(name)
-    end
-  end
-end
+require 'uberhook/abstract'
+require 'uberhook/base'
+require 'uberhook/version'

data/spec/abstract_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Uberhook::Abstract do
+  let(:klass) do
+    Class.new { include Uberhook::Abstract }
+  end
+
+  describe :before do
+    it 'should forward hook definition' do
+      klass.expects(:instance_hook).with(:before, :one).once
+      klass.class_eval { before :one }
+    end
+  end
+
+  describe :around do
+    it 'should forward hook definition'
+  end
+
+  describe :after do
+    it 'should forward hook definition' do
+      klass.expects(:instance_hook).with(:after, :one).once
+      klass.class_eval { after :one }
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe Uberhook::Base do
+  let(:klass) do
+    Class.new do
+      include Uberhook::Base
+
+      def one
+        @hook_calls << :one
+      end
+
+      def self.two
+        @hook_calls << :two
+      end
+    end
+  end
+
+  describe :instance_hook do
+    it 'should save a callback' do
+      klass.class_eval { instance_hook :before, :one }
+      hash = {:one => {:before => nil, :defined => true}}
+      klass.send(:instance_hooks).must_equal hash
+    end
+  end
+
+  it 'should forward a hook definition' do
+    klass.expects(:define_instance_hook).with(:one).once
+    klass.class_eval { instance_hook :before, :one }
+  end
+
+  it 'should not forward a unkown hook definition' do
+    klass.expects(:define_instance_hook).times(0)
+    klass.class_eval { instance_hook :before, :unkown }
+  end
+
+  it 'should excecute hooks' do
+    klass.class_eval do
+      attr_reader :hook_calls
+      def initialize
+        @hook_calls = []
+      end
+      instance_hook :before, :one do
+        @hook_calls << :before_one
+      end
+      instance_hook :after, :one do
+        @hook_calls << :after_one
+      end
+    end
+    inst = klass.new
+    inst.one
+    inst.hook_calls.must_equal [:before_one, :one, :after_one]
+  end
+
+  describe :class_hook do
+    it 'should save a callback' do
+      klass.class_eval { class_hook :before, :two }
+      hash = {:two => {:before => nil, :defined => true}}
+      klass.send(:class_hooks).must_equal hash
+    end
+
+    it 'should forward a hook definition' do
+      klass.expects(:define_class_hook).with(:two).once
+      klass.class_eval { class_hook :before, :two }
+    end
+
+    it 'should not forward a unkown hook definition' do
+      klass.expects(:define_class_hook).times(0)
+      klass.class_eval { class_hook :before, :unkown }
+    end
+
+    it 'should excecute hooks' do
+      klass.class_eval do
+        @hook_calls = []
+        class_hook :before, :two do
+          @hook_calls << :before_two
+        end
+        class_hook :after, :two do
+          @hook_calls << :after_two
+        end
+      end
+      hooks = [:before_two, :two, :after_two]
+      klass.two
+      klass.instance_variable_get(:@hook_calls).must_equal hooks
+    end
+  end
+
+  describe :process_instance_method_added do
+    it 'should excecute when methods get added' do
+      klass.expects(:process_instance_method_added).with(:three).once
+      klass.class_eval { def three; end }
+    end
+
+    it 'should continue when hooks get defined' do
+      klass.expects(:define_instance_hook).with(:three).once
+      klass.class_eval do
+        instance_hook :before, :three
+        def three; end
+      end
+    end
+
+    it 'should not continue without a hook' do
+      klass.expects(:define_instance_hook).times(0)
+      klass.class_eval { def three; end }
+    end
+  end
+
+  describe :process_class_method_added do
+    it 'should excecute when methods get added' do
+      skip 'Ignore methods like :singleton_method_added'
+      klass.expects(:process_class_method_added).with(:four).once
+      klass.class_eval { def self.four; end }
+    end
+
+    it 'should continue when hooks get defined' do
+      klass.expects(:define_class_hook).with(:four).once
+      klass.class_eval do
+        class_hook :before, :four
+        def self.four; end
+      end
+    end
+
+    it 'should not continue without a hook' do
+      klass.expects(:define_class_hook).times(0)
+      klass.class_eval { def self.four; end }
+    end
+  end
+
+  describe :define_instance_hook do
+    it 'should return the targets return value' do
+      klass.class_eval do
+        instance_hook :after, :three do
+          'after'
+        end
+        def three
+          'three'
+        end
+      end
+      klass.new.three.must_equal 'three'
+    end
+
+    it 'should make the original target method private' do
+      klass.class_eval { instance_hook :before, :one }
+      klass.new.private_methods.must_include :one_without_callbacks
+    end
+  end
+
+  describe :define_class_hook do
+    it 'should return the targets return value' do
+      klass.class_eval do
+        class_hook :after, :four do
+          'after'
+        end
+        def self.four
+          'four'
+        end
+      end
+      klass.four.must_equal 'four'
+    end
+
+    it 'should make the original target method private' do
+      klass.class_eval { class_hook :before, :two }
+      klass.private_methods.must_include :two_without_callbacks
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'mocha'
+
+require 'uberhook'

data/uberhook.gemspec

@@ -1,16 +1,19 @@
+require File.expand_path('../lib/uberhook/version', __FILE__)
+
 Gem::Specification.new do |gem|
   gem.name          = 'uberhook'
-  gem.version       = '0.0.2'
   gem.authors       = ['Martin Jagusch']
   gem.email         = ['_@mj.io']
+  gem.version       = Uberhook::VERSION
   gem.description   = 'Allows you to define :before and :after hooks for your classes and models.'
   gem.summary       = ':before and :after hooks'
   gem.homepage      = 'https://github.com/mjio/uberhook'
 
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'mocha', '~> 0.12.3'
+  gem.add_development_dependency 'minitest', '~> 3.3.0'
 
   gem.files         = `git ls-files`.split($/)
-  gem.test_files    = gem.files.grep(%r{^test/})
+  gem.test_files    = gem.files.grep(%r{^spec/})
   gem.require_paths = ['lib']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uberhook
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,40 +9,56 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-08 00:00:00.000000000 Z
+date: 2012-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2.2
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.3.0
 description: Allows you to define :before and :after hooks for your classes and models.
 email:
 - _@mj.io
@@ -57,8 +73,12 @@ files:
 - README.md
 - Rakefile
 - lib/uberhook.rb
-- test/test_helper.rb
-- test/uberhook_test.rb
+- lib/uberhook/abstract.rb
+- lib/uberhook/base.rb
+- lib/uberhook/version.rb
+- spec/abstract_spec.rb
+- spec/base_spec.rb
+- spec/spec_helper.rb
 - uberhook.gemspec
 homepage: https://github.com/mjio/uberhook
 licenses: []
@@ -85,5 +105,6 @@ signing_key:
 specification_version: 3
 summary: ':before and :after hooks'
 test_files:
-- test/test_helper.rb
-- test/uberhook_test.rb
+- spec/abstract_spec.rb
+- spec/base_spec.rb
+- spec/spec_helper.rb

data/test/test_helper.rb

@@ -1,10 +0,0 @@
-require 'test/unit'
-require 'mocha'
-
-require 'uberhook'
-
-class Uberhook::TestCase < Test::Unit::TestCase
-  def self.test(name, &block)
-    define_method("test #{name.inspect}", &block)
-  end
-end

data/test/uberhook_test.rb

@@ -1,112 +0,0 @@
-require 'test_helper'
-
-class UberhookTest < Uberhook::TestCase
-  def setup
-    @car = Class.new do
-      attr_reader :status
-      include Uberhook
-      def drive; @status = :drive; end
-      def start; @status = :start; end
-      def stop; end
-    end
-  end
-
-  test 'should register :pre hook' do
-    @car.expects(:register_hook).with(:pre, :drive, :start).once
-    @car.class_eval do
-      before :drive, :start
-    end
-  end
-
-  test 'should register :post hook' do
-    @car.expects(:register_hook).with(:post, :drive, :stop).once
-    @car.class_eval do
-      after :drive, :stop
-    end
-  end
-
-  test 'should save :pre hook temporally when target is not defined' do
-    @car.expects(:add_hook_to_waitinglist).with(:pre, :two, :one).once
-    @car.class_eval do
-      register_hook :pre, :two, :one
-      def one; end
-      def two; end
-    end
-  end
-
-  test 'should not define :pre hook when target is not defined' do
-    @car.expects(:define_hook).times(0)
-    @car.class_eval do
-      register_hook :pre, :two, :one
-    end
-  end
-
-  test 'should not define :post hook when target is not defined' do
-    @car.expects(:define_hook).times(0)
-    @car.class_eval do
-      register_hook :post, :one, :two
-    end
-  end
-
-  test 'should run callback before the hook method' do
-    @car.class_eval do
-      register_hook :pre, :drive, :start
-    end
-    beatle = @car.new
-    beatle.expects(:start).once
-    beatle.drive
-  end
-
-  test 'should run callback after the hook method' do
-    @car.class_eval do
-      register_hook :post, :start, :drive
-    end
-    beatle = @car.new
-    beatle.expects(:drive).once
-    beatle.start
-  end
-
-  test 'should run :pre callback when hook method gets defined' do
-    @car.class_eval do
-      register_hook :pre, :two, :one
-      def one; end
-      def two; end
-    end
-    beatle = @car.new
-    beatle.expects(:one).once
-    beatle.two
-  end
-
-  test 'should run :pre callback after hook method gets defined' do
-    @car.class_eval do
-      register_hook :pre, :two, :one
-      def one; @status = :one; end
-      def two; @status = :two; end
-    end
-    beatle = @car.new
-    beatle.two
-    assert_equal :two, beatle.status
-  end
-
-  test 'should run :post callback when hook method gets defined' do
-    @car.class_eval do
-      register_hook :post, :one, :two
-      def one; end
-      def two; end
-    end
-    beatle = @car.new
-    beatle.expects(:two).once
-    beatle.one
-  end
-
-  test 'should run :post callback after hook method gets defined' do
-    @car.class_eval do
-      register_hook :post, :one, :two
-      def one; @status = :one; end
-      def two; @status = :two; end
-    end
-    beatle = @car.new
-    beatle.one
-    assert_equal :two, beatle.status
-  end
-end