cascading_configuration 1.0.0

data/spec/cascading_configuration/core/instance_controller_spec.rb

@@ -0,0 +1,273 @@
+
+require_relative '../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::InstanceController do
+
+  ##############################
+  #  initialize                #
+  #  instance                  #
+  #  self.instance_controller  #
+  ##############################
+  
+  it 'can initialize for an instance' do
+    module ::CascadingConfiguration::Core::InstanceController::InitializeMock
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      InstanceController.instance.should == ForInstance
+      ForInstance::Controller.should == InstanceController
+      ::CascadingConfiguration::Core::InstanceController.instance_controller( ForInstance ).should == InstanceController
+      for_instance = ::Object.new
+      instance_controller = ::CascadingConfiguration::Core::InstanceController.new( for_instance )
+      instance_controller.instance.should == for_instance
+    end
+  end
+
+  ####################################
+  #  initialize_inheriting_instance  #
+  ####################################
+  
+  it 'causes the instance it extends to be enabled for managing inheritable support modules' do
+    module ::CascadingConfiguration::Core::InstanceController::InheritanceMock
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      AnotherModule = ::Module.new do
+        include ForInstance
+      end
+      #AnotherAnotherModule = ::Module.new do
+      #  include AnotherModule
+      #end
+      #Encapsulation.parents( AnotherAnotherModule ).include?( AnotherModule ).should == true
+    end
+  end
+  
+  ###########################
+  #  add_extension_modules  #
+  #  extension_modules      #
+  ###########################
+  
+  it 'can declare and retrieve extension modules for a configuration name on instance in an encapsulation' do
+    module ::CascadingConfiguration::Core::InstanceController::AddExtensionModulesMock
+    
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      
+      module SomeModuleA
+      end
+      module SomeModuleB
+      end
+      module SomeModuleC
+      end
+      
+      InstanceController.add_extension_modules( :some_configuration, Encapsulation, SomeModuleA, SomeModuleB, SomeModuleC ) do 
+        def some_other_stuff
+        end
+      end
+      extension_modules = InstanceController.extension_modules( :some_configuration, Encapsulation )
+      extension_modules.count.should == 4
+    end
+  end
+  
+  ##############################
+  #  extension_modules_upward  #
+  ##############################
+
+  it 'can get an array of extension modules ' do
+    module ::CascadingConfiguration::Core::InstanceController::ExtensionModulesUpwardMock
+
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+
+      CCMMock = ::Module.new do
+        def self.create_configuration( encapsulation, instance, this_name )
+        end
+        def self.initialize_configuration( encapsulation, instance, this_name )
+        end
+      end
+
+      Instance_A = ::Module.new
+      InstanceController_A = ::CascadingConfiguration::Core::InstanceController.new( Instance_A )
+      Encapsulation.register_configuration( Instance_A, :some_configuration, CCMMock )
+      ExtensionModule_A1 = ::Module.new
+      ExtensionModule_A2 = ::Module.new
+      InstanceController_A.add_extension_modules( :some_configuration, Encapsulation, ExtensionModule_A1, ExtensionModule_A2 ) do
+        def some_other_stuff
+        end        
+      end
+      InstanceController_A.extension_modules( :some_configuration ).count.should == 3
+      InstanceController_A.extension_modules_upward( :some_configuration ).should == [ InstanceController_A::Default_some_configuration, ExtensionModule_A2, ExtensionModule_A1 ]
+
+
+      Instance_B = ::Module.new
+      Encapsulation.register_child_for_parent( Instance_B, Instance_A )
+  
+      Instance_C = ::Module.new
+      InstanceController_C = ::CascadingConfiguration::Core::InstanceController.new( Instance_C )
+      Encapsulation.register_child_for_parent( Instance_C, Instance_B )
+      ExtensionModule_C1 = ::Module.new
+      InstanceController_C.add_extension_modules( :some_configuration, Encapsulation, ExtensionModule_C1 ) do
+        def some_other_stuff
+        end        
+      end
+      InstanceController_C.extension_modules_upward( :some_configuration ).should == [ InstanceController_C::Default_some_configuration, ExtensionModule_C1, InstanceController_A::Default_some_configuration, ExtensionModule_A2, ExtensionModule_A1 ]
+
+      InstanceController_B = ::CascadingConfiguration::Core::InstanceController.new( Instance_B )
+      InstanceController_B.extension_modules_upward( :some_configuration ).should == [ InstanceController_A::Default_some_configuration, ExtensionModule_A2, ExtensionModule_A1 ]
+      
+    end
+  end
+  
+  ####################
+  #  create_support  #
+  #  support         #
+  ####################
+
+  it 'can manage creation and return of module instances' do
+    module ::CascadingConfiguration::Core::InstanceController::CreateSupportMock
+      
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+
+      # should_include
+      ModuleInstance_Include = InstanceController.create_support( :some_type1, Encapsulation, nil, true, false, false, false )
+      InstanceController.support( :some_type1 ).should == ModuleInstance_Include
+      ForInstance.ancestors.include?( ModuleInstance_Include ).should == true
+      ForInstance.is_a?( ModuleInstance_Include ).should == false
+      InstanceController.cascade_includes.include?( ModuleInstance_Include ).should == false
+      InstanceController.cascade_extends.include?( ModuleInstance_Include ).should == false
+      
+      # should_extend
+      ModuleInstance_Extend = InstanceController.create_support( :some_type2, Encapsulation, false, nil, true, false, false )
+      InstanceController.support( :some_type2 ).should == ModuleInstance_Extend
+      ForInstance.ancestors.include?( ModuleInstance_Extend ).should == false
+      ForInstance.is_a?( ModuleInstance_Extend ).should == true
+      InstanceController.cascade_includes.include?( ModuleInstance_Extend ).should == false
+      InstanceController.cascade_extends.include?( ModuleInstance_Extend ).should == false
+      
+      # should_cascade_includes
+      ModuleInstance_CascadeIncludes = InstanceController.create_support( :some_type3, Encapsulation, false, nil, false, true, false )
+      InstanceController.support( :some_type3 ).should == ModuleInstance_CascadeIncludes
+      ForInstance.ancestors.include?( ModuleInstance_CascadeIncludes ).should == false
+      ForInstance.is_a?( ModuleInstance_CascadeIncludes ).should == false
+      InstanceController.cascade_includes.include?( ModuleInstance_CascadeIncludes ).should == true
+      InstanceController.cascade_extends.include?( ModuleInstance_CascadeIncludes ).should == false
+      
+      # should_cascade_extends
+      ModuleInstance_CascadeExtends = InstanceController.create_support( :some_type4, Encapsulation, nil, false, false, false, true )
+      InstanceController.support( :some_type4 ).should == ModuleInstance_CascadeExtends
+      ForInstance.ancestors.include?( ModuleInstance_CascadeExtends ).should == false
+      ForInstance.is_a?( ModuleInstance_CascadeExtends ).should == false
+      InstanceController.cascade_includes.include?( ModuleInstance_CascadeExtends ).should == false
+      InstanceController.cascade_extends.include?( ModuleInstance_CascadeExtends ).should == true
+      
+      AnotherModule_IncludeA = ::Module.new do
+        include ForInstance
+        ancestors.include?( ModuleInstance_CascadeIncludes ).should == true
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == true
+      end
+      AnotherModule_IncludeB = ::Module.new do
+        include AnotherModule_IncludeA
+        ancestors.include?( ModuleInstance_CascadeIncludes ).should == true
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == true
+      end
+      AnotherModule_IncludeC = ::Module.new do
+        include AnotherModule_IncludeB
+        ancestors.include?( ModuleInstance_CascadeIncludes ).should == true
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == true
+      end
+      AnotherModule_ClassInclude = ::Class.new do
+        include AnotherModule_IncludeC
+        ancestors.include?( ModuleInstance_CascadeIncludes ).should == true
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == true
+      end
+
+      AnotherModule_ExtendA = ::Module.new do
+        extend ForInstance
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == false
+        eigenclass.ancestors.include?( ModuleInstance_CascadeIncludes ).should == true
+      end
+      AnotherModule_ExtendB = ::Module.new do
+        extend AnotherModule_ExtendA
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == false
+      end
+      AnotherModule_ExtendC = ::Module.new do
+        extend AnotherModule_ExtendB
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == false
+      end
+      AnotherModule_ClassExtend = ::Class.new do
+        extend AnotherModule_ExtendC
+        eigenclass = class << self ; self ; end
+        eigenclass.ancestors.include?( ModuleInstance_CascadeExtends ).should == false
+      end
+
+    end
+  end  
+
+  ##############################
+  #  create_singleton_support  #
+  #  singleton_support         #
+  ##############################
+  
+  it 'can create a cascading support module for singleton (module/class) methods' do
+    module ::CascadingConfiguration::Core::InstanceController::CreateSingletonSupportMock
+    
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      
+      singleton_support = InstanceController.create_singleton_support
+      InstanceController.singleton_support.should == singleton_support
+      
+    end
+  end
+
+  #############################
+  #  create_instance_support  #
+  #  instance_support         #
+  #############################
+
+  it 'can create a cascading support module for instance methods' do
+    module ::CascadingConfiguration::Core::InstanceController::CreateInstanceSupportMock
+    
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+    
+      instance_support = InstanceController.create_instance_support
+      InstanceController.instance_support.should == instance_support
+    
+    end
+  end
+
+  ###################################
+  #  create_local_instance_support  #
+  #  local_instance_support         #
+  ###################################
+
+  it 'can create a non-cascading support module supporting the local object and its instances' do
+    module ::CascadingConfiguration::Core::InstanceController::CreateLocalInstanceSupportMock
+    
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+    
+      local_instance_support = InstanceController.create_local_instance_support
+      InstanceController.local_instance_support.should == local_instance_support
+    
+    end
+  end
+
+end

