cascading_configuration 1.0.0

data/lib/cascading_configuration/core/enable_instance_support.rb

@@ -0,0 +1,22 @@
+
+module ::CascadingConfiguration::Core::EnableInstanceSupport
+
+  ##############
+  #  included  #
+  ##############
+  
+  def included( instance )
+    
+    super if defined?( super )
+    
+    # Ensure our instance has an instance controller
+    unless instance_controller = ::CascadingConfiguration::Core::InstanceController.instance_controller( instance )
+      default_encapsulation = self::ClassInstance.default_encapsulation
+      instance_controller = ::CascadingConfiguration::Core::InstanceController.new( instance, default_encapsulation )
+    end
+
+    instance_controller.create_instance_support
+    
+  end
+  
+end

data/lib/cascading_configuration/core/enable_module_support.rb

@@ -0,0 +1,24 @@
+
+module ::CascadingConfiguration::Core::EnableModuleSupport
+  
+  ##############
+  #  extended  #
+  ##############
+  
+  def extended( instance )
+    
+    super if defined?( super )
+    
+    # Ensure our instance has an instance controller
+    unless instance_controller = ::CascadingConfiguration::Core::InstanceController.instance_controller( instance )
+      instance_controller = ::CascadingConfiguration::Core::InstanceController.new( instance, 
+                                                                                    @default_encapsulation,
+                                                                                    :Controller,
+                                                                                    true )
+    end
+
+    instance_controller.create_singleton_support
+    
+  end
+
+end

data/lib/cascading_configuration/core/encapsulation.rb

