kinda-hookable 0.0.2 → 0.0.3

data/lib/hookable.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'kinda-core'
+
+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
+      
+      [: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 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 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|
+          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 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)
+          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.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
+
+    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)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_name, include_private=false)
+      super || singleton_class.hooked_method_defined?(method_name)
+    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')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kinda-hookable
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Manuel Vila
@@ -31,6 +31,8 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
+- lib/hookable.rb
+- lib/kinda-hookable.rb
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/kinda/hookable