cascading_configuration 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,40 @@
+
+## 6/18/2012 ##
+
+Moved cascading_configuration-ancestors to a new independent gem: parallel-ancestry.
+
+Now with Less Magic™ and more Tasty Sandwiches™!
+
+Condensed cascading_configuration-variable, cascading_configuration-methods, cascading_configuration-definition, cascading_configuration-inheritance, cascading_configuration-module, cascading_configuration-setting, cascading_configuration-array, cascading_configuration-array-unique, cascading_configuration-array-sorted, cascading_configuration-sorted-unique, cascading_configuration-hash into a single gem with core support.
+
+Adding new modules is now incredibly easy, and all the old spaghetti internal code is gone.
+
+## 6/19/2012 ##
+
+Fix for multiple arguments.
+
+README updates.
+
+Removed Methods module and submodules - methods moved into InstanceController directly.
+
+Fixed parameters for alias methods on InstanceController.
+
+Changed inheritance for extends to behave like module inheritance. Now extending an instance with a CCM-enabled module will cause instance methods to be appended to extended instances eigenclass chain; singleton methods will not cascade for extend.
+
+Fixed Class instance configuration lookups.
+
+Fixed for FalseClass.
+
+Fixed for Object.
+
+## 6/24/2012 ##
+
+Added Instance and Singleton support module subclasses - fixes case where singleton support is created after extending with an instance with singleton support, causing the extending instance's singleton support to be both improperly included and below the instance, stomping any of its methods.
+
+Added :initialize_configuration to CascadingConfiguration::Core::Module; subclasses override to perform object initialization post-creation. This is so that objects are initialized only after all objects have been instantiated.
+
+## 6/27/2012 ##
+
+Renamed project from cascading-configuration to cascading_configuration to match Rubygems guidelines for gem naming.
+Ensured configurations don't re-register parents that are higher in the ancestor chain than the ones already registered.
+

data/README.md