@@ -0,0 +1,343 @@
+
+class ::CascadingConfiguration::Core::Encapsulation < ::Module
+
+  include ::ParallelAncestry
+
+  InstanceStruct = ::Struct.new( :configuration_variables_hash, 
+                                 :configurations_hash, 
+                                 :parent_for_configuration_hash )
+
+  @encapsulations = { }
+
+  ########################
+  #  self.encapsulation  #
+  ########################
+  
+  def self.encapsulation( encapsulation_or_name, ensure_exists = false )
+    
+    encapsulation_instance = nil
+
+    case encapsulation_or_name
+      
+      when nil
+        
+        encapsulation_instance = ::CascadingConfiguration::Core::Module::DefaultEncapsulation
+        
+      when self
+      
+        encapsulation_instance = encapsulation_or_name
+      
+      when ::Symbol, ::String
+
+        unless encapsulation_instance = @encapsulations[ encapsulation_or_name ]
+          if ensure_exists
+            exception_string = 'No encapsulation defined for :' << encapsulation_or_name.to_s
+            exception_string << '.'
+            raise ::ArgumentError, exception_string
+          end
+        end
+
+    end
+    
+    return encapsulation_instance
+    
+  end
+
+  ################
+  #  initialize  #
+  ################
+  
+  def initialize( encapsulation_name )
+
+    super()
+    
+    @encapsulation_name = encapsulation_name
+    
+    encapsulation_instance = self
+    
+    # We manage reference to self in singleton from here to avoid duplicative efforts.
+    self.class.class_eval do
+      @encapsulations[ encapsulation_name ] = encapsulation_instance
+      const_set( encapsulation_name.to_s.to_camel_case, encapsulation_instance )
+    end
+        
+    @instances_hash = { }
+    
+  end
+
+  ########################
+  #  encapsulation_name  #
+  ########################
+
+  attr_reader :encapsulation_name
+
+  #########################
+  #  has_configurations?  #
+  #########################
+  
+  def has_configurations?( instance )
+    
+    return ! configurations( instance ).empty?
+    
+  end
+
+  #########################
+  #  configuration_names  #
+  #########################
+  
+  def configuration_names( instance )
+    
+    return configurations( instance ).keys
+
+  end
+  
+  ############################
+  #  register_configuration  #
+  ############################
+  
+  def register_configuration( instance, configuration_name, configuration_module )
+    
+    # Record that a configuration is defined for this instance.
+    # 
+    # This doesn't suggest that a configuration exists for this instance and name, only that it has 
+    # been registered to acknowledge it could exist.
+    return configurations( instance )[ configuration_name ] = configuration_module
+
+  end
+
+  ####################
+  #  configurations  #
+  ####################
+  
+  def configurations( instance )
+    
+    return configuration_struct( instance ).configurations_hash ||= { }
+
+  end
+  
+  ########################
+  #  has_configuration?  #
+  ########################
+
+  def has_configuration?( instance, configuration_name )
+
+    has_configuration = nil
+    
+    unless has_configuration = configurations( instance ).has_key?( configuration_name ) or 
+           instance == instance.class
+      has_configuration = configurations( instance.class ).has_key?( configuration_name )
+    end
+
+    return has_configuration
+
+  end
+
+  ##########################
+  #  remove_configuration  #
+  ##########################
+  
+  def remove_configuration( instance, configuration_name )
+    
+    return configurations( instance ).delete( configuration_name )
+
+  end
+
+  ###############################
+  #  register_child_for_parent  #
+  ###############################
+  
+  def register_child_for_parent( child, parent )
+
+    super
+    
+    # Modules already have configurations and if parent already has configurations 
+    unless parent.is_a?( ::Module ) or has_parents?( parent )
+      register_child_for_parent( parent, parent.class )
+    end
+    
+    parent_configurations = configurations( parent )
+
+    parent_configurations.each do |this_name, this_configuration_module|
+      register_configuration( child, this_name, this_configuration_module )
+      register_parent_for_configuration( child, parent, this_name )
+      this_configuration_module.create_configuration( self, child, this_name )
+    end
+
+    parent_configurations.each do |this_name, this_configuration_module|
+      this_configuration_module.initialize_configuration( self, child, this_name )
+    end
+    
+  end
+
+  ##################################
+  #  is_parent_for_configuration?  #
+  ##################################
+  
+  def is_parent_for_configuration?( existing_parent, configuration_name, parent )
+    
+    is_parent_for_configuration = false
+    
+    this_parent = existing_parent
+    
+    begin
+      
+      if this_parent.equal?( parent )
+        is_parent_for_configuration = true
+      end
+      
+    end while this_parent = parent_for_configuration( this_parent, configuration_name )
+    
+    return is_parent_for_configuration
+    
+  end
+  
+  #######################################
+  #  register_parent_for_configuration  #
+  #######################################
+  
+  def register_parent_for_configuration( child, parent, configuration_name )
+    
+    parents_hash = parent_for_configuration_hash( child )
+    
+    # if we already have a parent, check to see if new parent is an ancestor of it
+    # if so, keep existing parent
+    unless existing_parent = parents_hash[ configuration_name ] and
+           is_parent_for_configuration?( existing_parent, configuration_name, parent )
+
+      parents_hash[ configuration_name ] = parent
+    
+      parents( child ).unshift( parent )
+      
+    end
+        
+    return self
+    
+  end
+
+  ##############################
+  #  parent_for_configuration  #
+  ##############################
+  
+  def parent_for_configuration( instance, configuration_name )
+
+    unless instance.equal?( ::Class ) or 
+           parent = parent_for_configuration_hash( instance )[ configuration_name ]
+
+      instance_class = instance.class
+      if has_configuration?( instance_class, configuration_name )
+        parent = instance_class
+      end
+    end
+
+    return parent
+
+  end
+
+  #############################
+  #  configuration_variables  #
+  #############################
+  
+  def configuration_variables( instance )
+    
+    return configuration_struct( instance ).configuration_variables_hash ||= { }
+
+  end
+
+  #######################
+  #  set_configuration  #
+  #######################
+
+  def set_configuration( instance, configuration_name, value )
+
+    return configuration_variables( instance )[ configuration_name ] = value
+    
+  end
+
+  ##############################
+  #  has_configuration_value?  #
+  ##############################
+
+  def has_configuration_value?( instance, configuration_name )
+
+    return configuration_variables( instance ).has_key?( configuration_name )
+
+  end
+  
+  #######################
+  #  get_configuration  #
+  #######################
+  
+  def get_configuration( instance, configuration_name )
+    
+    return configuration_variables( instance )[ configuration_name ]
+
+  end
+
+  ###################################
+  #  remove_configuration_variable  #
+  ###################################
+  
+  def remove_configuration_variable( instance, configuration_name )
+    
+    return configuration_variables( instance ).delete( configuration_name )
+
+  end
+  
+  ##################
+  #  match_parent  #
+  ##################
+  
+  def match_parent( instance, configuration_name, & match_block )
+    
+    matched_parent = nil
+    
+    this_parent = instance
+    
+    begin
+      
+      if match_block.call( this_parent )
+        matched_parent = this_parent
+        break
+      end
+      
+    end while this_parent = parent_for_configuration( this_parent, configuration_name )
+    
+    return matched_parent
+    
+  end
+
+  ##################################################################################################
+      private ######################################################################################
+  ##################################################################################################
+
+  ##########################
+  #  configuration_struct  #
+  ##########################
+  
+  def configuration_struct( instance )
+    
+    configuration_struct = nil
+    
+    instance_id = instance.__id__
+    
+    unless configuration_struct = @instances_hash[ instance_id ]
+      # fill in slots lazily
+      configuration_struct = self.class::InstanceStruct.new
+      @instances_hash[ instance_id ] = configuration_struct
+    end
+    
+    return configuration_struct
+    
+  end
+  
+  ###################################
+  #  parent_for_configuration_hash  #
+  ###################################
+  
+  def parent_for_configuration_hash( instance )
+    
+    return configuration_struct( instance ).parent_for_configuration_hash ||= { }
+
+  end
+  
+end

