cascading_configuration 1.0.0

data/spec/cascading_configuration/core/encapsulation_spec.rb

@@ -0,0 +1,208 @@
+
+require_relative '../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::Encapsulation do
+
+  ########################
+  #  initialize          #
+  #  self.encapsulation  #
+  ########################
+
+  it 'can initialize as an independent encapsulation of its features' do
+    module ::CascadingConfiguration::Core::Encapsulation::InitializeMock
+      Encapsulation = ::CascadingConfiguration::Core::Encapsulation.new( :encapsulation_name )
+      Encapsulation.encapsulation_name.should == :encapsulation_name
+      ::CascadingConfiguration::Core::Encapsulation.encapsulation( :encapsulation_name ).should == Encapsulation
+    end
+  end
+
+  ############################
+  #  register_configuration  #
+  #  has_configurations?     #
+  #  has_configuration?      #
+  #  configuration_names     #
+  #  remove_configuration    #
+  ############################
+  
+  it 'can hold configurations' do
+    module ::CascadingConfiguration::Core::Encapsulation::ConfigurationsMock
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      ForInstance = ::Module.new
+      CCMMock = ::Module.new do
+        def self.create_configuration( encapsulation, instance, this_name )
+        end
+        def self.initialize_configuration( encapsulation, instance, this_name )
+        end
+      end
+      Encapsulation.instance_eval do
+        has_configurations?( ForInstance ).should == false
+        has_configuration?( ForInstance, :some_configuration ).should == false
+        configuration_names( ForInstance ).should == [ ]
+        register_configuration( ForInstance, :some_configuration, CCMMock )
+        has_configurations?( ForInstance ).should == true
+        has_configuration?( ForInstance, :some_configuration ).should == true
+        configuration_names( ForInstance ).should == [ :some_configuration ]
+        remove_configuration( ForInstance, :some_configuration )
+        has_configurations?( ForInstance ).should == false
+        has_configuration?( ForInstance, :some_configuration ).should == false
+        configuration_names( ForInstance ).should == [ ]
+      end
+    end
+  end
+
+  #######################################
+  #  register_child_for_parent          #
+  #  parent_for_configuration           #
+  #  register_parent_for_configuration  #
+  #######################################
+  
+  it 'can register children for parents' do
+    module ::CascadingConfiguration::Core::Encapsulation::ParentsMock
+      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
+      Parent = ::Module.new
+      Child = ::Module.new
+      AnotherParent = ::Module.new
+      Encapsulation.module_eval do
+        register_configuration( Parent, :some_configuration, CCMMock )
+        register_child_for_parent( Child, Parent )
+        has_configuration?( Child, :some_configuration ).should == true
+        parent_for_configuration( Child, :some_configuration ).should == Parent
+        register_configuration( Child, :some_other_configuration, CCMMock )
+        register_parent_for_configuration( Child, AnotherParent, :some_other_configuration )
+        has_configuration?( Child, :some_other_configuration ).should == true
+        parent_for_configuration( Child, :some_other_configuration ).should == AnotherParent
+        parents( Child ).include?( AnotherParent ).should == true
+      end
+    end
+  end
+
+  ##############################
+  #  parent_for_configuration  #
+  ##############################
+  
+  it 'can find the next ancestor for a configuration name' do
+    module ::CascadingConfiguration::Core::Encapsulation::ParentForConfigurationMock
+    
+      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
+    
+      module MockA
+        class << self
+          attr_accessor :config_A
+        end
+      end      
+      Encapsulation.register_configuration( MockA, :config_A, CCMMock )
+
+      module MockB
+        class << self
+          attr_accessor :config_A, :config_B
+        end
+      end
+      Encapsulation.register_child_for_parent( MockB, MockA )
+      Encapsulation.register_configuration( MockB, :config_A, CCMMock )
+      Encapsulation.register_configuration( MockB, :config_B, CCMMock )
+    
+      module MockC1
+        class << self
+          attr_accessor :config_A, :config_B, :config_C1
+        end
+      end
+      Encapsulation.register_child_for_parent( MockC1, MockB )
+      Encapsulation.register_configuration( MockC1, :config_A, CCMMock )
+      Encapsulation.register_configuration( MockC1, :config_B, CCMMock )
+      Encapsulation.register_configuration( MockC1, :config_C1, CCMMock )
+
+      module MockC2
+        class << self
+          attr_accessor :config_A, :config_B, :config_C2
+        end
+      end
+      Encapsulation.register_child_for_parent( MockC2, MockB )
+      Encapsulation.register_configuration( MockC2, :config_A, CCMMock )
+      Encapsulation.register_configuration( MockC2, :config_B, CCMMock )
+      Encapsulation.register_configuration( MockC2, :config_C2, CCMMock )
+
+      module MockD
+        class << self
+          attr_accessor :config_A, :config_B, :config_C1, :config_C2
+        end
+      end
+    
+      Encapsulation.instance_eval do
+    
+        register_child_for_parent( MockD, MockC1 )
+        register_child_for_parent( MockD, MockC2 )
+        register_configuration( MockD, :config_A, CCMMock )
+        register_configuration( MockD, :config_B, CCMMock )
+        register_configuration( MockD, :config_C1, CCMMock )
+        register_configuration( MockD, :config_C2, CCMMock )
+      
+        parent_for_configuration( MockD, :config_A ).should == MockC2
+        parent_for_configuration( MockD, :config_B ).should == MockC2
+        parent_for_configuration( MockD, :config_C1 ).should == MockC1
+        parent_for_configuration( MockD, :config_C2 ).should == MockC2
+      
+        parent_for_configuration( MockC2, :config_A ).should == MockB
+        parent_for_configuration( MockC2, :config_B ).should == MockB
+        parent_for_configuration( MockC2, :config_C1 ).should == nil
+        parent_for_configuration( MockC2, :config_C2 ).should == nil
+      
+        parent_for_configuration( MockC1, :config_A ).should == MockB
+        parent_for_configuration( MockC1, :config_B ).should == MockB
+        parent_for_configuration( MockC1, :config_C1 ).should == nil
+        parent_for_configuration( MockC1, :config_C2 ).should == nil
+      
+        parent_for_configuration( MockB, :config_A ).should == MockA
+        parent_for_configuration( MockB, :config_B ).should == nil
+        parent_for_configuration( MockB, :config_C1 ).should == nil
+        parent_for_configuration( MockB, :config_C2 ).should == nil
+      
+        parent_for_configuration( MockA, :config_A ).should == nil
+        parent_for_configuration( MockA, :config_B ).should == nil
+        parent_for_configuration( MockA, :config_C1 ).should == nil
+        parent_for_configuration( MockA, :config_C2 ).should == nil
+      
+      end
+    
+    end
+    
+  end
+
+  ###################################
+  #  set_configuration              #
+  #  get_configuration              #
+  #  has_configuration_value?       #
+  #  configuration_variables        #
+  #  remove_configuration_variable  #
+  ###################################
+  
+  it 'can set, get and remove configuration variables' do
+    module ::CascadingConfiguration::Core::Encapsulation::ConfigurationVariableMock
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+      ForInstance = ::Module.new
+      Encapsulation.instance_eval do
+        has_configuration_value?( ForInstance, :some_variable ).should == false
+        set_configuration( ForInstance, :some_variable, :some_value )
+        has_configuration_value?( ForInstance, :some_variable ).should == true
+        get_configuration( ForInstance, :some_variable ).should == :some_value
+        configuration_variables( ForInstance ).should == { :some_variable => :some_value }
+        remove_configuration_variable( ForInstance, :some_variable )
+        configuration_variables( ForInstance ).should == { }
+        has_configuration_value?( ForInstance, :some_variable ).should == false
+      end
+    end
+  end
+
+end

