compositing-array-sorted-unique 1.0.12

data/CHANGELOG.rdoc

@@ -0,0 +1,17 @@
+
+== 3/17/12
+
+Initial release.
+
+== 3/18/12
+
+Added hooks for subclassing.
+
+== 6/15/12
+
+Moved hooks out to sorted-unique-array and utilized sorted-unique-array as foundation.
+Added alias from CompositingArray::Unique::Sorted to CompositingArray::Sorted::Unique.
+
+== 6/18/12
+
+Fixes for :initialize that required changing module include order and changing subclass inheritance.

data/README.md

@@ -0,0 +1,80 @@
+# Sorted Unique Compositing Array #
+
+http://rubygems.org/gems/compositing-array-sorted-unique
+
+# Description #
+
+Provides CompositingArray::Sorted::Unique.
+
+# Summary #
+
+An implementation of Array that permits chaining, where children inherit changes to parent and where parent settings can be overridden in children, and that retains sorted order, ensuring inserted values are unique.
+
+# Install #
+
+* sudo gem install compositing-array-sorted-unique
+
+# Usage #
+
+```ruby
+compositing_array = CompositingArray::Sorted::Unique.new
+sub_compositing_array = CompositingArray::Sorted::Unique.new( compositing_array )
+
+compositing_array.push( :A )
+# compositing_array
+# => [ :A ]
+# sub_compositing_array
+# => [ :A ]
+compositing_array.push( :C )
+# compositing_array
+# => [ :A, :C ]
+# sub_compositing_array
+# => [ :A, :C ]
+compositing_array.push( :B )
+# compositing_array
+# => [ :A, :B, :C ]
+# sub_compositing_array
+# => [ :A, :B, :C ]
+compositing_array.push( :B )
+# compositing_array
+# => [ :A, :B, :C ]
+# sub_compositing_array
+# => [ :A, :B, :C ]
+
+compositing_array.delete_at( 0 )
+# compositing_array
+# => [ :B, :C ]
+# sub_compositing_array
+# => [ :B, :C ]
+
+sub_compositing_array.push( :A )
+# compositing_array
+# => [ :B, :C ]
+# sub_compositing_array
+# => [ :A, :B, :C ]
+```
+
+# 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/compositing-array-sorted-unique.rb

@@ -0,0 +1,38 @@
+
+if $__compositing_array__spec__development
+  require_relative '../../compositing-array-sorted/lib/compositing-array-sorted.rb'
+  require_relative '../../compositing-array-unique/lib/compositing-array-unique.rb'
+else
+  require 'compositing-array-sorted'
+  require 'compositing-array-unique'
+end
+
+# Since we already have ::CompositingArray::Unique and ::CompositingArray::Sorted, and since
+# both inherit from ::CompositingArray, which thereby has Unique and Sorted as constants,
+# they also inherit Unique and Sorted as constants.
+#
+# This means we have ::CompositingArray::Unique::Sorted and ::CompositingArray::Sorted::Unique
+# before we have intentionally created them.
+#
+# Since we already have ::CompositingArray::Sorted::Unique we can simply re-declare it as our
+# subclass that should be in its place. That way ::CompositingArray::Sorted::Unique::Interface
+# will be created anew rather than pointing to ::CompositingArray::Unique::Interface.
+#
+class ::CompositingArray::Sorted::Unique < ::HookedArray
+end
+
+::CompositingArray::Unique::Sorted = ::CompositingArray::Sorted::Unique
+
+basepath = 'compositing-array-sorted-unique/CompositingArray/Sorted/Unique'
+
+files = [
+
+  'Interface'
+    
+]
+
+files.each do |this_file|
+  require_relative( File.join( basepath, this_file ) + '.rb' )
+end
+
+require_relative( basepath + '.rb' )

data/lib/compositing-array-sorted-unique/CompositingArray/Sorted/Unique.rb

@@ -0,0 +1,6 @@
+
+class ::CompositingArray::Sorted::Unique < ::HookedArray
+
+  include ::CompositingArray::Sorted::Unique::Interface
+  
+end

data/lib/compositing-array-sorted-unique/CompositingArray/Sorted/Unique/Interface.rb

@@ -0,0 +1,10 @@
+
+module ::CompositingArray::Sorted::Unique::Interface
+
+  include ::SortedArray::Interface
+  include ::UniqueArray::Interface
+  include ::CompositingArray::Interface
+  include ::CompositingArray::Sorted::Interface
+  include ::CompositingArray::Unique::Interface
+
+end

