module-cluster 1.4.8 → 2.0.0

data/spec/ModuleCluster_spec.rb

@@ -1,15 +0,0 @@
-require_relative '../lib/module-cluster.rb'
-
-describe ::ModuleCluster do
-
-  it 'clusters other modules' do
-    module ::ModuleCluster
-      is_a?( Define::Cluster )
-      is_a?( Define::ClusterCascades )
-      is_a?( Define::ClusterCascadesToClass )
-      is_a?( Define::ClusterCascadesToModule )
-      is_a?( Define::Deprecated )
-    end
-  end
-  
-end

data/spec/_private_/ModuleCluster/CascadeFeatures/PerformCascades_spec.rb

@@ -1,386 +0,0 @@
-
-require_relative '../../../../lib/module-cluster.rb'
-
-describe ::ModuleCluster::CascadeFeatures::PerformCascades do
-
-  ##########################################
-  #  collect_block_runtime_result_modules  #
-  ##########################################
-
-  it 'can run a block and return any modules that were returned by the block' do
-    # condition is a ::ModuleCluster-extended module
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule01
-    end
-    # a module to be included/extended at hook time
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule01
-    end
-    # another module includes the first module and invokes the runtime hook
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule01
-    end
-    # we need a mock instance to use our methods
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock01
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module_self = ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule01
-    hooked_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule01
-    block_ran = false
-    runtime_includes_block = Proc.new { block_ran = true ; ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule01 }
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include, nil, runtime_includes_block )
-    result_modules = ::ModuleCluster::CascadeFeatures::PerformCascades::Mock01.collect_block_runtime_result_modules( module_self,
-                                                                                                                   hooked_instance,
-                                                                                                                   set )
-    block_ran.should == true
-    result_modules.should == [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule01 ]
-  end
-
-  ########################################
-  #  should_include_or_extend_instance?  #
-  ########################################
-
-  it 'can report whether an instance should be included or extended based on a descriptor symbol' do
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    end
-    class ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    end
-    
-    module_class_instance_or_all = :all
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_class_or_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_class_and_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_class_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_or_class
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    module_class_instance_or_all = :module_and_class
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    module_class_instance_or_all = :module_class
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    module_class_instance_or_all = :module_or_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_and_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :class_or_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :class_and_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :class_instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    module_class_instance_or_all = :module
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    module_class_instance_or_all = :class
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    module_class_instance_or_all = :instance
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == false
-    into_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockClassInstance02.new
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock02.should_include_or_extend_instance?( module_class_instance_or_all, into_instance ).should == true
-  end
-
-  #######################################
-  #  include_or_extend_hooked_instance  #
-  #######################################
-
-  it 'can include or extend the hooked instance as appropriate' do
-    # condition is a ::ModuleCluster-extended module
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule03
-    end
-    # a module to be included/extended at hook time
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03
-    end
-    # another module includes the first module and invokes the runtime hook
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03A
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03B
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03C
-    end
-    # we need a mock instance to use our methods
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock03
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module_self = ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule03
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ] )
-
-    # include
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock03.include_or_extend_hooked_instance( ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03A, 
-                                                                                               set, 
-                                                                                               true, 
-                                                                                               false, 
-                                                                                               set.modules )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03A.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == true
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03A ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == false
-    # extend
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock03.include_or_extend_hooked_instance( ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03B, 
-                                                                                               set, 
-                                                                                               false, 
-                                                                                               true, 
-                                                                                               set.modules )    
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03B.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == false
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03B ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == true
-    # include and extend
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock03.include_or_extend_hooked_instance( ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03C, 
-                                                                                               set, 
-                                                                                               true, 
-                                                                                               true, 
-                                                                                               set.modules )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03C.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == true
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule03C ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule03 ).should == true
-    
-  end
-
-  ##########################################
-  #  cascade_modules_into_hooked_instance  #
-  ##########################################
-
-  it 'can cascade modules into the hooked instance as appropriate' do
-    # condition is a ::ModuleCluster-extended module
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule04
-      def declaration_method( modules )
-        @declaration_method_called = true
-      end
-      def called_declaration_method
-        return @declaration_method_called
-      end
-    end
-    # a module to be included/extended at hook time
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule04A
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule04B
-    end
-    # another module includes the first module and invokes the runtime hook
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule04
-    end
-    # we need a mock instance to use our methods
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock04
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module_self = ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule04
-    hooked_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule04
-    block_ran = false
-    runtime_includes_block = Proc.new { block_ran = true ; ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule04B }
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule04A ], runtime_includes_block )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock04.cascade_modules_into_hooked_instance( module_self, hooked_instance, set, set.modules )
-    # hooked instance should be extended with dependency module (module_self) and :declaration_method should be called on it
-    hooked_instance_eigenclass = class << hooked_instance ; self ; end
-    hooked_instance_eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule04 ).should == true
-    hooked_instance.called_declaration_method.should == true
-  end
-
-  ############################
-  #  include_extend_modules  #
-  ############################
-
-  it 'can perform include and/or extend of specified modules into instance' do
-    # condition is a ::ModuleCluster-extended module
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule05
-    end
-    # a module to be included/extended at hook time
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05
-    end
-    # another module includes the first module and invokes the runtime hook
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05A
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05B
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05C
-    end
-    # we need a mock instance to use our methods
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock05
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module_self = ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule05
-
-    # include
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ] )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock05.include_extend_modules( ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule05, 
-                                                                                    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05A, 
-                                                                                    set, 
-                                                                                    set.modules )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05A.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == true
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05A ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == false
-    # extend
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :extend, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ] )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock05.include_extend_modules( ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule05, 
-                                                                                    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05B, 
-                                                                                    set, 
-                                                                                    set.modules )    
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05B.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == false
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05B ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == true
-    # include and extend
-    set = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include_and_extend, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ] )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock05.include_extend_modules( ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule05, 
-                                                                                    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05C, 
-                                                                                    set, 
-                                                                                    set.modules )
-    ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05C.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == true
-    eigenclass = class << ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule05C ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule05 ).should == true
-    
-  end
-
-  ######################
-  #  perform_cascades  #
-  ######################
-
-  it 'can perform cascade of specified modules into instance' do
-
-    # condition is a ::ModuleCluster-extended module
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule06
-      def self.should_include_or_extend?( hooked_instance )
-        return true
-      end
-      def self.should_cascade?( hooked_instance )
-        return true
-      end
-      def self.hooks_suspended?( action )
-        return @hooks_suspended ||= false
-      end
-      def self.suspend_hooks
-        @hooks_suspended = true
-      end
-      def self.unsuspend_hooks
-        @hooks_suspended = false
-      end
-      def declaration_method( modules )
-        @declaration_method_called = true
-      end
-      def called_declaration_method
-        return @declaration_method_called
-      end
-    end
-    # a module to be included/extended at hook time
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06A
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06B
-    end
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C
-    end
-    # another module includes the first module and invokes the runtime hook
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule06
-    end
-    # we need a mock instance to use our methods
-    module ::ModuleCluster::CascadeFeatures::PerformCascades::Mock06
-      extend ::ModuleCluster::CascadeFeatures::PerformCascades
-    end
-    module_self = ::ModuleCluster::CascadeFeatures::PerformCascades::MockCascadeModule06
-    hooked_instance = ::ModuleCluster::CascadeFeatures::PerformCascades::MockModuleIncludingMockCascadeModule06
-    set_one = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06A ] )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :extend, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06B ] )
-    set_three = ::ModuleCluster::ClusterStack::Set.new( module_self, :declaration_method, :all, :include_and_extend, [ ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C ] )
-    set_stack = [ set_one, set_two, set_three ]
-
-    # test that suspending works - mocked for true/false
-    module_self.suspend_hooks
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock06.perform_cascades( module_self, :include, hooked_instance, set_stack )
-    hooked_instance.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06A ).should == false
-    hooked_instance.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C ).should == false
-    eigenclass = class << hooked_instance ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06B ).should == false
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C ).should == false
-    # also our dependency module should be extended
-    eigenclass.ancestors.include?( module_self ).should == false
-    module_self.unsuspend_hooks
-
-
-    ::ModuleCluster::CascadeFeatures::PerformCascades::Mock06.perform_cascades( module_self, :include, hooked_instance, set_stack )
-    hooked_instance.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06A ).should == true
-    hooked_instance.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C ).should == true
-    eigenclass = class << hooked_instance ; self ; end
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06B ).should == true
-    eigenclass.ancestors.include?( ::ModuleCluster::CascadeFeatures::PerformCascades::MockHookedIncludeModule06C ).should == true
-    # also our dependency module should be extended
-    eigenclass.ancestors.include?( module_self ).should == true
-    hooked_instance.called_declaration_method.should == true
-    
-  end
-
-end