data/spec/cascading_configuration/core/module/block_configurations/cascading_variables_spec.rb

@@ -0,0 +1,17 @@
+
+require_relative '../../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::Module::BlockConfigurations::CascadingVariables do
+
+  ############
+  #  setter  #
+  #  getter  #
+  ############
+  
+  
+  #####################
+  #  instance_setter  #
+  #  instance_getter  #
+  #####################
+
+end

data/spec/cascading_configuration/core/module/extended_configurations/compositing_objects_spec.rb

@@ -0,0 +1,127 @@
+
+require_relative '../../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects do
+
+  ##############################
+  #  initialize                #
+  #  compositing_object_class  #
+  ##############################
+  
+  it 'can initialize with a compositing object class' do
+    module ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects::InitializeMock
+      ClassInstance = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects.new( :setting, ::CompositingArray, :default, '' )
+      CCM = ::Module.new do
+        ::CascadingConfiguration::Core.enable( self, ClassInstance )
+      end
+      CCM::ClassInstance.default_encapsulation.should == ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      CCM::ClassInstance.ccm_name.should == :setting
+      CCM::ClassInstance.ccm_aliases.should == [ '' ]
+      CCM::ClassInstance.compositing_object_class.should == ::CompositingArray
+    end
+  end
+  
+  #####################################################
+  #  create_configuration                             #
+  #  initialize_compositing_configuration_for_parent  #
+  #####################################################
+  
+  it 'ensures objects are initialized for each level in hiearchy' do
+    module ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects::CreateConfigurationMock
+
+      ClassInstance = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects.new( :setting, ::CompositingArray, :default, '' )
+      CCM = ::Module.new do
+        ::CascadingConfiguration::Core.enable( self, ClassInstance )
+      end
+      
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      # module 1
+      Module1 = ::Module.new do
+        include CCM
+        attr_setting :some_configuration
+      end
+      Encapsulation.get_configuration( Module1, :some_configuration ).is_a?( ::CompositingArray ).should == true
+    
+      # module 2
+      Module2 = ::Module.new do
+        include Module1
+      end
+      Encapsulation.get_configuration( Module2, :some_configuration ).is_a?( ::CompositingArray ).should == true
+    
+      # module 3
+      Module3 = ::Module.new do
+        include Module2
+      end
+      Encapsulation.get_configuration( Module3, :some_configuration ).is_a?( ::CompositingArray ).should == true
+    
+      # class 1
+      Class1 = ::Class.new do
+        include Module3
+      end
+      Encapsulation.get_configuration( Class1, :some_configuration ).is_a?( ::CompositingArray ).should == true
+    
+      # subclass 1
+      Class2 = ::Class.new( Class1 )
+      Encapsulation.get_configuration( Class2, :some_configuration ).is_a?( ::CompositingArray ).should == true
+    
+      # instance
+      Instance = Class2.new
+      Encapsulation.get_configuration( Instance, :some_configuration ).nil?.should == true
+      Instance.some_configuration.is_a?( ::CompositingArray ).should == true
+
+      RandomInstance = ::Object.new
+      Encapsulation.register_child_for_parent( RandomInstance, Instance )
+      Encapsulation.get_configuration( RandomInstance, :some_configuration ).is_a?( ::CompositingArray ).should == true
+
+      RandomInstance2 = ::Object.new
+      Encapsulation.register_child_for_parent( RandomInstance2, RandomInstance )
+      Encapsulation.get_configuration( RandomInstance2, :some_configuration ).is_a?( ::CompositingArray ).should == true
+      
+    end
+    
+  end
+
+  #####################
+  #  setter           #
+  #  getter           #
+  #  instance_setter  #
+  #  instance_getter  #
+  #####################
+  
+  it 'can set and get values' do
+    module ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects::SetterGetterMock
+      
+      ClassInstance = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects.new( :setting, ::CompositingArray, :default, '' )
+      CCM = ::Module.new do
+        ::CascadingConfiguration::Core.enable( self, ClassInstance )
+      end
+      
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      # module 1
+      Module1 = ::Module.new do
+        include CCM
+        attr_setting :some_configuration
+        self.some_configuration.should == [ ]
+        self.some_configuration.push( :some_value )
+        self.some_configuration.should == [ :some_value ]
+        self.some_configuration = [ :some_other_value ]
+        self.some_configuration.should == [ :some_other_value ]
+      end
+    
+      Class1 = ::Class.new do
+        include Module1
+      end
+      
+      Instance = Class1.new
+      Instance.some_configuration.should == [ :some_other_value ]
+      Instance.some_configuration.push( :some_value )
+      Instance.some_configuration.should == [ :some_other_value, :some_value ]
+      Instance.some_configuration = [ :some_other_value ]
+      Instance.some_configuration.should == [ :some_other_value ]
+    
+    end
+  end
+  
+end

