callbacks 0.0.2 → 0.0.3

data/History.txt

@@ -10,3 +10,11 @@
   * API still not stable
   * Callbacks now picks up "before#{callback}" and "after_#{callback}" instance methods automatically
   * Some documentation added
+
+== 0.0.3 / 2008-10-14
+
+ * Callbacks per object instance (singleton callbacks)
+ * Shuffled some code between instancemethods and classmethods
+ * Some more tests
+ * API still not stable
+ * Some documentation added

data/Manifest.txt

@@ -26,4 +26,5 @@ tasks/test.rake
 test/profile.rb
 test/test_callbacks.rb
 test/test_helper.rb
+test/test_singleton_callbacks.rb
 test/tester_class.rb

data/README.txt

@@ -22,7 +22,7 @@ This package makes it simple to add callbacks a.k.a. "hooks" to ruby classes
     Object.send(:include, Callbacks)
     Object.add_callback_methods :inspect
     Object.before_inspect do
-    print "Going to inspect #{self.class}\n"
+      print "Going to inspect #{self.class}\n"
     end
 
     o = Object.new

data/Rakefile

@@ -9,6 +9,9 @@ require 'callbacks'
 
 task :default => 'spec:run'
 
+SUDO = ''
+HAVE_GIT = true
+
 PROJ.name = 'callbacks'
 PROJ.authors = 'Leon Bogaert'
 PROJ.email = 'leon@vanutsteen.nl'

data/Version.txt

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/callback.rb

@@ -2,14 +2,14 @@ class Callback
   attr_accessor :method, :input
   attr_writer :proc
   ACCEPTED = [Symbol, Proc, String, Method]
+  ACCEPTANCE_ERROR = "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method. %s is none of those."
   
   def initialize(method, input, &block)
-    #self.method = method
     self.input = input
     self.input = block if block_given?
     
     if not ACCEPTED.include? self.input.class
-      raise "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method. #{self.input} is none of those."
+      raise ACCEPTANCE_ERROR % self.input.class
     end
   end
   
@@ -25,19 +25,20 @@ class Callback
     case self.input
     when String
       Proc.new { eval(self.input) }
-    #else if self.input.respond_to?(self.method)
-    #    Proc.new { callback.send(method, self) }
-    #  end
+    else
+      nil
     end
   end
   
   def generate_block
     case self.input
     when Symbol
-      symbol = self.input.to_sym
-      Proc.new { self.send(symbol) }
+      instance_method = self.input.to_sym
+      Proc.new { self.send(instance_method) }
     when Proc, Method
       self.input
+    else
+      nil
     end
   end
 end

data/lib/callbacks.rb

@@ -1,20 +1,34 @@
 #Idea stolen from rails/activerecord
 module Callbacks
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  
   require 'observer'
-  require 'ext/metaid.rb'
+  require "#{PATH}/ext/metaid.rb"
   require 'callbackchain.rb'
   require 'instancemethods.rb'
   require 'classmethods.rb'
   require 'callback.rb'
-
+  
   #Sets all things right
   def self.included(base) #:nodoc:
-    base.extend Observable #why?
     base.extend Callbacks::ClassMethods
     base.send(:include, Callbacks::InstanceMethods)
   end
+  
+  def self.version
+    VERSION
+  end
+
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+  end
+
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, *args)
+  end
+  
 end
 
 #TODO: add aliases like add_hook(), callbacks(), et cetera
-#TODO: feature to add hooks/callbacks to instances instead of only classes
 #TODO: make all of the activesupport features/tests work

data/lib/classmethods.rb

@@ -1,7 +1,7 @@
 module Callbacks
   module ClassMethods
     
-    def callback_methods
+    def callback_methods  
       #Use one @, else it gets stored in the module and then it will be avaiable in every class that uses callback
       @callback_methods ||= []
     end 
@@ -30,15 +30,38 @@ module Callbacks
       self.callback_methods.delete(method.to_sym)
     end
     
+    #TODO: make this nicer      
+    def callback_actions_for(method, type)
+      if self.callback_actions[method].nil?
+        callback_actions = []
+      else
+        callback_actions = self.callback_actions[method][type] ||= []
+      end
+      
+#Removed this because this didn't work
+#callback_actions_for is called four times with every callback method:
+# before, before metaclass, after, after metaclass
+# And a class and metaclass both now the #{type}_#{method} method
+# So it got called twice
+#      if self.instance_methods.include?("#{type}_#{method}")
+#        if not callback_actions.include? "#{type}_#{method}".to_sym
+#          callback = self.add_callback_action(type, method, "#{type}_#{method}".to_sym)
+#          callback_actions << callback
+#        end
+#      end
+      
+      return callback_actions 
+    end
+    
     def build_callback_methods(method)
       build_before_callback_method(method)
       build_after_callback_method(method)
       
       class_eval <<-"end_eval"
         def #{method}_with_callbacks