data/spec/_private_/ModuleCluster/ClusterStack/Set/MultiSetProxy_spec.rb

@@ -1,419 +0,0 @@
-
-require_relative '../../../../../lib/module-cluster.rb'
-
-describe ::ModuleCluster::ClusterStack::Set::MultiSetProxy do
-
-  ###########
-  #  name=  #
-  #  name   #
-  ###########
-
-  it 'can set the name of each member set and retrieve the names of each member set' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    set_one.name = :some_name
-    set_two.name = :some_other_name
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.name.should == [ :some_name, :some_other_name ]
-    multi_set.name = :yet_another_other_name
-    multi_set.name.should == [ :yet_another_other_name, :yet_another_other_name ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.name.should == [ :yet_another_other_name, :yet_another_other_name, :some_name, :some_other_name ]
-  end
-
-  ########################
-  #  dependency_module=  #
-  #  dependency_module   #
-  ########################
-
-  it 'can set the dependecy module of each member set and retrieve the dependency module of each member set' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.dependency_module.should == [ ::ModuleCluster::Define::Cluster, ::ModuleCluster::Define::Cluster ]
-    multi_set.dependency_module = ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01
-    multi_set.dependency_module.should == [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01, ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01 ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.dependency_module.should == [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01, ::ModuleCluster::ClusterStack::Set::MultiSetProxy::DependencyModuleMock01, ::ModuleCluster::Define::Cluster, ::ModuleCluster::Define::Cluster ]
-  end
-
-  #############
-  #  method=  #
-  #  method   #
-  #############
-  
-  it 'can set the method of each member set and retrieve the methods of each member set' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.method.should == [ :include_also_includes, :include_also_includes ]
-    multi_set.method = :some_other_method
-    multi_set.method.should == [ :some_other_method, :some_other_method ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.method.should == [ :some_other_method, :some_other_method, :include_also_includes, :include_also_includes ]
-  end
-
-  ###################################
-  #  module_class_instance_or_all=  #
-  #  module_class_instance_or_all   #
-  ###################################
-  
-  it 'can set the object to which set applies for each member set and retrieve the objects to which sets apply for all member sets' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.module_class_instance_or_all.should == [ :all, :all ]
-    multi_set.module_class_instance_or_all = :module
-    multi_set.module_class_instance_or_all.should == [ :module, :module ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.module_class_instance_or_all.should == [ :module, :module, :all, :all ]
-  end
-
-  ########################
-  #  include_or_extend=  #
-  #  include_or_extend   #
-  ########################
-  
-  it 'can set whether set should be used to include, extend, or both and retrieve whether member sets are to be included, extended, or both' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.include_or_extend.should == [ :include_also_includes, :include_also_includes ]
-    multi_set.include_or_extend = :module
-    multi_set.include_or_extend.should == [ :module, :module ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.include_or_extend.should == [ :module, :module, :include_also_includes, :include_also_includes ]
-  end
-  
-  ##############
-  #  modules=  #
-  #  modules   #
-  ##############
-
-  it 'can set the modules of each member set and retrieve the modules of each member set' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.modules.should == [ [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ] ]
-    multi_set.modules = [ Module ]
-    multi_set.modules.should == [ [ Module ], [ Module ] ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.modules.should == [ [ Module ], [ Module ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ] ]
-    set_five = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    multi_multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_multi_set, set_five )
-    multi_multi_set_two.modules.should == [ [ Module ], [ Module ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ] ]
-  end
-
-  ########################################
-  #  runtime_includes_or_extends_block=  #
-  #  runtime_includes_or_extends_block   #
-  ########################################
-  
-  it 'can set the block for runtime determination of modules for each member set and retrieve the block from each member set' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    runtime_block = Proc.new { Module }
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], runtime_block )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], runtime_block )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.runtime_includes_or_extends_block.should == [ runtime_block, runtime_block ]
-    other_block = Proc.new { Kernel }
-    multi_set.runtime_includes_or_extends_block = other_block
-    multi_set.runtime_includes_or_extends_block.should == [ other_block, other_block ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], runtime_block )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], runtime_block )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.runtime_includes_or_extends_block.should == [ other_block, other_block, runtime_block, runtime_block ]
-  end
-
-  ################
-  #  suspended=  #
-  #  suspended   #
-  #  suspend     #
-  #  suspended?  #
-  #  resume      #
-  ################
-
-  it 'can suspend and resume each member set and retrieve whether member sets are suspended' do
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.suspended.should == [ false, false ]
-    multi_set.suspended?.should == [ false, false ]
-    multi_set.suspended = true
-    multi_set.suspended.should == [ true, true ]
-    multi_set.resume
-    multi_set.suspended.should == [ false, false ]
-    multi_set.suspend
-    multi_set.suspended.should == [ true, true ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_set_two.suspended.should == [ false, false ]
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.suspended?.should == [ true, true, false, false ]
-  end
-
-  ################
-  #  hooks_with  #
-  ################
-
-  it 'can return hooks in the set matching the description' do
-    
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    block_one = Proc.new do
-      puts 'nothing'
-    end
-    block_two = Proc.new do
-      puts 'more nothing'
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], block_one )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :instance, :extend, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], block_two )
-    set_one.name = :name_one
-    set_two.name = :name_two_and_three
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.suspended.should == [ false, false ]
-    multi_set.suspended?.should == [ false, false ]
-    multi_set.suspended = true
-    multi_set.suspended.should == [ true, true ]
-    multi_set.resume
-    multi_set.suspended.should == [ false, false ]
-    multi_set.suspend
-    multi_set.suspended.should == [ true, true ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    block_four = Proc.new do
-      puts 'another nothing'
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :class, :include_and_extend, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :module, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], block_four )
-    set_three.name = :name_two_and_three
-    set_four.name = :name_four
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_set_two.suspended.should == [ false, false ]
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    
-    # dependency_module
-    multi_set.hooks_with( :dependency_module => ::ModuleCluster::Define::Cluster ).should == [ set_one, set_two ]
-    multi_set_two.hooks_with( :dependency_module => ::ModuleCluster::Define::Cluster ).should == [ set_three, set_four ]
-    multi_multi_set.hooks_with( :dependency_module => ::ModuleCluster::Define::Cluster ).should == [ set_one, set_two, set_three, set_four ]
-    
-    # method
-    multi_set.hooks_with( :method => :include_also_includes ).should == [ set_one, set_two ]
-    multi_set_two.hooks_with( :method => :include_also_includes ).should == [ set_three, set_four ]
-    multi_multi_set.hooks_with( :method => :include_also_includes ).should == [ set_one, set_two, set_three, set_four ]
-    
-    # module_class_instance_or_all
-    multi_set.hooks_with( :module_class_instance_or_all => :all ).should == [ set_one ]
-    multi_set.hooks_with( :module_class_instance_or_all => :instance ).should == [ set_one, set_two ]
-    multi_set_two.hooks_with( :module_class_instance_or_all => :class ).should == [ set_three ]
-    multi_multi_set.hooks_with( :module_class_instance_or_all => :module ).should == [ set_one, set_four ]
-    
-    # include_or_extend
-    multi_set.hooks_with( :include_or_extend => :include ).should == [ set_one ]
-    multi_set.hooks_with( :include_or_extend => :extend ).should == [ set_two ]
-    multi_set_two.hooks_with( :include_or_extend => :include ).should == [ set_three, set_four ]
-    multi_multi_set.hooks_with( :include_or_extend => :extend ).should == [ set_two, set_three ]
-    multi_multi_set.hooks_with( :include_or_extend => :include ).should == [ set_one, set_three, set_four ]
-    
-    # modules
-    multi_set.hooks_with( :modules => ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ).should == [ set_one ]
-    multi_set.hooks_with( :modules => [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ] ).should == [ set_two ]
-    multi_set_two.hooks_with( :modules => [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ] ).should == [ set_three ]
-    multi_multi_set.hooks_with( :modules => ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ).should == [ set_one ]
-    multi_multi_set.hooks_with( :modules => [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ] ).should == [ set_four ]
-    
-    # runtime_includes_or_extends_block
-    multi_set.hooks_with( :runtime_includes_or_extends_block => block_one ).should == [ set_one ]
-    multi_set.hooks_with( :runtime_includes_or_extends_block => block_two ).should == [ set_two ]
-    multi_set_two.hooks_with( :runtime_includes_or_extends_block => block_four ).should == [ set_four ]
-    multi_set_two.hooks_with( :runtime_includes_or_extends_block => nil ).should == [ set_three ]
-    multi_multi_set.hooks_with( :runtime_includes_or_extends_block => block_four ).should == [ set_four ]
-    multi_multi_set.hooks_with( :runtime_includes_or_extends_block => block_one ).should == [ set_one ]
-    multi_multi_set.hooks_with( :runtime_includes_or_extends_block => nil ).should == [ set_three ]
-    
-    # suspended
-    multi_set.hooks_with( :suspended => false ).should == [ ]
-    multi_set.hooks_with( :suspended => true ).should == [ set_one, set_two ]
-    multi_set_two.hooks_with( :suspended => false ).should == [ set_three, set_four ]
-    multi_multi_set.hooks_with( :suspended => true ).should == [ set_one, set_two ]
-    multi_multi_set.hooks_with( :suspended => false ).should == [ set_three, set_four ]
-    
-    # name
-    multi_set.hooks_with( :name => :name_one ).should == [ set_one ]
-    multi_set.hooks_with( :name => :name_two_and_three ).should == [ set_two ]
-    multi_set_two.hooks_with( :name => :name_two_and_three ).should == [ set_three ]
-    multi_multi_set.hooks_with( :name => :name_two_and_three ).should == [ set_two, set_three ]
-    multi_multi_set.hooks_with( :name => :name_four ).should == [ set_four ]
-    
-    # we've ensured individual descriptions work, now we just need to make sure the logic loops
-    # since each works individually, if the loop works then any loop should work
-    #
-    # name x include_or_extend
-    multi_set.hooks_with( :name => :name_one, 
-                          :include_or_extend => :extend ).should == [ ]
-    multi_set.hooks_with( :name => :name_two_and_three, 
-                          :include_or_extend => :extend ).should == [ set_two ]
-    multi_set_two.hooks_with( :name => :name_two_and_three, 
-                              :include_or_extend => :include ).should == [ set_three ]
-    multi_multi_set.hooks_with( :name => :name_two_and_three, 
-                                :include_or_extend => :include ).should == [ set_three ]
-    multi_multi_set.hooks_with( :name => :name_four, 
-                                :include_or_extend => :include ).should == [ set_four ]
-    
-  end
-
-  ###########
-  #  hooks  #
-  ###########
-
-  it 'can return a hook or set of hooks in set matching name' do
-
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02
-    end
-    set_one = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock01 ], nil )
-    set_two = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock02 ], nil )
-    set_one.name = :some_name
-    set_two.name = :some_other_name
-    multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_one, set_two )
-    multi_set.name.should == [ :some_name, :some_other_name ]
-    multi_set.name = :yet_another_other_name
-    multi_set.name.should == [ :yet_another_other_name, :yet_another_other_name ]
-    # also make sure it works nested in another MultiSetProxy
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03
-    end
-    module ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04
-    end
-    set_three = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock03 ], nil )
-    set_four = ::ModuleCluster::ClusterStack::Set.new( ::ModuleCluster::Define::Cluster, :include_also_includes, :all, :include, [ ::ModuleCluster::ClusterStack::Set::MultiSetProxy::Mock04 ], nil )
-    set_three.name = :some_name
-    set_four.name = :some_other_name
-    multi_set_two = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( set_three, set_four )
-    multi_multi_set = ::ModuleCluster::ClusterStack::Set::MultiSetProxy.new( multi_set, multi_set_two )
-    multi_multi_set.name.should == [ :yet_another_other_name, :yet_another_other_name, :some_name, :some_other_name ]
-
-    multi_set.hooks( :yet_another_other_name ).should == [ set_one, set_two ]
-    multi_set_two.hooks( :some_name ).should == [ set_three ]
-    multi_set_two.hooks( :some_other_name ).should == [ set_four ]
-    multi_multi_set.hooks( :yet_another_other_name ).should == [ set_one, set_two ]
-    multi_multi_set.hooks( :some_name ).should == [ set_three ]
-    multi_multi_set.hooks( :some_other_name ).should == [ set_four ]
-    
-  end
-  
-end