module-cluster 2.0.3 → 2.0.4

data/lib/module/cluster/instance_controller/instance_controller_interface.rb

@@ -115,7 +115,7 @@ module ::Module::Cluster::InstanceController::InstanceControllerInterface
   def before_extend_subclass_proxy
 
     return @before_extend_subclass_proxy ||= self.class::MultipleHookControllerProxy.new( :before_extend_subclass,
-                                                                                          before_include_controller,
+                                                                                          before_extend_controller,
                                                                                           subclass_controller )
 
   end

data/lib/module/cluster/instance_controller/multiple_hook_controller_proxy.rb

@@ -40,10 +40,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   # 
   # @return [Module::Cluster::InstanceController::HookController] self
   #
-  def include( *modules )
+  def include( *modules, & block )
     
     @hook_controllers.each do |this_hook_controller|
-      this_hook_controller.include( *modules )
+      this_hook_controller.include( *modules, & block )
     end
 
     return self
@@ -67,10 +67,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   # 
   # @return [Module::Cluster::InstanceController::HookController] self
   #
-  def extend( *modules )
+  def extend( *modules, & block )
 
     @hook_controllers.each do |this_hook_controller|
-      this_hook_controller.extend( *modules )
+      this_hook_controller.extend( *modules, & block )
     end
 
     return self
@@ -94,10 +94,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   # 
   # @return [Module::Cluster::InstanceController::HookController] self
   #
-  def include_and_extend( *modules )
+  def include_and_extend( *modules, & block )
     
     @hook_controllers.each do |this_hook_controller|
-      this_hook_controller.include_and_extend( *modules )
+      this_hook_controller.include_and_extend( *modules, & block )
     end
 
     return self
@@ -121,10 +121,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   # 
   # @return [Module::Cluster::InstanceController::HookController] self
   #
-  def extend_and_include( *modules )
+  def extend_and_include( *modules, & block )
     
     @hook_controllers.each do |this_hook_controller|
-      this_hook_controller.extend_and_include( *modules )
+      this_hook_controller.extend_and_include( *modules, & block )
     end
 
     return self
@@ -172,9 +172,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def before_extend( *modules )
+  def before_extend( *modules, & block )
     
-    return chain_proxy.before_extend( *modules )
+    return chain_proxy.before_extend( *modules, & block )
     
   end
 
@@ -196,9 +196,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def before_include( *modules )
+  def before_include( *modules, & block )
     
-    return chain_proxy.before_include( *modules )
+    return chain_proxy.before_include( *modules, & block )
     
   end
 
@@ -221,9 +221,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def before_include_or_extend( *modules )
+  def before_include_or_extend( *modules, & block )
 
-    return chain_proxy.before_include_or_extend( *modules )
+    return chain_proxy.before_include_or_extend( *modules, & block )
     
   end
   
@@ -247,9 +247,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def after_include( *modules )
+  def after_include( *modules, & block )
 
-    return chain_proxy.after_include( *modules )
+    return chain_proxy.after_include( *modules, & block )
     
   end
 
@@ -271,9 +271,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def after_extend( *modules )
+  def after_extend( *modules, & block )
 
-    return chain_proxy.after_extend( *modules )
+    return chain_proxy.after_extend( *modules, & block )
     
   end
 
@@ -296,9 +296,9 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Chain Proxy for chained declarations.
   #
-  def after_include_or_extend( *modules )
+  def after_include_or_extend( *modules, & block )
     
-    return chain_proxy.after_include_or_extend( *modules )
+    return chain_proxy.after_include_or_extend( *modules, & block )
     
   end
 

data/lib/module/cluster/instance_controller/multiple_hook_controller_proxy/chain_proxy.rb

@@ -66,10 +66,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   # 
   # @return [Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainProxy] self
   #
-  def extend( *modules )
+  def extend( *modules, & block )
 
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.extend( *modules )
+      this_hook_controller_chain_proxy.extend( *modules, & block )
     end
 
     return self
@@ -94,10 +94,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   # 
   # @return [Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainProxy] self
   #
-  def include_and_extend( *modules )
+  def include_and_extend( *modules, & block )
     
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.include_and_extend( *modules )
+      this_hook_controller_chain_proxy.include_and_extend( *modules, & block )
     end
 
     return self
