nakajima-booty-call 0.0.3 → 0.0.5

data/lib/booty_call.rb

@@ -1,11 +1,14 @@
 $LOAD_PATH << File.dirname(__FILE__) + '/booty_call'
+$LOAD_PATH << File.dirname(__FILE__) + '/core_ext'
 
 module BootyCall
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end
 
 require 'rubygems'
 require 'nakajima'
+require 'array'
+require 'method'
 require 'callbacker'
 require 'observed_method'
 require 'introspector'

data/lib/booty_call/callbacker.rb

@@ -15,23 +15,26 @@ module BootyCall
       add_callback(:after, method_id, *symbols, &block)
     end
     
+    def around(method_id, *symbols, &block)
+      add_callback(:around, method_id, *symbols, &block)
+    end
+    
     private
     
     def extend_klass
       klass.class_eval do
         @pristine_cache = Hash.new
-        @callback_cache = { :after => Hash.new([]), :before => Hash.new([]) }
+        @callback_cache = { :after => Hash.new([]), :before => Hash.new([]), :around => Hash.new([]) }
         extend ClassMethods
         include InstanceMethods
       end
     end
     
     def add_callback(position, method_id, *symbols, &block)
-      klass.callback_cache[position][method_id].tap do |slot|
-        slot.push(block) if block_given?
-        slot.concat(symbols)
-        slot.tap.compact!.uniq!
-      end
+      klass.callback_cache[position][method_id] << block if block_given?
+      klass.callback_cache[position][method_id] += symbols
+      klass.callback_cache[position][method_id].compact!
+      klass.callback_cache[position][method_id].uniq!
       
       klass.pristine_cache[method_id] ||= begin
         klass.instance_method(method_id).tap do
@@ -42,19 +45,19 @@ module BootyCall
     
     def redefine_method(method_id)
       safe_method_id = method_id.to_s