data/lib/cascading_configuration/core/instance_controller/extension_module.rb

@@ -0,0 +1,38 @@
+
+class ::CascadingConfiguration::Core::InstanceController::ExtensionModule < ::Module
+
+  ################
+  #  initialize  #
+  ################
+  
+  def initialize( instance_controller, encapsulation, configuration_name, & definer_block )
+    
+    @instance_controller = instance_controller
+    @encapsulation = encapsulation
+    @configuration_name = configuration_name
+    
+    if block_given?
+      module_eval( & definer_block )
+    end
+    
+  end
+
+  #########################
+  #  instance_controller  #
+  #########################
+
+  attr_reader :instance_controller
+
+  ###################
+  #  encapsulation  #
+  ###################
+
+  attr_reader :encapsulation
+  
+  ########################
+  #  configuration_name  #
+  ########################
+  
+  attr_reader :configuration_name
+      
+end

data/lib/cascading_configuration/core/instance_controller/support_module/instance_support_module.rb

@@ -0,0 +1,21 @@
+
+class ::CascadingConfiguration::Core::InstanceController::SupportModule::InstanceSupportModule < 
+      ::CascadingConfiguration::Core::InstanceController::SupportModule
+
+  ######################
+  #  is_super_module?  #
+  ######################
+  
+  def is_super_module?( module_instance )
+
+    is_super_module = false
+    
+    if is_super_module = super
+      is_super_module = module_instance.included?( @instance_controller.instance )
+    end
+    
+    return is_super_module
+    
+  end
+
+end

data/lib/cascading_configuration/core/instance_controller/support_module/singleton_support_module.rb

@@ -0,0 +1,21 @@
+
+class ::CascadingConfiguration::Core::InstanceController::SupportModule::SingletonSupportModule < 
+      ::CascadingConfiguration::Core::InstanceController::SupportModule
+
+  ######################
+  #  is_super_module?  #
+  ######################
+  
+  def is_super_module?( module_instance )
+    
+    is_super_module = false
+    
+    if is_super_module = super
+      is_super_module = module_instance.extended?( @instance_controller.instance )
+    end
+    
+    return is_super_module
+    
+  end
+
+end