@@ -122,10 +122,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   # 
   # @return [Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainProxy] self
   #
-  def extend_and_include( *modules )
+  def extend_and_include( *modules, & block )
     
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.extend_and_include( *modules )
+      this_hook_controller_chain_proxy.extend_and_include( *modules, & block )
     end
 
     return self
@@ -204,10 +204,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def before_extend( *modules )
+  def before_extend( *modules, & block )
     
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.before_extend( *modules )
+      this_hook_controller_chain_proxy.before_extend( *modules, & block )
     end
     
     return self
@@ -232,10 +232,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def before_include( *modules )
+  def before_include( *modules, & block )
     
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.before_include( *modules )
+      this_hook_controller_chain_proxy.before_include( *modules, & block )
     end
     
     return self
@@ -261,10 +261,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def before_include_or_extend( *modules )
+  def before_include_or_extend( *modules, & block )
 
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.before_include_or_extend( *modules )
+      this_hook_controller_chain_proxy.before_include_or_extend( *modules, & block )
     end
     
     return self
@@ -291,10 +291,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def after_include( *modules )
+  def after_include( *modules, & block )
 
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.after_include( *modules )
+      this_hook_controller_chain_proxy.after_include( *modules, & block )
     end
     
     return self
@@ -319,10 +319,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def after_extend( *modules )
+  def after_extend( *modules, & block )
 
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.after_extend( *modules )
+      this_hook_controller_chain_proxy.after_extend( *modules, & block )
     end
     
     return self
@@ -348,10 +348,10 @@ class ::Module::Cluster::InstanceController::MultipleHookControllerProxy::ChainP
   #
   # @return [Module::Cluster::InstanceController::HookController::ChainProxy] Self.
   #
-  def after_include_or_extend( *modules )
+  def after_include_or_extend( *modules, & block )
     
     @proxies.each do |this_hook_controller_chain_proxy|
-      this_hook_controller_chain_proxy.after_include_or_extend( *modules )
+      this_hook_controller_chain_proxy.after_include_or_extend( *modules, & block )
     end
     
     return self

data/spec/module/cluster_spec.rb

@@ -524,6 +524,8 @@ describe ::Module::Cluster do
       end
       
       block_ran.should == true
+      
+      block_ran = false
 
       class AnotherClassC < AnotherClassB
         is_a?( A ).should == true
@@ -633,6 +635,1199 @@ describe ::Module::Cluster do
     end
   end
 