-      safe_method_id.gsub!(/=/, '__EQUALS__')
-      safe_method_id.gsub!(/\?/, '__PREDICATE__')
+      safe_method_id.gsub!(/([\w_]+)(\?|!|=|\b)/) { |m| "#{$1}_without_callbacks#{$2}" }
       klass.class_eval(<<-EOS, "(__DELEGATION__)", 1)
         def #{method_id}(*args, &block)
           catch(#{method_id.to_sym.inspect}) do
-            return unless self.class.run_callbacks_for(self, :before, #{method_id.inspect})
-            result = __PRISTINE__(#{method_id.inspect}, *args, &block)
-            self.class.run_callbacks_for(self, :after, #{method_id.inspect}, result)
-            return result
+            res = nil
+            run_callbacks(:before, #{method_id.inspect})
+            run_callbacks(:around, #{method_id.inspect}) { res = __PRISTINE__(#{method_id.inspect}, *args, &block) }
+            run_callbacks(:after,  #{method_id.inspect}, res)
+            res
           end
         end
         
-        def #{safe_method_id}_without_callbacks(*args, &block)
+        def #{safe_method_id}(*args, &block)
           __PRISTINE__(#{method_id.inspect}, *args, &block)
         end
       EOS
@@ -68,25 +71,34 @@ module BootyCall
       def callback_cache
         @callback_cache || superclass.callback_cache
       end
-      
-      def run_callbacks_for(target, position, method_id, *results)
-        callbacks = callback_cache[position][method_id.to_sym]
-        
-        handler = proc do |fn|
-          fn.is_a?(Proc) ? fn : begin
-            target.method(fn).arity.abs == results.length ?
-              proc { send(fn, *results) } :
-              proc { send(fn) }
-          end
-        end
-        
-        callbacks.empty? ? true : callbacks.map { |fn|
-          target.instance_exec(*results, &handler.call(fn))
-        }.all?
-      end
     end
     
     module InstanceMethods
+      def callbacks_for(position, method_id, *results, &block)
+        callbacks = self.class.callback_cache[position][method_id.to_sym]
+        
+        if callbacks.empty?
+          block ? instance_eval(&block) : true
+        else
+          callbacks.map { |callback|
+            if callback.is_a?(Proc)
+              instance_exec(*results.unshift?(block), &callback)
+            else
+              method(callback).arity_match?(results) ?
+                send(callback, *results, &block) :
+                send(callback, &block)
+            end
+          }.all?
+        end
+      end
+      
+      def run_callbacks(position, method_id, *args, &block)
+        callbacks_for(position, method_id, *args, &block).tap do |result|
+          # Halt method propagation if before callbacks return false
+          throw(method_id, false) if position.eql?(:before) and result.eql?(false)
+        end
+      end
+      
       def __PRISTINE__(method_id, *args, &block)
         if method = self.class.pristine_cache[method_id]
           method.bind(self).call(*args, &block)

data/lib/booty_call/hook.rb

@@ -1,4 +1,8 @@
 module BootyCall
+  def self.included(klass)
+    klass.send(:include, Hook)
+  end
+  
   module Hook
     def self.included(klass)
       klass.class_eval do
@@ -18,15 +22,29 @@ module BootyCall
         callback(:after, method_id, *args, &block)
       end
       
+      def around(method_id, *args, &block)
+        callback(:around, method_id, *args, &block)
+      end
+      
       def observe(method_id, options={}, &block)
         observer = options[:meta] ? @meta_introspector : @introspector
         observer.observe(method_id, options, &block)
       end
       
       def callback(position, method_id, *args, &block)
-        @introspector.defined_methods.include?(method_id) ?
-          @callbacker.send(position, method_id, *args, &block) :
-          observe(method_id) { send(position, method_id, *args, &block) }
+        case method_id
+        when Regexp
+          return if @introspector.observing?(method_id)
+          observe(method_id, :times => :all) { |m| callback(position, m, *(args << block)) }
+          @introspector.defined_methods \
+            .select { |m| m.to_s =~ method_id } \
+            .reject { |m| @introspector.observing?(m) } \
+            .each { |m| send(position, m, *args, &block) }
+        when Symbol
+          @introspector.has_method?(method_id) ?
+            @callbacker.send(position, method_id, *args, &block) :
+            observe(method_id) { send(position, method_id, *(args << block)) }
+        end
       end
     end
   end

data/lib/booty_call/introspector.rb

@@ -7,42 +7,52 @@ module BootyCall
       @observed_methods = { }
     end
     
+    def observe(method_id, options={}, &block)
+      observe_klass!
+      @observed_methods[method_id] ||= ObservedMethod.new(method_id, options)
+      @observed_methods[method_id].push(block) if block_given?
+    end
+    
     def observe_klass!
       @observed ||= begin
-        this = self
-        hook = options[:meta] ? :singleton_method_added : :method_added
-        klass.meta_def(hook) do |m|
-          this.check_method(m)
-        end; true
+        name = options[:meta] ? :singleton_method_added : :method_added
+        install_hook(name) or true
       end
     end
     
-    def observing?(method_id)
-      not not @observed_methods[method_id]
+    def defined_methods
+      (klass.instance_methods - Object.instance_methods).map(&:to_sym)
     end
     
-    def observe(method_id, options={}, &block)
-      observe_klass!
-      @observed_methods[method_id] ||= ObservedMethod.new(method_id, options)
-      @observed_methods[method_id].push(block) if block_given?
+    def has_method?(method_id)
+      klass.instance_method(method_id) rescue false
     end
     
-    def defined_methods
-      (klass.instance_methods - Object.instance_methods).map(&:to_sym)
+    def observing?(method_id)
+      not not @observed_methods[method_id]
     end
     
+    private
+    
+    def install_hook(name)
+      this = self
+      klass.meta_def(name) do |m|
+        this.send :check_method, m
+      end
+    end
+
     def check_method(sym)
       @observed_methods.each do |method_id, observer|
-        stop_observing(method_id) do
+        without_observers(method_id) do
           observer.match(sym)
           observer.valid?
         end
       end
     end
     
-    def stop_observing(method_id, &block)
+    def without_observers(method_id, &block)
       @observed_methods.delete(method_id).tap do |observer|
-        @observed_methods[method_id] = observer if block.try(:call, observer)
+        @observed_methods[method_id] = observer if block[observer]
       end
     end
   end

data/lib/booty_call/observed_method.rb

@@ -4,28 +4,33 @@ module BootyCall
     
     def initialize(method_id, options={})
       @method_id = method_id
-      @callbacks = []
+      @handlers = []
       @count = 0
       @times = options[:times] || 1
     end
   
     def match(sym)
       return unless case method_id
-      when Symbol then valid?
+      when Symbol then valid? and method_id === sym
       when Regexp then valid? and method_id.try(:match, sym.to_s)
       else ; nil
       end
-      @callbacks.each { |fn| fn.call(sym) }
+      @handlers.each { |fn| fn[sym] }
       @count += 1
     end
     
     def valid?
-      @times.to_s.match(/^(inf|any|all|every)/) or @count < @times
+      if @times.to_s.match(/^(inf|any|all|every)/)
+        def self.valid?; true end
+        true # memoizing the result
+      else
+        @count < @times
+      end
     end
   
     def push(*args)
-      @callbacks += args
-      @callbacks.tap.compact!.uniq!
+      @handlers += args
+      @handlers.tap.compact!.uniq!
     end
   end
 end

data/lib/core_ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+  def unshift?(item)
+    tap do
+      unshift(item) if item
+    end
+  end
+end

data/lib/core_ext/method.rb

@@ -0,0 +1,5 @@
+class Method
+  def arity_match?(collection)
+    arity == -1 or arity == collection.length
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nakajima-booty-call
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -37,6 +37,9 @@ files:
 - lib/booty_call/callbacker.rb
 - lib/booty_call/introspector.rb
 - lib/booty_call/observed_method.rb
+- lib/core_ext
+- lib/core_ext/array.rb
+- lib/core_ext/method.rb
 has_rdoc: false
 homepage: http://github.com/nakajima/booty-call
 post_install_message: