booty-call 0.0.5

data/lib/booty-call.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/booty_call.rb'

data/lib/booty_call.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH << File.dirname(__FILE__) + '/booty_call'
+
+module BootyCall
+  VERSION = '0.0.5'
+end
+
+require 'rubygems'
+require 'nakajima'
+require 'callbacker'
+require 'observed_method'
+require 'introspector'
+require 'hook'

data/lib/booty_call/callbacker.rb

@@ -0,0 +1,115 @@
+module BootyCall
+  class Callbacker
+    attr_reader :klass
+    
+    def initialize(klass)
+      @klass = klass
+      extend_klass
+    end
+    
+    def before(method_id, *symbols, &block)
+      add_callback(:before, method_id, *symbols, &block)
+    end
+    
+    def after(method_id, *symbols, &block)
+      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([]), :around => Hash.new([]) }
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+    
+    def add_callback(position, method_id, *symbols, &block)
+      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
+          redefine_method method_id
+        end
+      end
+    end
+    
+    def redefine_method(method_id)
+      safe_method_id = method_id.to_s
+      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
+            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}(*args, &block)
+          __PRISTINE__(#{method_id.inspect}, *args, &block)
+        end
+      EOS
+    end
+    
+    module ClassMethods
+      def pristine_cache
+        @pristine_cache || superclass.pristine_cache
+      end
+      
+      def callback_cache
+        @callback_cache || superclass.callback_cache
+      end
+      
+      def run_callbacks_for(target, position, method_id, *results, &block)
+        callbacks = callback_cache[position][method_id.to_sym]
+        
+        handle = proc do |fn|
+          if fn.is_a?(Proc)
+            block ? proc { instance_exec(block, &fn) } : fn
+          else
+            target.method(fn).arity.abs == results.length ?
+              proc { send(fn, *results, &block) } :
+              proc { send(fn, &block) }
+          end
+        end
+        
+        cancel = proc do
+          block ? target.instance_eval(&block) : true
+        end
+        
+        callbacks.empty? ? cancel[block] : callbacks.map { |fn|
+          target.instance_exec(*results, &handle[fn])
+        }.all?
+      end
+    end
+    
+    module InstanceMethods
+      def run_callbacks(position, method_id, *args, &block)
+        self.class.run_callbacks_for(self, 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)
+        else
+          raise NoMethodError, "No method named #{method_id.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/booty_call/hook.rb

@@ -0,0 +1,51 @@
+module BootyCall
+  def self.included(klass)
+    klass.send(:include, Hook)
+  end
+  
+  module Hook
+    def self.included(klass)
+      klass.class_eval do
+        extend(ClassMethods)
+        @callbacker = BootyCall::Callbacker.new(self)
+        @introspector = BootyCall::Introspector.new(self)
+        @meta_introspector = BootyCall::Introspector.new(self, :meta => true)
+      end
+    end
+    
+    module ClassMethods
+      def before(method_id, *args, &block)
+        callback(:before, method_id, *args, &block)
+      end
+      
+      def after(method_id, *args, &block)
+        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)
+        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
+end

data/lib/booty_call/introspector.rb

@@ -0,0 +1,59 @@
+module BootyCall
+  class Introspector
+    attr_reader :klass, :options
+    
+    def initialize(klass, options={})
+      @klass, @options = klass, options
+      @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
+        name = options[:meta] ? :singleton_method_added : :method_added
+        install_hook(name) or true
+      end
+    end
+    
+    def defined_methods
+      (klass.instance_methods - Object.instance_methods).map(&:to_sym)
+    end
+    
+    def has_method?(method_id)
+      klass.instance_method(method_id) rescue false
+    end
+    
+    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|
+        without_observers(method_id) do
+          observer.match(sym)
+          observer.valid?
+        end
+      end
+    end
+    
+    def without_observers(method_id, &block)
+      @observed_methods.delete(method_id).tap do |observer|
+        @observed_methods[method_id] = observer if block[observer]
+      end
+    end
+  end
+end

data/lib/booty_call/observed_method.rb

@@ -0,0 +1,36 @@
+module BootyCall
+  class ObservedMethod
+    attr_reader :method_id
+    
+    def initialize(method_id, options={})
+      @method_id = method_id
+      @handlers = []
+      @count = 0
+      @times = options[:times] || 1
+    end
+  
+    def match(sym)
+      return unless case method_id
+      when Symbol then valid? and method_id === sym
+      when Regexp then valid? and method_id.try(:match, sym.to_s)
+      else ; nil
+      end
+      @handlers.each { |fn| fn[sym] }
+      @count += 1
+    end
+    
+    def valid?
+      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)
+      @handlers += args
+      @handlers.tap.compact!.uniq!
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: booty-call
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nakajima-nakajima
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: patnakajima@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/booty_call
+- lib/booty-call.rb
+- lib/booty_call.rb
+- lib/booty_call/hook.rb
+- lib/booty_call/callbacker.rb
+- lib/booty_call/introspector.rb
+- lib/booty_call/observed_method.rb
+has_rdoc: false
+homepage: http://github.com/nakajima/booty-call
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.0
+signing_key: 
+specification_version: 2
+summary: Callbacks for your Ruby
+test_files: []
+