cascading_configuration 1.0.0

data/lib/cascading_configuration/core/module/block_configurations/cascading_variables.rb

@@ -0,0 +1,129 @@
+
+class ::CascadingConfiguration::Core::Module::BlockConfigurations::CascadingVariables < 
+      ::CascadingConfiguration::Core::Module::BlockConfigurations
+
+  ##########################
+  #  create_configuration  #
+  ##########################
+
+  # Pending.
+  def create_configuration( encapsulation, instance, name )
+
+    unless compositing_object = encapsulation.get_configuration( instance, name )
+
+      super
+
+      # initialize without initializing for parents
+      # we will initialize for parents after initializing all instances for inheritance
+      compositing_object = @compositing_object_class.new( nil, instance )
+
+      instance_controller = ::CascadingConfiguration::Core::InstanceController.nearest_instance_controller( encapsulation, 
+                                                                                                      instance, 
+                                                                                                      name )
+
+      extension_modules = instance_controller.extension_modules_upward( name, encapsulation )
+    
+      unless extension_modules.empty?
+        # Modules are gathered from lowest ancestor upward. This means that they are already 
+        # in the proper order for include/extend (which usually we would have to reverse).
+        compositing_object.extend( *extension_modules )
+      end
+    
+      encapsulation.set_configuration( instance, name, compositing_object )    
+    
+      initialize_compositing_configuration_for_parent( encapsulation, instance, name )
+
+    end
+    
+    return compositing_object
+    
+  end
+
+  ############
+  #  setter  #
+  ############
+
+  # Pending.
+  def setter( encapsulation, instance, name, value )
+
+    return encapsulation.set_configuration( instance, name, value )
+
+  end
+
+  ############
+  #  getter  #
+  ############
+
+  # Pending.
+  def getter( encapsulation, instance, name )
+
+    return encapsulation.get_configuration( instance, name )
+
+  end
+
+  #####################
+  #  instance_setter  #
+  #####################
+
+  # Pending.
+  def instance_setter( encapsulation, instance, name, value )
+
+    # ensure our compositing object already exists
+    instance_getter( encapsulation, instance, name, value )
+
+    # now we can set normally
+    return setter( encapsulation, instance, name, value )
+
+  end
+
+  #####################
+  #  instance_getter  #
+  #####################
+
+  # Pending.
+  def instance_getter( encapsulation, instance, name )
+
+    cascading_value = nil
+    
+    if encapsulation.has_configuration_value?( instance, name )
+      cascading_value = encapsulation.get_configuration( instance, name )
+    else
+      cascading_value = initialize_configuration_for_parent( encapsulation, instance, configuration_name )
+    end
+
+    return cascading_value
+
+  end
+
+  #####################################################
+  #  initialize_compositing_configuration_for_parent  #
+  #####################################################
+  
+  # Pending.
+  def initialize_compositing_configuration_for_parent( encapsulation, instance, configuration_name )
+
+    unless compositing_object = encapsulation.get_configuration( instance, configuration_name )
+      compositing_object = create_configuration( encapsulation, instance, configuration_name )
+    end
+    
+    # if instance has a parent
+    if parent = encapsulation.parent_for_configuration( instance, configuration_name )
+
+      # if first parent for configuration isn't initialized yet, initialize it
+      unless parent_composite_object = encapsulation.get_configuration( parent, configuration_name )
+        parent_composite_object = initialize_compositing_configuration_for_parent( encapsulation, 
+                                                                                   parent, 
+                                                                                   configuration_name )
+      end
+      
+      unless compositing_object.parent_composite_object == parent_composite_object
+        compositing_object.initialize_for_parent( parent_composite_object )
+      end
+      
+    end
+
+    return compositing_object
+  
+  end
+
+end

data/lib/cascading_configuration/core/module/block_configurations.rb

@@ -0,0 +1,15 @@
+
+class ::CascadingConfiguration::Core::Module::BlockConfigurations < ::CascadingConfiguration::Core::Module
+
+  ###########################
+  #  define_configurations  #
+  ###########################
+  
+  # Pending.
+  def define_configurations( instance_controller, encapsulation, method_types, *names, & definer_block )
+    
+    super
+    
+  end
+
+end