data/spec/cascading_configuration/core/module/extended_configurations_spec.rb

@@ -0,0 +1,37 @@
+
+require_relative '../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::Module::ExtendedConfigurations do
+  
+  #############################
+  #  parse_extension_modules  #
+  #############################
+
+  it 'can parse extension modules from names' do
+    module ::CascadingConfiguration::Core::Module::ParseExtensionModulesMock
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      CCM = ::CascadingConfiguration::Core::Module::ExtendedConfigurations.new( :setting, :default, '' )
+      module ModuleA
+      end
+      module ModuleB
+      end
+      module ModuleC
+      end
+      module ModuleD
+      end
+      names_modules = [ :name1, :name2, ModuleA, :name3, ModuleB, :name4, :name5, ModuleC, ModuleD, :name6 ]
+      names_modules_hash = CCM.class.parse_extension_modules( InstanceController, Encapsulation, *names_modules )
+      modules = [ ModuleA, ModuleB, ModuleC, ModuleD ]
+      names_modules_hash.should == { :name1 => modules,
+                                     :name2 => modules,
+                                     :name3 => modules,
+                                     :name4 => modules,
+                                     :name5 => modules,
+                                     :name6 => modules }
+    end
+  end
+
+  
+end

data/spec/cascading_configuration/core/module/inheriting_values_spec.rb