@@ -0,0 +1,211 @@
+# Cascading Configuration #
+
+http://rubygems.org/gems/cascading_configuration
+
+# Summary #
+
+Provides inheritable values across Ruby inheritance hierarchy or across arbitrary declared inheritance relations.
+
+# Description #
+
+Inheritable Objects and Downward-Compositing Hashes and Arrays; Downward-Transforming Values coming soon.
+
+# Install #
+
+* sudo gem install cascading_configuration
+
+# Usage #
+
+Since CascadingConfiguration produces configurations for both singletons and instances, include or extend of a CascadingConfiguration module (for instance CascadingConfiguration::Setting) also causes the including instance to be extended by module::ClassInstance (ie CascadingConfiguration::Setting::ClassInstance).
+
+The result is that extending will enable only the singleton, whereas including will enable both singleton and instances.
+
+Each module supports the same pattern for naming methods it provides.
+
+The module has a name, which is used in each of the method types:
+
+```ruby
+:setting                # =>  :attr_setting
+:hash                   # =>  :attr_hash
+:array                  # =>  :attr_array
+:unique_array           # =>  :attr_unique_array
+:sorted_array           # =>  :attr_sorted_array
+:sorted_unique_array    # =>  :attr_sorted_unique_array
+```
+
+For backwards compatibility, these methods are also available:
+
+```ruby
+:attr_configuration
+:attr_configuration_hash
+:attr_configuration_array
+:attr_configuration_unique_array
+:attr_configuration_sorted_array
+:attr_configuration_sorted_unique_array
+```
+
+## Base Method Naming Pattern ##
+
+There are 5 types of base methods:
+
+### :attr\_[module\_name] ###
+
+Cascading methods, which will affect instances according to include/extend pattern used.
+
+### :attr\_module\_[module\_name] and attr\_class\_[module\_name] ###
+
+Cascading module/class methods, which will affect all module singletons according to include/extend pattern used.
+
+### :attr\_instance\_[module\_name] ###
+
+Cascading instance methods, which will affect instances of including modules according to include/extend pattern used.
+
+### :attr\_local\_[module\_name] ###
+
+Non-cascading methods that will affect the instance declared on as well as instances of that instance, if applicable.
+
+### :attr\_object\_[module\_name] ###
+
+Non-cascading methods that will affect only the instance declared on.
+
+## Inheritable Objects ##
+
+Inheritable Objects are values received from an ancestor:
+
+```ruby
+module ModuleA
+  include CascadingConfiguration::Setting
+  attr_setting  :some_setting
+  self.some_setting = :some_value
+end
+
+class ClassA
+  include ModuleA
+  self.some_setting = :some_other_value
+end
+
+class ClassB < ClassA
+  some_setting == :some_other_value
+  self.some_setting = :another_value
+end
+
+class ClassC < ClassB
+  some_setting == :another_value
+end
+```
+
+Simply put, the instance asked for the value will look up its ancestor chain until it finds an explicitly assigned value, which it returns.
+
+This is provided by:
+
+* CascadingConfiguration::Setting
+
+## Downward-Compositing Hashes and Arrays ##
+
+Whether Hashes or Arrays, the idea is the same. We call the Compositing Objects. They all work the same way (automatically):
+
+1. The compositing object is initialized with a reference to the configuration instance it is attached to.
+2. The compositing object is initialized (separately) for its immediate parent object.
+3. Whenever an update occurs, the compositing object updates its registered child object with the update.
+
+This way the lower objects are kept in sync with parent elements. Overriding hooked methods (provided by HookedArray from the hooked-array gem) provides a great deal of flexible functionality, permitting elements to be transformed as they are passed down the ancestor hierarchy.
+
+Right now there are 5 types of Compositing Objects:
+
+* CascadingConfiguration::Hash
+* CascadingConfiguration::Array
+* CascadingConfiguration::Array::Unique
+* CascadingConfiguration::Array::Sorted
+* CascadingConfiguration::Array::Sorted::Unique
+
+All work the same with the exception of differing compositing object types. All declarations of compositing object configurations also accept extension modules and/or a block that will be used to create an extension module. Extension modules will be used to extend the compositing object; extension modules automatically cascade along the ancestor hierarchy for a given configuration. 
+
+```ruby
+module ModuleA
+  include CascadingConfiguration::Array
+  attr_array  :some_array
+  some_array == [ ]
+  some_array.push( :some_value )
+  some_array == [ :some_value ]
+end
+
+class ClassA
+  include ModuleA
+  some_array == [ :some_value ]
+end
+
+class ClassB < ClassA
+  some_array == [ :some_value ]
+  some_array.push( :another_value )
+  some_array == [ :some_value, :another_value ]
+end
+
+class ClassC < ClassB
+  some_setting == :another_value
+  some_array.delete( :some_value )
+  some_array == [ :another_value ]
+end
+```
+
+The end result:
+
+```ruby
+ModuleA.some_array == [ :some_value ]
+
+ClassA.some_array == [ :some_value ]
+
+ClassB.some_array == [ :some_value, :another_value ]
+
+ClassA.some_array == [ :another_value ]
+```
+
+## Downward-Transforming Values ##
+
+Downward-Transforming Values are not yet 100% implemented, but the remainder is minimal and will be coming soon.
+
+Each time a child is registered, Downward-Transforming Values are processed via a block to produce the new value that the inheriting instance will receive. 
+
+Final details still being determined.
+
+
+## Configuration Modules ##
+
+Including or extending CascadingConfiguration includes or extends all of its configuration modules:
+
+* CascadingConfiguration::Setting
+* CascadingConfiguration::Hash
+* CascadingConfiguration::Array
+* CascadingConfiguration::Array::Unique
+* CascadingConfiguration::Array::Sorted
+* CascadingConfiguration::Array::Sorted::Unique
+
+These modules can also be used individually in the same way (simply include or extend).
+
+# Check Out the Code #
+
+CascadingConfiguration is, in my opinion, a strong showing of what one can do with Ruby. Of particular interest is its demonstrated use of the parallel-ancestry gem. More very real world examples coming soon.
+
+# License #
+
+  (The MIT License)
+
+  Copyright (c) Asher
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  'Software'), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/cascading_configuration/array/sorted/unique.rb

@@ -0,0 +1,110 @@
+
+###
+#  CascadingConfiguration::Array::Sorted::Unique allows definition of array attributes that will composite downward 
+#  through the ancestor chain and ensure that member elements remain sorted and unique.
+# 
+module ::CascadingConfiguration::Array::Sorted::Unique
+
+  ###
+  # Cascading array attribute methods, which will affect instances according to include/extend pattern used.
+  #
+  # @method attr_sorted_unique_array
+  #
+  # @overload attr_sorted_unique_array( *names )
+  #   
+  #   @scope 
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String},Module] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array attribute module/class methods, which will affect all module singletons 
+  #   according to include/extend pattern used.
+  #
+  # @method attr_module_sorted_unique_array
+  #
+  # @overload attr_module_sorted_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array instance methods, which will affect instances of including modules according to 
+  #   include/extend pattern used.
+  #
+  # @method attr_instance_sorted_unique_array
+  #
+  # @overload attr_instance_sorted_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect the instance declared on as well as instances of that instance, 
+  #   if applicable.
+  #
+  # @method attr_local_sorted_unique_array
+  #
+  # @overload attr_local_sorted_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect only the instance declared on.
+  #
+  # @method attr_object_sorted_unique_array
+  #
+  # @overload attr_object_sorted_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  sorted_unique_array_module = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::
+                                 CompositingObjects.new( :sorted_unique_array, 
+                                                         ::CompositingArray::Sorted::Unique, 
+                                                         :default, 
+                                                         :unique_sorted_array,
+                                                         :configuration_sorted_unique_array,
+                                                         :configuration_unique_sorted_array )
+  
+  ::CascadingConfiguration::Core.enable( self, sorted_unique_array_module )
+
+end
+
+::CascadingConfiguration::Array::Unique::Sorted = ::CascadingConfiguration::Array::Sorted::Unique