data/spec/CompositingArray/Sorted/Unique_spec.rb

@@ -0,0 +1,1218 @@
+
+if $__compositing_array__spec__development
+  require_relative '../../../lib/compositing-array-sorted-unique.rb'
+else
+  require 'compositing-array-sorted-unique'
+end
+
+describe ::CompositingArray::Sorted::Unique do
+
+  ################
+  #  initialize  #
+  ################
+
+  it 'can add initialize with an ancestor, inheriting its values and linking to it as a child' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new( nil, self )
+
+    cascading_composite_array.instance_variable_get( :@parent_composite_object ).should == nil
+    cascading_composite_array.should == []
+    cascading_composite_array.push( :A, :B, :C, :D )
+
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    sub_cascading_composite_array.instance_variable_get( :@parent_composite_object ).should == cascading_composite_array
+    sub_cascading_composite_array.should == [ :A, :B, :C, :D ]
+
+  end
+
+  ##################################################################################################
+  #    private #####################################################################################
+  ##################################################################################################
+
+  ##################################################
+  #  update_corresponding_index_for_parent_change  #
+  ##################################################
+
+  it 'can update tracked parent indices for parent insert/delete' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    cascading_composite_array.push( :A, :B )
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    
+    sub_cascading_composite_array.instance_eval do
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      # insert 1 in parent before parent-1
+      update_corresponding_index_for_parent_change( 1, 1 )
+      @local_index_for_parent_index[ 0 ].should == 0
+      # no longer a parent-1 index (has to be set separately)
+      @local_index_for_parent_index[ 1 ].should == nil
+      # parent-1 is now parent-2
+      @local_index_for_parent_index[ 2 ].should == 2
+      @parent_and_interpolated_object_count.should == 3
+    end
+  
+  end
+
+  #################################################
+  #  update_corresponding_index_for_local_change  #
+  #################################################
+
+  it 'can update tracked parent indices for local insert/delete' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    cascading_composite_array.push( :A, :B )
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    
+    sub_cascading_composite_array.instance_eval do
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      # insert 1 before parent-1
+      update_corresponding_index_for_local_change( 1, 1 )
+      @local_index_for_parent_index[ 0 ].should == 0
+      # new index for parent-1 is 2
+      @local_index_for_parent_index[ 1 ].should == 2
+      @local_index_for_parent_index[ 2 ].should == nil
+      @parent_and_interpolated_object_count.should == 3
+    end
+    
+  end
+
+  ###########################################
+  #  update_as_sub_array_for_parent_insert  #
+  ###########################################
+
+  it 'can handle updating itself as a sub-array when told an insert has occurred in parent' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    cascading_composite_array.push( :A, :B )
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    
+    sub_cascading_composite_array.instance_eval do
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      # insert 1 before parent-1
+      update_as_sub_array_for_parent_insert( 1, :C )
+      @local_index_for_parent_index[ 0 ].should == 0
+      # new parent index parent-1 inserted for :C
+      @local_index_for_parent_index[ 1 ].should == 1
+      # new index for parent-1 is parent-2
+      @local_index_for_parent_index[ 2 ].should == 2
+      @parent_and_interpolated_object_count.should == 3
+    end
+    
+  end
+
+  ########################################
+  #  update_as_sub_array_for_parent_set  #
+  ########################################
+
+  it 'can handle updating itself as a sub-array when told a set has occurred in parent' do
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    cascading_composite_array.push( :A, :B )
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    
+    sub_cascading_composite_array.instance_eval do
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      # set for parent-1
+      update_as_sub_array_for_parent_set( 1, :C )
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 0
+      @local_index_for_parent_index[ 2 ].should == nil
+      @parent_and_interpolated_object_count.should == 2
+    end
+    
+  end
+
+  ###########################################
+  #  update_as_sub_array_for_parent_delete  #
+  ###########################################
+
+  it 'can handle updating itself as a sub-array when told a delete has occurred in parent' do
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    cascading_composite_array.push( :A, :B )
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+    
+    sub_cascading_composite_array.instance_eval do
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      # delete parent-1
+      update_as_sub_array_for_parent_delete( 1 )
+      @local_index_for_parent_index[ 0 ].should == 0
+      @local_index_for_parent_index[ 1 ].should == 1
+      @local_index_for_parent_index[ 2 ].should == nil
+      @parent_and_interpolated_object_count.should == 1
+    end
+    
+  end
+  
+  ##################################################################################################
+  #    public ######################################################################################
+  ##################################################################################################
+  
+  #########
+  #  []=  #
+  #########
+
+  it 'can add elements' do
+  
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array[ 0 ] = :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array[ 1 ] = :B
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B ]
+
+    sub_cascading_composite_array[ 0 ] = :C
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array[ 0 ] = :B
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array[ 2 ] = :C
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    cascading_composite_array[ 0 ] = :D
+    cascading_composite_array.should == [ :B, :D ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+  
+  ############
+  #  insert  #
+  ############
+
+  it 'can insert elements' do
+  
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.insert( 3, :D )
+    cascading_composite_array.should == [ nil, :D ]
+    sub_cascading_composite_array.should == [ nil, :D ]
+
+    cascading_composite_array.insert( 1, :B )
+    cascading_composite_array.should == [ nil, :B, :D ]
+    sub_cascading_composite_array.should == [ nil, :B, :D ]
+
+    cascading_composite_array.insert( 2, :C )
+    cascading_composite_array.should == [ nil, :B, :C, :D ]
+    sub_cascading_composite_array.should == [ nil, :B, :C, :D ]
+
+    sub_cascading_composite_array.insert( 0, :E )
+    cascading_composite_array.should == [ nil, :B, :C, :D ]
+    sub_cascading_composite_array.should == [  nil, :B, :C, :D, :E ]
+
+    sub_cascading_composite_array.insert( 4, :F )
+    cascading_composite_array.should == [ nil, :B, :C, :D ]
+    sub_cascading_composite_array.should == [  nil, :B, :C, :D, :E, :F ]
+
+  end
+  
+  ##########
+  #  push  #
+  #  <<    #
+  ##########
+  
+  it 'can add elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array << :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array << :B
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B ]
+
+    sub_cascading_composite_array << :C
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array << :B
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+  
+  ############
+  #  concat  #
+  #  +       #
+  ############
+
+  it 'can add elements' do
+
+    # NOTE: this breaks + by causing it to modify the array like +=
+    # The alternative was worse.
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.concat( [ :A ] )
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array += [ :B ]
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B ]
+
+    sub_cascading_composite_array.concat( [ :C ] )
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array += [ :B ]
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  ####################
+  #  delete_objects  #
+  ####################
+
+  it 'can delete multiple elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += [ :A, :B ]
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B ]
+
+    cascading_composite_array.delete_objects( :A, :B )
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    sub_cascading_composite_array += [ :B, :C, :D ]
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ :B, :C, :D ]
+    
+    sub_cascading_composite_array.delete_objects( :C, :B )
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ :D ]
+
+  end
+
+  #######
+  #  -  #
+  #######
+  
+  it 'can exclude elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A )
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array -= [ :A ]
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array.push( :B )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array.push( :C )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array -= [ :B ]
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+
+  ############
+  #  delete  #
+  ############
+  
+  it 'can delete elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A )
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.delete( :A )
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array.push( :B )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array.push( :C )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array.delete( :B )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+
+  ###############
+  #  delete_at  #
+  ###############
+
+  it 'can delete by indexes' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A )
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+    
+    cascading_composite_array.delete_at( 0 )
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array.push( :B )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array.push( :C )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array.delete_at( 0 )
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+
+  #######################
+  #  delete_at_indexes  #
+  #######################
+
+  it 'can delete by indexes' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    cascading_composite_array.delete_at_indexes( 0, 1 )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array.delete_at_indexes( 0, 1, 2 )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ ]
+
+  end
+
+  ###############
+  #  delete_if  #
+  ###############
+
+  it 'can delete by block' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.delete_if do |object|
+      object != :C
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.delete_if do |object|
+      object != nil
+    end
+    sub_cascading_composite_array.should == [ ]
+    cascading_composite_array.should == [ :C ]
+
+    cascading_composite_array.delete_if.is_a?( Enumerator ).should == true
+
+  end
+
+  #############
+  #  keep_if  #
+  #############
+
+  it 'can keep by block' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.keep_if do |object|
+      object == :C
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.keep_if do |object|
+      object == nil
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ ]
+
+  end
+
+  ##############
+  #  compact!  #
+  ##############
+
+  it 'can compact' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, nil, :B, nil, :C, nil )
+    cascading_composite_array.should == [ nil, :A, :B, :C ]
+    sub_cascading_composite_array.should == [ nil, :A, :B, :C ]
+    cascading_composite_array.compact!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array.push( nil, :D )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ nil, :A, :B, :C, :D ]
+    sub_cascading_composite_array.compact!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C, :D ]
+
+  end
+
+  ##############
+  #  flatten!  #
+  ##############
+
+  it 'can flatten' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, [ :F_A, :F_B ], :B, [ :F_C ], :C, [ :F_D ], [ :F_E ] )
+    cascading_composite_array.should == [ :A, [ :F_A, :F_B ], :B, [ :F_C ], :C, [ :F_D ], [ :F_E ] ]
+    sub_cascading_composite_array.should == [ :A, [ :F_A, :F_B ], :B, [ :F_C ], :C, [ :F_D ], [ :F_E ] ]
+    cascading_composite_array.flatten!
+    cascading_composite_array.should == [ :A, :B, :C, :F_A, :F_B, :F_C, :F_D, :F_E ]
+    sub_cascading_composite_array.should == [ :A, :B, :C, :F_A, :F_B, :F_C, :F_D, :F_E ]
+
+    sub_cascading_composite_array.push( [ :F_F, :F_G ], :D, [ :F_H ] )
+    cascading_composite_array.should == [ :A, :B, :C, :F_A, :F_B, :F_C, :F_D, :F_E ]
+    sub_cascading_composite_array.should == [ :A, :B, :C, :D, :F_A, :F_B, :F_C, :F_D, :F_E, [ :F_F, :F_G ], [ :F_H ] ]
+    sub_cascading_composite_array.flatten!
+    cascading_composite_array.should == [ :A, :B, :C, :F_A, :F_B, :F_C, :F_D, :F_E ]
+    sub_cascading_composite_array.should == [ :A, :B, :C, :D, :F_A, :F_B, :F_C, :F_D, :F_E, :F_F, :F_G, :F_H ]
+
+  end
+
+  #############
+  #  reject!  #
+  #############
+
+  it 'can reject' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.reject! do |object|
+      object != :C
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.reject! do |object|
+      object != nil
+    end
+    sub_cascading_composite_array.should == [ ]
+    cascading_composite_array.should == [ :C ]
+
+    cascading_composite_array.reject!.is_a?( Enumerator ).should == true
+
+  end
+
+  #############
+  #  replace  #
+  #############
+
+  it 'can replace self' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.replace( [ :D, :E, :F ] )
+    cascading_composite_array.should == [ :D, :E, :F ]
+    sub_cascading_composite_array.should == [ :D, :E, :F ]
+
+    cascading_composite_array.should == [ :D, :E, :F ]
+    sub_cascading_composite_array.should == [ :D, :E, :F ]
+    sub_cascading_composite_array.replace( [ :G, :H, :I ] )
+    cascading_composite_array.should == [ :D, :E, :F ]
+    sub_cascading_composite_array.should == [ :G, :H, :I ]
+
+  end
+
+  ##############
+  #  reverse!  #
+  ##############
+
+  it 'can reverse self' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.reverse!
+    cascading_composite_array.should == [ :C, :B, :A ]
+    sub_cascading_composite_array.should == [ :C, :B, :A ]
+
+    cascading_composite_array.should == [ :C, :B, :A ]
+    sub_cascading_composite_array.should == [ :C, :B, :A ]
+    sub_cascading_composite_array.reverse!
+    cascading_composite_array.should == [ :C, :B, :A ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  #############
+  #  rotate!  #
+  #############
+
+  it 'can rotate self' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    cascading_composite_array.rotate!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    cascading_composite_array.rotate!( -1 )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array.rotate!( 2 )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  #############
+  #  select!  #
+  #############
+
+  it 'can keep by select' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.select! do |object|
+      object == :C
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.select! do |object|
+      object == nil
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array.select!.is_a?( Enumerator ).should == true
+
+  end
+
+  ##############
+  #  shuffle!  #
+  ##############
+
+  it 'can shuffle self' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == cascading_composite_array
+
+    first_shuffle_version = cascading_composite_array.dup
+    cascading_composite_array.shuffle!
+    cascading_composite_array.should == first_shuffle_version
+    sub_cascading_composite_array.should == cascading_composite_array
+
+    first_shuffle_version = sub_cascading_composite_array.dup
+    sub_cascading_composite_array.shuffle!
+    sub_cascading_composite_array.should == first_shuffle_version
+    sub_cascading_composite_array.should == cascading_composite_array
+
+  end
+
+  ##############
+  #  collect!  #
+  #  map!      #
+  ##############
+
+  it 'can replace by collect/map' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.collect! do |object|
+      :C
+    end
+    cascading_composite_array.should == [ :C, ]
+    sub_cascading_composite_array.should == [ :C ]
+
+    sub_cascading_composite_array.collect! do |object|
+      :A
+    end
+    cascading_composite_array.should == [ :C ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.collect!.is_a?( Enumerator ).should == true
+
+  end
+
+  ###########
+  #  sort!  #
+  ###########
+
+  it 'can replace by collect/map' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.sort! do |a, b|
+      if a < b
+        1
+      elsif a > b
+        -1
+      elsif a == b
+        0
+      end
+    end
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array.sort! do |a, b|
+      if a < b
+        -1
+      elsif a > b
+        1
+      elsif a == b
+        0
+      end
+    end
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    cascading_composite_array.sort!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  ##############
+  #  sort_by!  #
+  ##############
+
+  it 'can replace by collect/map' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.sort_by! do |object|
+      case object
+      when :A
+        :B
+      when :B
+        :A
+      when :C
+        :C
+      end
+    end
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array.sort_by! do |object|
+      case object
+      when :A
+        :C
+      when :B
+        :B
+      when :C
+        :A
+      end
+    end
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    cascading_composite_array.sort_by!.is_a?( Enumerator ).should == true
+
+  end
+
+  ###########
+  #  uniq!  #
+  ###########
+
+  it 'can remove non-unique elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array.push( :A, :B, :C, :C, :C, :B, :A )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    cascading_composite_array.uniq!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+    sub_cascading_composite_array.push( :C, :B )
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.uniq!
+    cascading_composite_array.should == [ :A, :B, :C ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  #############
+  #  unshift  #
+  #############
+
+  it 'can unshift onto the first element' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.unshift( :B )
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B ]
+
+    sub_cascading_composite_array.unshift( :C )
+    cascading_composite_array.should == [ :A, :B ]
+    sub_cascading_composite_array.should == [ :A, :B, :C ]
+
+  end
+
+  #########
+  #  pop  #
+  #########
+  
+  it 'can pop the final element' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.pop.should == :A
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array += :B
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array += :C
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.pop.should == :C
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+  end
+
+  ###########
+  #  shift  #
+  ###########
+  
+  it 'can shift the first element' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.shift.should == :A
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array += :B
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array += :C
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+    sub_cascading_composite_array.shift.should == :B
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+
+  ############
+  #  slice!  #
+  ############
+  
+  it 'can slice elements' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.slice!( 0, 1 ).should == [ :A ]
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array += :B
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array += :C
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array.slice!( 0, 1 ).should == [ :B ]
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :C ]
+
+  end
+  
+  ###########
+  #  clear  #
+  ###########
+
+  it 'can clear, causing present elements to be excluded' do
+
+    cascading_composite_array = ::CompositingArray::Sorted::Unique.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique.new( cascading_composite_array )
+
+    cascading_composite_array += :A
+    cascading_composite_array.should == [ :A ]
+    sub_cascading_composite_array.should == [ :A ]
+
+    cascading_composite_array.clear
+    cascading_composite_array.should == [ ]
+    sub_cascading_composite_array.should == [ ]
+
+    cascading_composite_array += :B
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B ]
+
+    sub_cascading_composite_array += :C
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ :B, :C ]
+
+    sub_cascading_composite_array.clear
+    cascading_composite_array.should == [ :B ]
+    sub_cascading_composite_array.should == [ ]
+
+  end
+
+  ##################
+  #  pre_set_hook  #
+  ##################
+
+  it 'has a hook that is called before setting a value; return value is used in place of object' do
+    
+    class ::CompositingArray::Sorted::Unique::SubMockPreSet < ::CompositingArray
+      
+      def pre_set_hook( index, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPreSet.new
+
+    cascading_composite_array.push( :some_value )
+    
+    cascading_composite_array.should == [ :some_other_value ]
+    
+  end
+
+  ###################
+  #  post_set_hook  #
+  ###################
+
+  it 'has a hook that is called after setting a value' do
+
+    class ::CompositingArray::Sorted::Unique::SubMockPostSet < ::CompositingArray
+      
+      def post_set_hook( index, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPostSet.new
+
+    cascading_composite_array.push( :some_value ).should == [ :some_other_value ]
+    
+    cascading_composite_array.should == [ :some_value ]
+    
+  end
+
+  ##################
+  #  pre_get_hook  #
+  ##################
+
+  it 'has a hook that is called before getting a value; if return value is false, get does not occur' do
+    
+    class ::CompositingArray::Sorted::Unique::SubMockPreGet < ::CompositingArray
+      
+      def pre_get_hook( index )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPreGet.new
+    
+    cascading_composite_array.push( :some_value )
+    cascading_composite_array[ 0 ].should == nil
+    
+    cascading_composite_array.should == [ :some_value ]
+    
+  end
+
+  ###################
+  #  post_get_hook  #
+  ###################
+
+  it 'has a hook that is called after getting a value' do
+
+    class ::CompositingArray::Sorted::Unique::SubMockPostGet < ::CompositingArray
+      
+      def post_get_hook( index, object )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPostGet.new
+    
+    cascading_composite_array.push( :some_value )
+    cascading_composite_array[ 0 ].should == :some_other_value
+    
+    cascading_composite_array.should == [ :some_value ]
+    
+  end
+
+  #####################
+  #  pre_delete_hook  #
+  #####################
+
+  it 'has a hook that is called before deleting an index; if return value is false, delete does not occur' do
+    
+    class ::CompositingArray::Sorted::Unique::SubMockPreDelete < ::CompositingArray
+      
+      def pre_delete_hook( index )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPreDelete.new
+    
+    cascading_composite_array.push( :some_value )
+    cascading_composite_array.delete_at( 0 )
+    
+    cascading_composite_array.should == [ :some_value ]
+    
+  end
+
+  ######################
+  #  post_delete_hook  #
+  ######################
+
+  it 'has a hook that is called after deleting an index' do
+    
+    class ::CompositingArray::Sorted::Unique::SubMockPostDelete < ::CompositingArray
+      
+      def post_delete_hook( index, object )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockPostDelete.new
+    
+    cascading_composite_array.push( :some_value )
+    cascading_composite_array.delete_at( 0 ).should == :some_other_value
+    
+    cascading_composite_array.should == [ ]
+    
+  end
+
+  ########################
+  #  child_pre_set_hook  #
+  ########################
+
+  it 'has a hook that is called before setting a value that has been passed by a parent; return value is used in place of object' do
+    
+    class ::CompositingArray::Sorted::Unique::SubMockChildPreSet < ::CompositingArray
+      
+      def child_pre_set_hook( index, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPreSet.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPreSet.new( cascading_composite_array )
+    cascading_composite_array.push( :some_value )
+
+    sub_cascading_composite_array.should == [ :some_other_value ]
+    
+  end
+
+  #########################
+  #  child_post_set_hook  #
+  #########################
+
+  it 'has a hook that is called after setting a value passed by a parent' do
+
+    class ::CompositingArray::Sorted::Unique::SubMockChildPostSet < ::CompositingArray
+      
+      def child_post_set_hook( index, object, is_insert = false )
+        push( :some_other_value )
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPostSet.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPostSet.new( cascading_composite_array )
+    cascading_composite_array.push( :some_value )
+
+    cascading_composite_array.should == [ :some_value ]
+    sub_cascading_composite_array.should == [ :some_value, :some_other_value ]
+    
+  end
+
+  ###########################
+  #  child_pre_delete_hook  #
+  ###########################
+
+  it 'has a hook that is called before deleting an index that has been passed by a parent; if return value is false, delete does not occur' do
+
+    class ::CompositingArray::Sorted::Unique::SubMockChildPreDelete < ::CompositingArray
+      
+      def child_pre_delete_hook( index )
+        false
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPreDelete.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPreDelete.new( cascading_composite_array )
+    cascading_composite_array.push( :some_value )
+    cascading_composite_array.delete( :some_value )
+
+    cascading_composite_array.should == [  ]
+    sub_cascading_composite_array.should == [ :some_value ]
+    
+  end
+
+  ############################
+  #  child_post_delete_hook  #
+  ############################
+
+  it 'has a hook that is called after deleting an index passed by a parent' do
+
+    class ::CompositingArray::Sorted::Unique::SubMockChildPostDelete < ::CompositingArray
+      
+      def child_post_delete_hook( index, object )
+        delete( :some_other_value )
+      end
+      
+    end
+    
+    cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPostDelete.new
+    sub_cascading_composite_array = ::CompositingArray::Sorted::Unique::SubMockChildPostDelete.new( cascading_composite_array )
+    cascading_composite_array.push( :some_value )
+    sub_cascading_composite_array.push( :some_other_value )
+    cascading_composite_array.delete( :some_value )
+
+    cascading_composite_array.should == [  ]
+    sub_cascading_composite_array.should == [ ]
+    
+  end
+  
+end