data/lib/cascading_configuration/core/module/extended_configurations/compositing_objects.rb

@@ -0,0 +1,173 @@
+
+class ::CascadingConfiguration::Core::Module::ExtendedConfigurations::CompositingObjects < 
+      ::CascadingConfiguration::Core::Module::ExtendedConfigurations
+  
+  ################
+  #  initialize  #
+  ################
+  
+  def initialize( ccm_name, 
+                  compositing_object_class = nil,
+                  default_encapsulation_or_encapsulation_name = ::CascadingConfiguration::Core::
+                                                                  Module::DefaultEncapsulation, 
+                  *ccm_aliases )
+    
+    super( ccm_name, default_encapsulation_or_encapsulation_name, *ccm_aliases )
+    
+    @compositing_object_class = compositing_object_class
+    
+  end
+
+  ##########################
+  #  create_configuration  #
+  ##########################
+
+  def create_configuration( encapsulation, instance, name )
+    
+    unless compositing_object = encapsulation.get_configuration( instance, name )
+    
+      super
+
+      # initialize without initializing for parents
+      # we will initialize for parents after initializing all instances for inheritance
+      compositing_object = @compositing_object_class.new( nil, instance )
+
+      instance_controller = ::CascadingConfiguration::Core::
+                              InstanceController.nearest_instance_controller( encapsulation, instance, name )
+  
+      if instance_controller
+      
+        extension_modules = instance_controller.extension_modules_upward( name, encapsulation )
+    
+        unless extension_modules.empty?
+          # Modules are gathered from lowest ancestor upward. This means that they are already 
+          # in the proper order for include/extend (which usually we would have to reverse).
+          compositing_object.extend( *extension_modules )
+        end
+    
+      end
+        
+      encapsulation.set_configuration( instance, name, compositing_object )    
+    
+    end
+    
+    return compositing_object
+    
+  end
+
+  ##############################
+  #  initialize_configuration  #
+  ##############################
+  
+  def initialize_configuration( encapsulation, instance, name )
+    
+    initialize_compositing_configuration_for_parent( encapsulation, instance, name )
+    
+  end
+
+  ##############################
+  #  compositing_object_class  #
+  ##############################
+  
+  attr_reader :compositing_object_class
+
+  ############
+  #  setter  #
+  ############
+  
+  def setter( encapsulation, instance, name, value )
+    
+    compositing_object = encapsulation.get_configuration( instance, name )
+
+    compositing_object.replace( value )
+
+    return compositing_object
+    
+  end
+  
+  #####################
+  #  instance_setter  #
+  #####################
+  
+  def instance_setter( encapsulation, instance, name, value )
+    
+    # ensure our compositing object already exists
+    instance_getter( encapsulation, instance, name )
+    
+    # now we can set normally
+    return setter( encapsulation, instance, name, value )
+    
+  end
+  
+  ############
+  #  getter  #
+  ############
+
+  def getter( encapsulation, instance, name )
+        
+    return encapsulation.get_configuration( instance, name )
+    
+  end
+
+  #####################
+  #  instance_getter  #
+  #####################
+  
+  def instance_getter( encapsulation, instance, name )
+    
+    compositing_object = nil
+
+    unless compositing_object = encapsulation.get_configuration( instance, name )
+      compositing_object = initialize_compositing_configuration_for_parent( encapsulation, instance, name )
+    end
+
+    return compositing_object
+    
+  end
+
+  #####################################################
+  #  initialize_compositing_configuration_for_parent  #
+  #####################################################
+  
+  def initialize_compositing_configuration_for_parent( encapsulation, instance, configuration_name )
+
+    unless compositing_object = encapsulation.get_configuration( instance, configuration_name )
+      compositing_object = create_configuration( encapsulation, instance, configuration_name )
+    end
+    
+    # if instance has a parent
+    if parent = encapsulation.parent_for_configuration( instance, configuration_name )
+
+      # We are initializing for existing ancestors, but they may not have initialized yet - 
+      # so we need to make sure they did before we initialize for instance.
+      
+      # As long as our ancestor has an ancestor make sure that it has initialized for its parent.
+      # We can break at the first ancestor that we hit that has initialized for parent
+      # or if we run out of ancestors.
+
+      parent_composite_object = encapsulation.get_configuration( parent, configuration_name )
+      parent_composite_object2 = nil
+      if parent2 = encapsulation.parent_for_configuration( parent, configuration_name )
+        parent_composite_object2 = encapsulation.get_configuration( parent2, configuration_name )
+      end
+      
+      # if first parent for configuration isn't initialized yet, initialize it
+      unless parent_composite_object and
+             parent_composite_object.parent_composite_object.equal?( parent_composite_object2 )
+
+        parent_composite_object = initialize_compositing_configuration_for_parent( encapsulation, 
+                                                                                   parent, 
+                                                                                   configuration_name )
+      end
+
+      unless compositing_object.parent_composite_object.equal?( parent_composite_object )
+        compositing_object.initialize_for_parent( parent_composite_object )
+      end
+      
+    end
+
+    return compositing_object
+  
+  end
+
+end