+  ##############################
+  #  before_include_or_extend  #
+  ##############################
+  
+  it 'can simultaneously create hooks for both before-include and before-extend - with block only' do
+    module ::Module::Cluster::BeforeIncludeExtendHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_extend( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == true
+
+    end
+  end
+  
+  it 'can simultaneously create hooks for both before-include and before-extend - without block' do
+    module ::Module::Cluster::BeforeIncludeExtendHookMock
+
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).before_include_or_extend.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+    end
+  end
+
+  it 'can simultaneously create hooks for both before-include and before-extend - with block' do
+    module ::Module::Cluster::BeforeIncludeExtendHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_extend.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+
+    end
+  end
+  
+  #############################
+  #  after_include_or_extend  #
+  #############################
+
+  it 'can simultaneously create hooks for both after-include and after-extend - with block only' do
+    module ::Module::Cluster::AfterIncludeExtendHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_extend( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-include and after-extend - without block' do
+    module ::Module::Cluster::AfterIncludeExtendHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).after_include_or_extend.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-include and after-extend - with block' do
+    module ::Module::Cluster::AfterIncludeExtendHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_extend.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  ################################
+  #  before_include_or_subclass  #
+  ################################
+
+  it 'can simultaneously create hooks for both before-include and subclass - with block only' do
+    module ::Module::Cluster::BeforeIncludeSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == false
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both before-include and subclass - without block' do
+    module ::Module::Cluster::BeforeIncludeSubclassHookMock
+      
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).before_include_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == false
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == false
+        def self.inherited( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+      
+    end
+  end
+
+  it 'can simultaneously create hooks for both before-include and subclass - with block' do
+    module ::Module::Cluster::BeforeIncludeSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == false
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  ###############################
+  #  after_include_or_subclass  #
+  ###############################
+
+  it 'can simultaneously create hooks for both after-include and subclass - with block' do
+    module ::Module::Cluster::AfterIncludeSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == false
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-include and subclass - without block' do
+    module ::Module::Cluster::AfterIncludeSubclassHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).after_include_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == false
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == false
+        def self.inherited( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-include and subclass - with block' do
+    module ::Module::Cluster::AfterIncludeSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == false
+      end
+
+      block_ran.should == false
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  ###############################
+  #  before_extend_or_subclass  #
+  ###############################
+
+  it 'can simultaneously create hooks for both before-extend and subclass - with block only' do
+    module ::Module::Cluster::BeforeExtendSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_extend_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == false
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both before-extend and subclass - without block' do
+    module ::Module::Cluster::BeforeExtendSubclassHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).before_extend_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == false
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == false
+        def self.inherited( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both before-extend and subclass - with block' do
+    module ::Module::Cluster::BeforeExtendSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_extend_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == false
+      end
+
+      block_ran.should == false
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  ##############################
+  #  after_extend_or_subclass  #
+  ##############################
+
+  it 'can simultaneously create hooks for both after-extend and subclass - with block only' do
+    module ::Module::Cluster::AfterExtendSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_extend_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == false
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+      
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-extend and subclass - without block' do
+    module ::Module::Cluster::AfterExtendSubclassHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).after_extend_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == false
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == false
+        def self.inherited( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for both after-extend and subclass - with block' do
+    module ::Module::Cluster::AfterExtendSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_extend_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == false
+      end
+
+      block_ran.should == false
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  ##########################################
+  #  before_include_or_extend_or_subclass  #
+  ##########################################
+
+  it 'can simultaneously create hooks for before-extend, before-include, and subclass - with block only' do
+    module ::Module::Cluster::BeforeIncludeExtendSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_extend_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for before-extend, before-include, and subclass - without block' do
+    module ::Module::Cluster::BeforeIncludeExtendSubclassHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).before_include_or_extend_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for before-extend, before-include, and subclass - with block' do
+    module ::Module::Cluster::BeforeIncludeExtendSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).before_include_or_extend_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  #########################################
+  #  after_include_or_extend_or_subclass  #
+  #########################################
+
+  it 'can simultaneously create hooks for after-extend, after-include, and subclass - with block only' do
+    module ::Module::Cluster::AfterIncludeExtendSubclassHookBlockOnlyMock
+    
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_extend_or_subclass( & block )
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtend
+        extend ClusterModuleMock
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for after-extend, after-include, and subclass - without block' do
+    module ::Module::Cluster::AfterIncludeExtendSubclassHookMock
+    
+      module A
+      end
+
+      module ClusterModuleMock
+        extend ::Module::Cluster
+        cluster( :cluster_name ).after_include_or_extend_or_subclass.extend( A )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+      
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+        def self.inherited( instance )
+          instance.is_a?( A ).should == true
+          super if defined?( super )
+        end
+      end
+      
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+    
+    end
+  end
+
+  it 'can simultaneously create hooks for after-extend, after-include, and subclass - with block' do
+    module ::Module::Cluster::AfterIncludeExtendSubclassHookBlockMock
+    
+      module A
+      end
+
+      block_ran = false
+      
+      ClusterModuleMock = ::Module.new
+      ClusterModuleMock.module_eval do
+        extend ::Module::Cluster
+        block = ::Proc.new do |instance|
+          instance.is_a?( A ).should == true
+          block_ran = true
+        end
+        cluster( :cluster_name ).after_include_or_extend_or_subclass.extend( A, & block )
+        def self.included( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+        def self.extended( instance )
+          instance.is_a?( A ).should == false
+          super if defined?( super )
+          instance.is_a?( A ).should == true
+        end
+      end
+
+      class BaseClassInclude
+        include ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassIncludeSub < BaseClassInclude
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+      
+      block_ran = false
+
+      class BaseClassExtend
+        extend ClusterModuleMock
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+      block_ran = false
+    
+      class BaseClassExtendSub < BaseClassExtend
+        is_a?( A ).should == true
+      end
+
+      block_ran.should == true
+    
+    end
+  end
+
   #######################
   #  conditional hooks  #
   #######################