-          trigger_callback_actions(:#{method}, :before)
+          self.trigger_callback_actions(:#{method}, :before) 
           retval = self.send("#{method}_without_callbacks")
-          trigger_callback_actions(:#{method}, :after)
+          self.trigger_callback_actions(:#{method}, :after)
           return retval
         end
       end_eval
@@ -63,26 +86,28 @@ module Callbacks
       ca[method][type] << callback
       return callback
     end
-    
-    private
+   
     def build_before_callback_method(method)
-      instance_eval <<-"end_eval"
-      
-          def before_#{method}(*callbacks, &block)
-            add_callback_action :before, :#{method}, *callbacks, &block
-          end
-
-      end_eval
+      build_callback_method(:before, method)
     end
     
     def build_after_callback_method(method)
-      instance_eval <<-"end_eval"
+      build_callback_method(:after, method)
+    end
+    
+    def build_callback_method(type, method)
+      method = <<-"end_eval"
+
+#          def #{type}_#{method}(*callbacks, &block)
+#            self.class.add_callback_action(:#{type}, :#{method}, *callbacks, &block)
+#          end
 
-          def after_#{method}(*callbacks, &block)
-            add_callback_action :after, :#{method}, *callbacks, &block
+          def self.#{type}_#{method}(*callbacks, &block)
+            add_callback_action(:#{type}, :#{method}, *callbacks, &block)
           end
 
       end_eval
+      module_eval(method)
     end
     
   end

data/lib/instancemethods.rb

@@ -1,49 +1,41 @@
 module Callbacks
   module InstanceMethods
     
-    def callback_actions(show_classvars = true)
-      callback_actions = self.class_callback_actions
-      #return self.instance_callbacks if show_classvars == false
-      #return self.class_callback_actions + self.instance_callback_actions if show_classvars == true
+    def trigger_callback_actions(method, type)
+      trigger_class_callback_actions(method, type) if self.class.respond_to?(:callback_actions_for)
+      trigger_metaclass_callback_actions(method, type) if self.metaclass.respond_to?(:callback_actions_for)
+      #Should I return something?
     end
     
-    def callback_actions_for(method, type)  
-      #Do the rescue if [method] does not exist (nil), [type] will fail
-      begin
-        callback_actions = self.callback_actions[method][type] ||= []
-      rescue NoMethodError
-        callback_actions = []
+    #TODO: do something with a block or proc or something :p
+    #Instead of self.class/self.metaclass
+    def trigger_class_callback_actions(method, type)
+      self.class.callback_actions_for(method, type).each do |callback|
+        
+        if callback.block
+          self.instance_eval(&callback.block)
+        else
+          callback.proc.call
+        end
       end
       
-      #If the before/after_ method exists, and it is not already added,
-      # add it!
-      #Dit kan mooier!
+      #I'm not happy with this...
       if self.respond_to?("#{type}_#{method}")
-        if not callback_actions.include? "#{type}_#{method}".to_sym
-          #callback_actions << Callback.new(method, "#{type}_#{method}".to_sym)
-          callback = self.class.add_callback_action(type, method, "#{type}_#{method}".to_sym)
-          callback_actions << callback
-        end
+        self.send("#{type}_#{method}")
       end
-      
-      return callback_actions
     end
     
-    def class_callback_actions
-      self.class.callback_actions
-    end
-
-    def trigger_callback_actions(method, type)
-      
-      self.callback_actions_for(method, type).each do |callback|
+    def trigger_metaclass_callback_actions(method, type)
+      self.metaclass.callback_actions_for(method, type).each do |callback|
+        
         if callback.block
-          return instance_eval(&callback.block)
+          return self.instance_eval(&callback.block)
         else
           callback.proc.call
         end
       end
-    
       #Should I return something?
     end
-  end
-end
+
+  end #InstanceMethods
+end #Callbacks

data/test/test_callbacks.rb

@@ -153,21 +153,6 @@ class CallbacksTest < Test::Unit::TestCase
     assert_equal ['before_exit'], $tests_run
   end
   
-#  def test_should_not_raise_error_when_method_not_exist
-#    assert_nothing_raised do 
-#      Tester.add_callback_methods :doesnotexist
-#    end
-#  end
-  
-#  def test_no_method_callback_should_not_add_method
-#    Tester.add_callback_methods :nomethodcallback
-#    t = Tester.new
-#    
-#    assert_raise NameError do 
-#      t.nomethodcallback
-#    end
-#  end
-  
   def test_should_use_defined_methods_in_class_as_callback
     Tester.add_callback_methods :callback_with_defined_method
     t = Tester.new
@@ -185,16 +170,27 @@ class CallbacksTest < Test::Unit::TestCase
     end
   end
   
-  #  def test_callbacks_created_in_class_should_be_vissible_in_instance
-  #    Tester.add_callback_methods :boot, :exit
-  #    t = Tester.new
-  #    assert_equal [:boot, :exit], t.callbacks
-  #  end
+  def test_callbacks_created_in_class_should_be_vissible_in_instance
+    Tester.add_callback_methods :boot, :exit
+    Tester.new
+    assert_equal [:boot, :exit], Tester.callback_methods
+  end
+  
+  def test_predefined_callback_methods_should_run_once
+    Tester.add_callback_methods :callback_with_defined_method
+    t = Tester.new
+    t.callback_with_defined_method
+    assert $tests_run.length == 1
+  end
   
-  #  def test_callback_created_in_instance_should_not_be_vissible_in_class
-  #    t = Tester.new
-  #    t.add_callback :boot
-  #    assert_equal [], Tester.callbacks
-  #  end
+  def test_method_defined_after_include_should_work
+    Tester.send(:define_method, :after_include) do
+      $tests_run << 'after_include'
+    end
+    Tester.add_callback_methods :after_include
+    t = Tester.new
+    t.after_include
+    assert $tests_run.length == 1
+  end
   
 end

data/test/test_singleton_callbacks.rb

@@ -0,0 +1,85 @@
+class SingletonCallbacksTest < Test::Unit::TestCase
+  attr_accessor :tester
+  
+  def setup
+    Object.send(:remove_const, :Tester) if defined? Tester
+    load 'test/tester_class.rb'
+    self.tester = Tester.new
+    $tests_run = []
+  end
+  
+  def test_should_create_instance_methods
+    tester.metaclass.add_callback_methods :boot
+    
+    assert_nothing_raised { tester.boot }
+    assert_nothing_raised { tester.boot_without_callbacks }
+    assert_nothing_raised { tester.metaclass.before_boot('p "ehlo"') }
+    assert_nothing_raised { tester.metaclass.after_boot('p "ehlo"') }
+  end
+  
+  def test_class_should_create_before_and_after_method
+    tester.metaclass.add_callback_methods :boot
+    methods = tester.metaclass.methods.grep(/(^before_.+$|^after_.+$)/)
+    
+    assert methods.include?('before_boot')
+    assert methods.include?('after_boot')
+  end
+  
+  def test_callback_created_in_instance_should_not_be_vissible_in_class
+    tester.metaclass.add_callback_methods :boot
+    assert_equal [], Tester.callback_methods
+  end
+    
+  def test_callback_created_in_class_should_be_vissible_in_instance
+    #This ain't gonna work...
+    #I don't know how to get the variables
+    Tester.add_callback_methods :boot
+    t = Tester.new
+    assert_equal [:boot], t.metaclass.callback_methods
+  end
+    
+  def test_callbacks_created_in_class_and_instance_should_both_be_run
+    Tester.add_callback_methods :boot
+    Tester.before_boot do
+      $tests_run << 'before_boot'
+    end
+      
+    tester.metaclass.after_boot do
+      $tests_run << 'after_boot'
+    end
+      
+    tester.boot
+      
+    assert $tests_run.include?('before_boot')
+    assert $tests_run.include?('after_boot')
+  end
+  
+  def test_callbacks_created_in_class_and_instance_should_both_be_run_2
+    Tester.add_callback_methods :boot
+    Tester.before_boot do
+      $tests_run << 'before_boot'
+    end
+      
+    tester.metaclass.before_boot do
+      $tests_run << 'before_boot_2'
+    end
+      
+    tester.boot
+      
+    assert $tests_run.include?('before_boot')
+    assert $tests_run.include?('before_boot_2')
+  end
+  
+  def test_singleton_callbacks_on_clean_object
+    a = Object.new
+    a.metaclass.send(:include, Callbacks)
+    a.metaclass.add_callback_methods :to_s
+    a.metaclass.before_to_s do
+      $tests_run << 'clean!'
+    end
+    a.to_s #and see the magic happen
+    
+    assert $tests_run.length == 1
+    assert $tests_run[0] == 'clean!'
+  end
+end

data/test/tester_class.rb

@@ -2,6 +2,7 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'callbacks'
 
 class Tester
+  include Callbacks
 
   def boot
     return "booting"
@@ -27,6 +28,5 @@ class Tester
   def fill_globalvar_tests_run
     $tests_run << 'fill_globalvar_tests_run'
   end
-
-  include Callbacks
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: callbacks
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Leon Bogaert
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-28 00:00:00 +02:00
+date: 2008-10-14 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -51,6 +51,7 @@ files:
 - test/profile.rb
 - test/test_callbacks.rb
 - test/test_helper.rb
+- test/test_singleton_callbacks.rb
 - test/tester_class.rb
 has_rdoc: true
 homepage: www.vanutsteen.nl
@@ -76,10 +77,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: callbacks
-rubygems_version: 1.2.0
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: This package makes it simple to add callbacks a
 test_files: 
 - test/test_helper.rb
+- test/test_singleton_callbacks.rb
 - test/test_callbacks.rb