data/spec/cascading_configuration/core/instance_controller/extension_module_spec.rb

@@ -0,0 +1,26 @@
+
+require_relative '../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::InstanceController::ExtensionModule do
+
+  ################
+  #  initialize  #
+  ################
+  
+  it 'can create a module for use with an instance for dynamic definition' do
+    module ::CascadingConfiguration::Core::InstanceController::ExtensionModule::InitializeMock
+
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+
+      Module_instance = ::CascadingConfiguration::Core::InstanceController::ExtensionModule.new( InstanceController, Encapsulation, :some_configuration )
+
+      Module_instance.instance_controller.should == InstanceController
+      Module_instance.encapsulation.should == Encapsulation
+      Module_instance.configuration_name.should == :some_configuration
+
+    end
+  end
+
+end

data/spec/cascading_configuration/core/instance_controller/support_module_spec.rb

@@ -0,0 +1,269 @@
+
+require_relative '../../../../lib/cascading_configuration.rb'
+
+describe ::CascadingConfiguration::Core::InstanceController::SupportModule do
+
+  ################
+  #  initialize  #
+  ################
+  
+  it 'can create a module for use with an instance for dynamic definition' do
+    module ::CascadingConfiguration::Core::InstanceController::SupportModule::InitializeMock
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      Encapsulation = ::CascadingConfiguration::Core::Encapsulation.new( :some_encapsulation )
+      Module_instance = ::CascadingConfiguration::Core::InstanceController::SupportModule.new( InstanceController, Encapsulation, :some_type )
+      ForInstance.ancestors.include?( Module_instance ).should == false
+      ForInstance.is_a?( Module_instance ).should == false
+    end
+  end
+
+  ###################
+  #  super_modules  #
+  ###################
+  
+  it 'can return the first super module on each parent tree' do
+    module ::CascadingConfiguration::Core::InstanceController::SuperModulesMock
+
+      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
+
+      # set up hierarchy
+      ForInstance_A = ::Module.new
+      Encapsulation.register_configuration( ForInstance_A, :some_configuration, CCMMock )
+      InstanceController_A = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_A )
+      
+      Module_A = InstanceController_A.create_support( :some_type )
+      ForInstance_B1 = ::Module.new do
+        include ForInstance_A
+      end
+      Encapsulation.register_configuration( ForInstance_B1, :some_other_configuration, CCMMock )
+      Encapsulation.register_child_for_parent( ForInstance_B1, ForInstance_A )
+      ForInstance_B2 = ::Module.new do
+        include ForInstance_A
+      end
+      Encapsulation.register_child_for_parent( ForInstance_B2, ForInstance_A )
+      ForInstance_C1 = ::Module.new do
+        include ForInstance_B1
+      end
+      Encapsulation.register_configuration( ForInstance_C1, :yet_another_configuration, CCMMock )
+      Encapsulation.register_child_for_parent( ForInstance_C1, ForInstance_B1 )
+      ForInstance_C2 = ::Module.new do
+        include ForInstance_B1
+      end
+      Encapsulation.register_child_for_parent( ForInstance_C2, ForInstance_B1 )
+      ForInstance_D = ::Module.new do
+        include ForInstance_B2
+        include ForInstance_C1
+        include ForInstance_C2
+      end
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_B2 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C1 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C2 )
+      Module_A.super_modules.empty?.should == true
+      InstanceController_B2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B2 )
+      Module_B2 = InstanceController_B2.create_support( :some_type )
+      Module_B2.super_modules.should == [ Module_A ]
+      InstanceController_C1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C1 )
+      Module_C1 = InstanceController_C1.create_support( :some_type )
+      Module_B2.super_modules.should == [ Module_A ]
+      Module_C1.super_modules.should == [ Module_A ]
+      InstanceController_C2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C2 )
+      Module_C2 = InstanceController_C2.create_support( :some_type )
+      Module_B2.super_modules.should == [ Module_A ]
+      Module_C1.super_modules.should == [ Module_A ]
+      Module_C2.super_modules.should == [ Module_A ]
+      InstanceController_B1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B1 )
+      Module_B1 = InstanceController_B1.create_support( :some_type )
+      Module_B1.super_modules.should == [ Module_A ]
+      Module_B2.super_modules.should == [ Module_A ]
+      Module_C1.super_modules.should == [ Module_B1 ]
+      Module_C2.super_modules.should == [ Module_B1 ]
+      InstanceController_D = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_D )
+      Module_D = InstanceController_D.create_support( :some_type )
+      Module_B1.super_modules.should == [ Module_A ]
+      Module_B2.super_modules.should == [ Module_A ]
+      Module_C1.super_modules.should == [ Module_B1 ]
+      Module_C2.super_modules.should == [ Module_B1 ]
+      Module_D.super_modules.should == [ Module_C2, Module_C1, Module_B2 ]
+    end
+  end
+  
+  ###################
+  #  child_modules  #
+  ###################
+  
+  it 'can return the first child module on each child tree' do
+    module ::CascadingConfiguration::Core::InstanceController::ChildModulesMock
+
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+
+      # set up hierarchy
+      ForInstance_A = ::Module.new do
+        # we have to mock the method bc that's how the module determines if it has a configuration defined
+        # since we don't know whether a configuration value has been set yet
+        attr_accessor :some_configuration
+      end
+      InstanceController_A = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_A )
+      Module_A = InstanceController_A.create_support( :some_type )
+      ForInstance_B1 = ::Module.new do
+        # we have to mock the method bc that's how the module determines if it has a configuration defined
+        # since we don't know whether a configuration value has been set yet
+        attr_accessor :some_other_configuration
+        include ForInstance_A
+      end
+      Encapsulation.register_child_for_parent( ForInstance_B1, ForInstance_A )
+      ForInstance_B2 = ::Module.new do
+        include ForInstance_A
+      end
+      Encapsulation.register_child_for_parent( ForInstance_B2, ForInstance_A )
+      ForInstance_C1 = ::Module.new do
+        include ForInstance_B1
+        attr_accessor :yet_another_configuration
+      end
+      Encapsulation.register_child_for_parent( ForInstance_C1, ForInstance_B1 )
+      ForInstance_C2 = ::Module.new do
+        include ForInstance_B1
+      end
+      Encapsulation.register_child_for_parent( ForInstance_C2, ForInstance_B1 )
+      ForInstance_D = ::Module.new do
+        include ForInstance_B2
+        include ForInstance_C1
+        include ForInstance_C2
+      end
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_B2 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C1 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C2 )
+      InstanceController_B2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B2 )
+      Module_B2 = InstanceController_B2.create_support( :some_type )
+      InstanceController_C1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C1 )
+      Module_C1 = InstanceController_C1.create_support( :some_type )
+      InstanceController_C2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C2 )
+      Module_C2 = InstanceController_C2.create_support( :some_type )
+      InstanceController_B1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B1 )
+      Module_B1 = InstanceController_B1.create_support( :some_type )
+      InstanceController_D = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_D )
+      Module_D = InstanceController_D.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_B1, Module_B2 ]
+      Module_B1.child_modules.should == [ Module_C1, Module_C2 ]
+      Module_B2.child_modules.should == [ Module_D ]
+      Module_C1.child_modules.should == [ Module_D ]
+      Module_C2.child_modules.should == [ Module_D ]
+      Module_D.child_modules.empty?.should == true
+    end
+  end
+  
+  ###########################################
+  #  cascade_new_support_for_child_modules  #
+  ###########################################
+  
+  it 'can return the first child module on each child tree' do
+    module ::CascadingConfiguration::Core::InstanceController::CascadeNewSupportForChildModulesMock
+
+      Encapsulation = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+
+      # set up hierarchy
+      ForInstance_A = ::Module.new do
+        # we have to mock the method bc that's how the module determines if it has a configuration defined
+        # since we don't know whether a configuration value has been set yet
+        attr_accessor :some_configuration
+      end
+      InstanceController_A = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_A )
+      Module_A = InstanceController_A.create_support( :some_type )
+      ForInstance_B1 = ::Module.new do
+        # we have to mock the method bc that's how the module determines if it has a configuration defined
+        # since we don't know whether a configuration value has been set yet
+        attr_accessor :some_other_configuration
+        include ForInstance_A
+      end
+      Encapsulation.register_child_for_parent( ForInstance_B1, ForInstance_A )
+      ForInstance_B2 = ::Module.new do
+        include ForInstance_A
+      end
+      Encapsulation.register_child_for_parent( ForInstance_B2, ForInstance_A )
+      ForInstance_C1 = ::Module.new do
+        include ForInstance_B1
+        attr_accessor :yet_another_configuration
+      end
+      Encapsulation.register_child_for_parent( ForInstance_C1, ForInstance_B1 )
+      ForInstance_C2 = ::Module.new do
+        include ForInstance_B1
+      end
+      Encapsulation.register_child_for_parent( ForInstance_C2, ForInstance_B1 )
+      ForInstance_D = ::Module.new do
+        include ForInstance_B2
+        include ForInstance_C1
+        include ForInstance_C2
+      end
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_B2 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C1 )
+      Encapsulation.register_child_for_parent( ForInstance_D, ForInstance_C2 )
+      Module_A.child_modules.empty?.should == true
+      InstanceController_C2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C2 )
+      Module_C2 = InstanceController_C2.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_C2 ]
+      Module_C2.child_modules.empty?.should == true
+      InstanceController_B2 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B2 )
+      Module_B2 = InstanceController_B2.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_C2, Module_B2 ]
+      Module_B2.child_modules.empty?.should == true
+      Module_C2.child_modules.empty?.should == true
+      InstanceController_C1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_C1 )
+      Module_C1 = InstanceController_C1.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_C1, Module_C2, Module_B2 ]
+      Module_B2.child_modules.empty?.should == true
+      Module_C1.child_modules.empty?.should == true
+      Module_C2.child_modules.empty?.should == true
+      InstanceController_D = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_D )
+      Module_D = InstanceController_D.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_C1, Module_C2, Module_B2 ]
+      Module_B2.child_modules.should == [ Module_D ]
+      Module_C1.child_modules.should == [ Module_D ]
+      Module_C2.child_modules.should == [ Module_D ]
+      Module_D.child_modules.empty?.should == true
+      InstanceController_B1 = ::CascadingConfiguration::Core::InstanceController.new( ForInstance_B1 )
+      Module_B1 = InstanceController_B1.create_support( :some_type )
+      Module_A.child_modules.should == [ Module_B1, Module_B2 ]
+      Module_B1.child_modules.should == [ Module_C1, Module_C2 ]
+      Module_B2.child_modules.should == [ Module_D ]
+      Module_C1.child_modules.should == [ Module_D ]
+      Module_C2.child_modules.should == [ Module_D ]
+      Module_D.child_modules.empty?.should == true
+    end
+  end
+  
+  ###################
+  #  define_method  #
+  #  alias_method   #
+  #  remove_method  #
+  #  undef_method   #
+  ###################
+  
+  it 'can define a method in the configuration module, ensuring the module exists first' do
+    module ::CascadingConfiguration::Core::InstanceController::DefineAliasRemoveUndefMock
+      ForInstance = ::Module.new
+      InstanceController = ::CascadingConfiguration::Core::InstanceController.new( ForInstance )
+      Module_instance = InstanceController.create_support( :some_type )
+      Module_instance.define_method( :some_method ) do
+        return :some_method
+      end
+      Module_instance.method_defined?( :some_method ).should == true
+      Module_instance.alias_method( :some_alias, :some_method )
+      Module_instance.method_defined?( :some_method ).should == true
+      Module_instance.method_defined?( :some_alias ).should == true
+      Module_instance.remove_method( :some_alias ).should == true
+      Module_instance.method_defined?( :some_alias ).should == false
+      Module_instance.remove_method( :some_alias ).should == false
+      Module_instance.undef_method( :some_method ).should == true
+      Module_instance.method_defined?( :some_method ).should == false
+      Module_instance.undef_method( :some_method ).should == false
+    end
+  end
+
+end