hooks 0.1 → 0.1.1

data/README.rdoc

@@ -5,12 +5,10 @@
 
 == Introduction
 
-Hooks lets you define hooks declaratively in your ruby class. You can add callbacks to your hook, which will be 
+_Hooks_ lets you define hooks declaratively in your ruby class. You can add callbacks to your hook, which will be 
 run as soon as _you_ run the hook!
 
-It's almost like ActiveSupport::Callbacks but 76,6% less complex.
-
-Instead, it is not more than 80 lines of code, one method compilation, no +method_missing+ and no magic.
+It's almost like ActiveSupport::Callbacks but 76,6% less complex. Instead, it is not more than 60 lines of code, one method compilation, no +method_missing+ and no magic.
 
 
 == Example
@@ -35,7 +33,7 @@ Now you can add callbacks to your hook declaratively in your class.
       puts "Hell, yeah!"
     end
  
-Running the callbacks happens on instances. It will run the block and +#have_a_desert+ from above.
+Running the callbacks happens on instances. It will run the block and #have_a_desert from above.
 
   cat.run_hook :after_dinner
   # => Ice cream!
@@ -73,9 +71,13 @@ The current gem requires
 * active_support 2.3.x
 
 
+== Anybody using it?
+
+* Hooks is already used in [Apotomo:http://github.com/apotonick/apotomo], a hot widget framework for Rails. Look at +lib/apotomo/widget.rb+ for examples and into +lib/apotomo/tree_node.rb+ to learn how modules-driven code might benefit from hooks.
+
 == Similar libraries
 
-* http://github.com/nakajima/aspectory/tree/master/lib/aspectory/
+* http://github.com/nakajima/aspectory
 * http://github.com/auser/backcall
 * http://github.com/mmcgrana/simple_callbacks
 

data/Rakefile

@@ -13,8 +13,8 @@ Rake::TestTask.new(:test) do |test|
 end
 
 require 'jeweler'
-$:.unshift File.dirname(__FILE__) # add current dir to LOAD_PATHS
-require 'lib/hooks'
+$:.unshift File.dirname(__FILE__)+"/lib" # add current dir to LOAD_PATHS
+require 'hooks'
 
 Jeweler::Tasks.new do |spec|
   spec.name         = "hooks"
@@ -26,8 +26,6 @@ Jeweler::Tasks.new do |spec|
   spec.email        = "apotonick@gmail.com"
 
   spec.files = FileList["[A-Z]*", File.join(*%w[{lib} ** *]).to_s]
-  
-  spec.add_dependency 'activesupport', '>= 2.3.0'
 end
 
 Jeweler::GemcutterTasks.new

data/lib/hooks.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/class/inheritable_attributes.rb'
+require "hooks/inheritable_attribute"
 
 # Almost like ActiveSupport::Callbacks but 76,6% less complex.
 #
@@ -16,9 +16,10 @@ require 'active_support/core_ext/class/inheritable_attributes.rb'
 #
 #   cat.run_hook :after_dinner
 module Hooks
-  VERSION = "0.1"
+  VERSION = "0.1.1"
   
   def self.included(base)
+    base.extend InheritableAttribute
     base.extend ClassMethods
   end
   
@@ -30,21 +31,41 @@ module Hooks
       define_hook_writer(name, accessor_name)
     end
     
-    private
-      def define_hook_writer(hook, accessor_name)
-        instance_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          def #{hook}(method=nil, &block)
-            callback = block_given? ? block : method
-            #{accessor_name} << callback
-          end
-        RUBY_EVAL
-      end
-      
-      def setup_hook_accessors(accessor_name)
-        class_inheritable_array(accessor_name, :instance_writer => false)
-        send("#{accessor_name}=", [])  # initialize ivar.
+    # Like Hooks#run_hook but for the class. Note that +:callbacks+ must be class methods.
+    #
+    # Example:
+    #
+    # class Cat
+    #   after_eight :grab_a_beer
+    #   
+    #   def self.grab_a_beer(*) # and so on...
+    # 
+    # where <tt>Cat.run_hook :after_eight</tt> will call the class method +grab_a_beer+.
+    def run_hook(name, *args)
+      run_hook_for(name, self, *args)
+    end    
+    
+    def run_hook_for(name, scope, *args)
+      send("_#{name}_callbacks").each do |callback|
+        scope.send(callback, *args) and next if callback.kind_of? Symbol
+        callback.call(*args) 
       end
-      
+    end
+    
+  private
+    def define_hook_writer(hook, accessor_name)
+      instance_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{hook}(method=nil, &block)
+          callback = block_given? ? block : method
+          #{accessor_name} << callback
+        end
+      RUBY_EVAL
+    end
+    
+    def setup_hook_accessors(accessor_name)
+      inheritable_attr(accessor_name)
+      send("#{accessor_name}=", [])  # initialize ivar.
+    end  
   end
   
   # Runs the callbacks (method/block) for the specified hook +name+. Additional arguments will 
@@ -59,9 +80,6 @@ module Hooks
   #   desert("i want ice cream!")
   #   block.call("i want ice cream!")
   def run_hook(name, *args)
-    self.class.send("_#{name}_callbacks").each do |callback|
-      send(callback, *args) and next if callback.kind_of? Symbol
-      callback.call(*args) 
-    end
+    self.class.run_hook_for(name, self, *args)
   end
 end

data/lib/hooks/inheritable_attribute.rb

@@ -0,0 +1,33 @@
+module Hooks
+  module InheritableAttribute
+    # Creates an inheritable attribute with accessors in the singleton class. Derived classes inherit the
+    # attributes. This is especially helpful with arrays or hashes that are extended in the inheritance
+    # chain. Note that you have to initialize the inheritable attribute.
+    #
+    # Example:
+    #
+    #   class Cat
+    #     inheritable_attr :drinks
+    #     self.drinks = ["Becks"]
+    #
+    #   class Garfield < Cat
+    #     self.drinks << "Fireman's 4"
+    #
+    # and then, later
+    #
+    #   Cat.drinks      #=> ["Becks"]
+    #   Garfield.drinks #=> ["Becks", "Fireman's 4"]
+    def inheritable_attr(name)
+      instance_eval %Q{
+        def #{name}=(v)
+          @#{name} = v
+        end
+        
+        def #{name}
+          return @#{name} unless superclass.respond_to?(:#{name})
+          @#{name} ||= superclass.#{name}.clone # only do this once.
+        end
+      }
+    end
+  end  
+end

data/test/hooks_test.rb

@@ -31,9 +31,16 @@ class HooksTest < ActiveSupport::TestCase
         @klass.after_eight do true; end
         assert @klass._after_eight_callbacks.first.kind_of? Proc
       end
+      
+      should "be inherited" do
+        @klass.after_eight :dine
+        subklass = Class.new(@klass)
+        
+        assert_equal [:dine], subklass._after_eight_callbacks
+      end
     end
     
-    context "Hooks.run_hook"do
+    context "Hooks#run_hook" do
       should "run without parameters" do
         @mum.instance_eval do
           def a; executed << :a; end
@@ -59,6 +66,32 @@ class HooksTest < ActiveSupport::TestCase
         
         assert_equal [2, 0], @mum.executed
       end
-    end  
+    end
+    
+    context "in class context" do
+      should "run a callback block" do
+        executed = []
+        @klass.after_eight do
+          executed << :klass
+        end
+        @klass.run_hook :after_eight
+        
+        assert_equal [:klass], executed
+      end
+      
+      should "run a class methods" do
+        executed = []
+        @klass.instance_eval do
+          after_eight :have_dinner
+          
+          def have_dinner(executed)
+            executed << :have_dinner
+          end
+        end
+        @klass.run_hook :after_eight, executed
+        
+        assert_equal [:have_dinner], executed
+      end
+    end
   end
 end

data/test/inheritable_attribute_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class HooksTest < ActiveSupport::TestCase
+  context "Hooks.define_hook" do
+    setup do
+      @klass = Class.new(Object) do
+        extend Hooks::InheritableAttribute
+      end
+      
+      @mum = @klass.new
+      @klass.inheritable_attr :drinks
+    end
+    
+    should "provide a reader with inherited attributes, already" do
+      assert_equal nil, @klass.drinks
+    end
+    
+    should "provide an attribute copy in subclasses" do
+      @klass.drinks = []
+      assert @klass.drinks.object_id != Class.new(@klass).drinks.object_id
+    end
+    
+    should "provide a writer" do
+      @klass.drinks = [:cabernet]
+      assert_equal [:cabernet], @klass.drinks
+    end
+    
+    should "inherit attributes" do
+      @klass.drinks = [:cabernet]
+      
+      subklass_a = Class.new(@klass)
+      subklass_a.drinks << :becks
+      
+      subklass_b = Class.new(@klass)
+      
+      assert_equal [:cabernet],         @klass.drinks
+      assert_equal [:cabernet, :becks], subklass_a.drinks
+      assert_equal [:cabernet],         subklass_b.drinks
+    end
+    
+    should "not inherit attributes if we set explicitely" do
+      @klass.drinks = [:cabernet]
+      subklass = Class.new(@klass)
+      
+      subklass.drinks = [:merlot] # we only want merlot explicitely.
+      assert_equal [:merlot], subklass.drinks # no :cabernet, here
+    end
+  end
+end

metadata

@@ -5,7 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  version: "0.1"
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -13,24 +14,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-24 00:00:00 +02:00
+date: 2010-10-03 00:00:00 +02:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        - 0
-        version: 2.3.0
-  type: :runtime
-  version_requirements: *id001
+dependencies: []
+
 description: Declaratively define hooks, add callbacks and run them with the options you like.
 email: apotonick@gmail.com
 executables: []
@@ -45,6 +32,8 @@ files:
 - README.rdoc
 - Rakefile
 - lib/hooks.rb
+- lib/hooks/inheritable_attribute.rb
+- test/inheritable_attribute_test.rb
 - test/test_helper.rb
 - test/hooks_test.rb
 has_rdoc: true
@@ -80,5 +69,6 @@ signing_key:
 specification_version: 3
 summary: Generic hooks with callbacks for Ruby.
 test_files: 
+- test/inheritable_attribute_test.rb
 - test/test_helper.rb
 - test/hooks_test.rb