@@ -0,0 +1,87 @@
+
+require_relative '../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::Module::InheritingValues do
+
+  ########################################
+  #  get_configuration_searching_upward  #
+  ########################################
+
+  it 'can get the first defined configuration searching up the module configuration inheritance chain' do
+    module ::CascadingConfiguration::Core::Module::InheritingValues::GetConfigurationSearchingUpwardMock
+      
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      CCM = ::CascadingConfiguration::Core::Module::InheritingValues.new( 'configuration' )
+            
+      Instance_A = ::Module.new
+      Encapsulation.register_configuration( Instance_A, :some_configuration, CCM )
+      Instance_B = ::Module.new do
+        include Instance_A
+      end
+      Encapsulation.register_child_for_parent( Instance_B, Instance_A )
+      Encapsulation.register_configuration( Instance_B, :some_other_configuration, CCM )
+      Instance_C1 = ::Module.new do
+        include Instance_B
+      end
+      Encapsulation.register_child_for_parent( Instance_C1, Instance_B )
+      Encapsulation.register_configuration( Instance_C1, :yet_another_configuration, CCM )
+      Instance_C2 = ::Module.new do
+        include Instance_B
+      end
+      Encapsulation.register_child_for_parent( Instance_C2, Instance_B )
+      Instance_D = ::Module.new do
+        include Instance_C1
+        include Instance_C2
+      end
+      Encapsulation.register_child_for_parent( Instance_D, Instance_C1 )
+      Encapsulation.register_child_for_parent( Instance_D, Instance_C2 )
+      
+      Encapsulation.set_configuration( Instance_A, :some_configuration, :some_value )
+      Encapsulation.set_configuration( Instance_B, :some_other_configuration, :some_other_value )
+      
+      CCM.module_eval do
+        get_configuration_searching_upward( Encapsulation, Instance_B, :some_configuration ).should == :some_value
+        get_configuration_searching_upward( Encapsulation, Instance_B, :some_other_configuration ).should == :some_other_value
+        get_configuration_searching_upward( Encapsulation, Instance_C1, :some_configuration ).should == :some_value
+        get_configuration_searching_upward( Encapsulation, Instance_C1, :some_other_configuration ).should == :some_other_value
+        Encapsulation.set_configuration( Instance_C1, :yet_another_configuration, :another_value )
+        get_configuration_searching_upward( Encapsulation, Instance_C1, :yet_another_configuration ).should == :another_value
+        get_configuration_searching_upward( Encapsulation, Instance_C2, :some_configuration ).should == :some_value
+        get_configuration_searching_upward( Encapsulation, Instance_C2, :some_other_configuration ).should == :some_other_value
+        get_configuration_searching_upward( Encapsulation, Instance_D, :some_configuration ).should == :some_value
+        get_configuration_searching_upward( Encapsulation, Instance_D, :some_other_configuration ).should == :some_other_value
+        get_configuration_searching_upward( Encapsulation, Instance_D, :yet_another_configuration ).should == :another_value
+      end
+      
+    end    
+  end
+
+  #####################
+  #  setter           #
+  #  getter           #
+  #  instance_setter  #
+  #  instance_getter  #
+  #####################
+  
+  it 'can set and get values' do
+    module ::CascadingConfiguration::Core::Module::InheritingValues::SetterGetterMock
+      
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      
+      CCM = ::CascadingConfiguration::Core::Module::InheritingValues.new( 'configuration' )
+      
+      CCM.method( :setter ).should == CCM.method( :instance_setter )
+      CCM.method( :getter ).should == CCM.method( :instance_getter )
+      
+      CCM.getter( Encapsulation, ForInstance, :some_configuration ).should == nil
+      CCM.setter( Encapsulation, ForInstance, :some_configuration, :some_value )
+      CCM.getter( Encapsulation, ForInstance, :some_configuration ).should == :some_value
+      
+    end
+  end
+  
+end