data/lib/cascading_configuration/core/module/extended_configurations.rb

@@ -0,0 +1,65 @@
+
+class ::CascadingConfiguration::Core::Module::ExtendedConfigurations < ::CascadingConfiguration::Core::Module
+
+  ##################################
+  #  self.parse_extension_modules  #
+  ##################################
+  
+  def self.parse_extension_modules( instance_controller, encapsulation, *names_modules )
+    
+    # We can have configuration names or modules - we need to separate them.
+    names = [ ]
+    modules = [ ]
+
+    names_modules.each do |this_name_or_module|
+
+      case this_name_or_module
+        
+        when ::Class
+
+          raise ArgumentError, 'Module expected (received Class).'
+        
+        when ::Module
+
+          modules.push( this_name_or_module )
+
+        else
+        
+          names.push( this_name_or_module )
+        
+      end
+      
+    end
+    
+    names_modules_hash = { }
+    
+    # if we have a block to define extensions to the compositing object:
+      
+    names.each do |this_name|
+      names_modules_hash[ this_name ] = modules
+    end
+    
+    return names_modules_hash
+    
+  end
+
+  ###########################
+  #  define_configurations  #
+  ###########################
+  
+  def define_configurations( instance_controller, encapsulation, method_types, *names_modules, & definer_block )
+    
+    # Ask MethodModule to parse extension modules for these declarations on instance.
+    names_modules_hash = self.class.parse_extension_modules( instance_controller, encapsulation, *names_modules )
+    
+    names_modules_hash.each do |this_name, these_modules|
+      instance_controller.add_extension_modules( this_name, encapsulation, *these_modules, & definer_block )
+    end
+    
+    names = names_modules_hash.keys
+
+    super( instance_controller, encapsulation, method_types, *names, & definer_block )
+    
+  end
+
+end

data/lib/cascading_configuration/core/module/inheriting_values.rb

@@ -0,0 +1,64 @@
+
+class ::CascadingConfiguration::Core::Module::InheritingValues < ::CascadingConfiguration::Core::Module
+  
+  ############
+  #  setter  #
+  ############
+  
+  def setter( encapsulation, instance, name, value )
+    
+    return encapsulation.set_configuration( instance, name, value )
+    
+  end
+  
+  ############
+  #  getter  #
+  ############
+
+  def getter( encapsulation, instance, name )
+    
+    return get_configuration_searching_upward( encapsulation, instance, name )
+    
+  end
+
+  #####################
+  #  instance_getter  #
+  #####################
+
+  alias_method( :instance_getter, :getter )
+
+  #####################
+  #  instance_setter  #
+  #####################
+  
+  alias_method( :instance_setter, :setter )
+
+  ########################################
+  #  get_configuration_searching_upward  #
+  ########################################
+
+  def get_configuration_searching_upward( encapsulation, instance, configuration_name )
+
+    configuration_value = nil
+
+    matching_ancestor = nil
+
+    did_match_ancestor = false
+
+    matching_ancestor = encapsulation.match_parent( instance, configuration_name ) do |this_ancestor|
+      if encapsulation.has_configuration_value?( this_ancestor, configuration_name )
+        did_match_ancestor = true
+      else
+        false
+      end
+    end
+
+    if did_match_ancestor
+      configuration_value = encapsulation.get_configuration( matching_ancestor, configuration_name )
+    end
+    
+    return configuration_value
+    
+  end
+  
+end