kinda-hookable 0.0.3 → 0.0.4

data/README.rdoc

@@ -1,6 +1,3 @@
-Author:: Manuel Vila (mailto:mvila@3base.com)
-License:: Don't know yet
-
 = Hookable
 
 Patch any method with before, after and around hooks.
@@ -11,4 +8,4 @@ Patch any method with before, after and around hooks.
 
 == Usage
 
-Still very alpha and documentation will come later.
+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

@@ -5,14 +5,7 @@ module Kinda
   module Hookable
     include Core
 
-    module ClassMethods
-      extend container.extensions
-      
-      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
-      
+    ClassMethods = inheritable_extend do
       [:before, :after, :around].each do |kind|
         define_method(kind) do |method_name, &block|
           add_hook(kind, method_name, &block)
@@ -21,6 +14,41 @@ module Kinda
 
       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
 
@@ -45,12 +73,6 @@ module Kinda
         result
       end
     
-      def hooked_methods
-        @hooked_methods ||= Hash.new do |hash, method_name|
-          hash[method_name] = HookedMethod.new(self, method_name)
-        end
-      end
-
       def find_hooks(method_name, kind)
         hooks = []
         self_and_ancestors.each do |ancestor|
@@ -61,70 +83,44 @@ module Kinda
         end
         hooks
       end
-
-      def hooked_method_defined?(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
-
+      
       def method_added(method_name)
         super
-        if hooked_method_defined?(method_name)
+        if method_hooked?(method_name)
           patch_method(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.exec_method(method_name, original_method, self, *args, &block)
-        end
-        Thread.current[:__adding_method__] = false
-        hooked_methods[method_name].method_patched = true
-      end
-
       def patch_method_if_necessary(method_name)
         self_and_ancestors.each do |ancestor|
-          ancestor.is_a?(Module) ? next : break unless ancestor.respond_to?(:method_defined_in_this_class?)
-          if ancestor.method_defined_in_this_class?(method_name)
+          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
-
-      def method_defined_in_this_class?(name) # Works for singleton class too
-        instance_method(name).owner == self rescue false
-      end
     end
 
-    inheritable_extension ClassMethods
-
     ###
 
-    delegate_to_class :before
-    delegate_to_class :after
-    alias_method :on, :after
-    delegate_to_class :around
-    delegate_to_class :singleton_method_added, :method_added
+    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 singleton_class.hooked_method_defined?(method_name)
-        singleton_class.exec_method(method_name, nil, self, *args, &block)
+      if method_hooked?(method_name)
+        singleton_class_send(:exec_method, method_name, nil, self, *args, &block)
       else
         super
       end
     end
-
-    def respond_to?(method_name, include_private=false)
-      super || singleton_class.hooked_method_defined?(method_name)
-    end
     
     ###
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kinda-hookable
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Manuel Vila
@@ -31,11 +31,13 @@ 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: []
 
@@ -56,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: kinda-hookable
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Patch any method with before, after and around hooks