data/lib/cascading_configuration/array/sorted.rb

@@ -0,0 +1,106 @@
+
+###
+#  CascadingConfiguration::Array::Sorted allows definition of array attributes that will composite downward through
+#  the ancestor chain and ensure that member elements remain sorted.
+# 
+module ::CascadingConfiguration::Array::Sorted
+
+  ###
+  # Cascading array attribute methods, which will affect instances according to include/extend pattern used.
+  #
+  # @method attr_sorted_array
+  #
+  # @overload attr_sorted_array( *names )
+  #   
+  #   @scope 
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String},Module] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array attribute module/class methods, which will affect all module singletons 
+  #   according to include/extend pattern used.
+  #
+  # @method attr_module_sorted_array
+  #
+  # @overload attr_module_sorted_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array instance methods, which will affect instances of including modules according to 
+  #   include/extend pattern used.
+  #
+  # @method attr_instance_sorted_array
+  #
+  # @overload attr_instance_sorted_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect the instance declared on as well as instances of that instance, 
+  #   if applicable.
+  #
+  # @method attr_local_sorted_array
+  #
+  # @overload attr_local_sorted_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect only the instance declared on.
+  #
+  # @method attr_object_sorted_array
+  #
+  # @overload attr_object_sorted_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  sorted_array_module = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::
+                          CompositingObjects.new( :sorted_array, 
+                                                  ::CompositingArray::Sorted, 
+                                                  :default, 
+                                                  :configuration_sorted_array )
+  
+  ::CascadingConfiguration::Core.enable( self, sorted_array_module )
+
+end

data/lib/cascading_configuration/array/unique.rb

@@ -0,0 +1,106 @@
+
+###
+#  CascadingConfiguration::Array allows definition of array attributes that will composite downward through
+#  the ancestor chain and ensure that member elements remain unique.
+# 
+module ::CascadingConfiguration::Array::Unique
+
+  ###
+  # Cascading array attribute methods, which will affect instances according to include/extend pattern used.
+  #
+  # @method attr_unique_array
+  #
+  # @overload attr_unique_array( *names )
+  #   
+  #   @scope 
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String},Module] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array attribute module/class methods, which will affect all module singletons 
+  #   according to include/extend pattern used.
+  #
+  # @method attr_module_unique_array
+  #
+  # @overload attr_module_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array instance methods, which will affect instances of including modules according to 
+  #   include/extend pattern used.
+  #
+  # @method attr_instance_unique_array
+  #
+  # @overload attr_instance_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect the instance declared on as well as instances of that instance, 
+  #   if applicable.
+  #
+  # @method attr_local_unique_array
+  #
+  # @overload attr_local_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect only the instance declared on.
+  #
+  # @method attr_object_unique_array
+  #
+  # @overload attr_object_unique_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  unique_array_module = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::
+                          CompositingObjects.new( :unique_array, 
+                                                  ::CompositingArray::Unique, 
+                                                  :default, 
+                                                  :configuration_unique_array )
+  
+  ::CascadingConfiguration::Core.enable( self, unique_array_module )
+
+end

data/lib/cascading_configuration/array.rb

@@ -0,0 +1,103 @@
+
+###
+#  CascadingConfiguration::Array allows definition of array attributes that will composite downward through
+#  the ancestor chain.
+# 
+module ::CascadingConfiguration::Array
+
+  ###
+  # Cascading array attribute methods, which will affect instances according to include/extend pattern used.
+  #
+  # @method attr_array
+  #
+  # @overload attr_array( *names )
+  #   
+  #   @scope 
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String},Module] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array attribute module/class methods, which will affect all module singletons 
+  #   according to include/extend pattern used.
+  #
+  # @method attr_module_array
+  #
+  # @overload attr_module_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Cascading array instance methods, which will affect instances of including modules according to 
+  #   include/extend pattern used.
+  #
+  # @method attr_instance_array
+  #
+  # @overload attr_instance_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect the instance declared on as well as instances of that instance, 
+  #   if applicable.
+  #
+  # @method attr_local_array
+  #
+  # @overload attr_local_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  ###
+  # Non-cascading array methods that will affect only the instance declared on.
+  #
+  # @method attr_object_array
+  #
+  # @overload attr_object_array( *names )
+  #
+  #   @param [Symbol,String,Hash{Symbol,String=>Symbol,String}] name The name to be used 
+  #    for the declared attribute. If a array is passed, each key will be used as the setting 
+  #    name and accessor and each value will be used as the corresponding write accessor.
+  #
+  #   @yield [ ] Creates a new Module of type CascadingConfiguration::Core::InstanceController::ExtensionModule
+  #    and runs module_eval( & block ) on instance with provided block.
+  #
+  #   @return self
+  #
+
+  array_module = ::CascadingConfiguration::Core::Module::ExtendedConfigurations::
+                   CompositingObjects.new( :array, ::CompositingArray, :default, :configuration_array )
+  
+  ::CascadingConfiguration::Core.enable( self, array_module )
+
+end