RubyGems - cascading-configuration-array - Versions diffs - 2.0.3 → 2.1.0 - Mend

cascading-configuration-array 2.0.3 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

data/README.md CHANGED

@@ -203,7 +203,7 @@ end
   (The MIT License)
-  Copyright (c) 2011 Asher
+  Copyright (c) Asher
   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the

data/README.rdoc CHANGED

@@ -36,7 +36,7 @@ See README.md
   (The MIT License)
-  Copyright (c) 2011 Asher
+  Copyright (c) Asher
   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the

data/lib/cascading-configuration-array.rb CHANGED

@@ -1,4 +1,6 @@
+require 'compositing-array'
 if $__cascading_configuration__spec__development
   require_relative '../../variable/lib/cascading-configuration-variable.rb'
 else
@@ -7,19 +9,9 @@ end
 module ::CascadingConfiguration
   module Array
-    class CompositingArray < ::Array
-    end
-    module ModuleSupportMethods
-    end
-    module Interface
-    end
   end
 end
-require_relative 'cascading-configuration-array/_private_/CascadingConfiguration/Array/CompositingArray.rb'
-require_relative 'cascading-configuration-array/_private_/CascadingConfiguration/Array/ModuleSupportMethods.rb'
-require_relative 'cascading-configuration-array/CascadingConfiguration/Array/Interface.rb'
 require_relative 'cascading-configuration-array/CascadingConfiguration/Array.rb'

data/lib/cascading-configuration-array/CascadingConfiguration/Array.rb CHANGED

@@ -2,11 +2,52 @@
 module ::CascadingConfiguration::Array
   # Configuration modules for storage of settings arrays
-  include ::CascadingConfiguration::Variable
+  include ::CascadingConfiguration::Inheritance
-  # Interface to declare configuration settings arrays
-  include ::CascadingConfiguration::Array::Interface
+  #######################################
+  #  attr_configuration_array           #
+  #  attr_module_configuration_array    #
+  #  attr_local_configuration_array     #
+  #  attr_object_configuration_array    #
+  #  attr_instance_configuration_array  #
+  #######################################
-  extend ::CascadingConfiguration::Array::ModuleSupportMethods
+  def attr_configuration_array( *configuration_names, & define_block ) ;; end
+  def attr_module_configuration_array( *configuration_names, & define_block ) ;; end
+  def attr_class_configuration_array( *configuration_names, & define_block ) ;; end
+  def attr_local_configuration_array( *configuration_names, & define_block ) ;; end
+  def attr_object_configuration_array( *configuration_names, & define_block ) ;; end
+  def attr_instance_configuration_array( *configuration_names, & define_block ) ;; end
+  cca = self
+  ccv = ::CascadingConfiguration::Variable
+  ccm = ::CascadingConfiguration::Methods
+  setter_proc = ::Proc.new do |instance, configuration_name, value|
+    return instance.__send__( configuration_name ).replace( value )
+  end
+  getter_proc = ::Proc.new do |instance, configuration_name|
+    composite_array = nil
+    if ccv.has_configuration_variable?( instance, configuration_name )
+      composite_array = ccv.get_configuration_variable( instance, configuration_name )
+    else
+      parent_composite_array = nil
+      if ancestor = ::CascadingConfiguration::Variable.ancestor( instance, configuration_name )
+        parent_composite_array = ancestor.__send__( configuration_name )
+      end
+      composite_array = ::CompositingArray.new( parent_composite_array )
+      ccv.set_configuration_variable( instance, configuration_name, composite_array )
+    end
+    return composite_array
+  end
+  ccm.declare_compositing_configuration_object( self, :array, setter_proc, getter_proc )
 end

data/spec/CascadingConfiguration/Array_spec.rb CHANGED

@@ -744,5 +744,30 @@ describe CascadingConfiguration::Array do
     end
   end
+  #########################################
+  #  attr_configuration_array with hooks  #
+  #########################################
+  it 'can define a configuration array with hooks' do
+    module ::CascadingConfiguration::Array::HooksMock
+      include ::CascadingConfiguration::Array
+      module ExtensionModule
+        def push( arg )
+          super( 2 )
+        end
+      end
+      attr_configuration_array :configuration_setting, ExtensionModule
+      configuration_setting.push( 1 )
+      configuration_setting[ 0 ].should == 2
+      attr_configuration_array :other_configuration_setting do
+        def push( arg )
+          super( 2 )
+        end
+      end
+      other_configuration_setting.push( 1 )
+      other_configuration_setting[ 0 ].should == 2
+    end
+  end
 end

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cascading-configuration-array
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.0
   prerelease:
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-03-04 00:00:00.000000000 Z
+date: 2012-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cascading-configuration-variable
-  requirement: &70108328808940 !ruby/object:Gem::Requirement
+  requirement: &70132135355540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,19 +21,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70108328808940
+  version_requirements: *70132135355540
 description: Provides :attr_configuration_array.
 email: asher@ridiculouspower.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/cascading-configuration-array/_private_/CascadingConfiguration/Array/CompositingArray.rb
-- lib/cascading-configuration-array/_private_/CascadingConfiguration/Array/ModuleSupportMethods.rb
-- lib/cascading-configuration-array/CascadingConfiguration/Array/Interface.rb
 - lib/cascading-configuration-array/CascadingConfiguration/Array.rb
 - lib/cascading-configuration-array.rb
-- spec/_private_/CascadingConfiguration/Array/CompositingArray_spec.rb
 - spec/CascadingConfiguration/Array_spec.rb
 - README.md
 - README.rdoc
@@ -57,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: cascading-configuration-array
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key:
 specification_version: 3
 summary: Support package for cascading-configuration.

data/lib/cascading-configuration-array/CascadingConfiguration/Array/Interface.rb DELETED

@@ -1,111 +0,0 @@
-module ::CascadingConfiguration::Array::Interface
-  ######################
-  #  self.setter_proc  #
-  ######################
-  def self.setter_proc( configuration_name )
-    return Proc.new do |array|
-      return ::CascadingConfiguration::Array.set_composite_array( self,
-                                                                  configuration_name,
-                                                                  array )
-    end
-  end
-  ######################
-  #  self.getter_proc  #
-  ######################
-  def self.getter_proc( configuration_name )
-    return Proc.new do
-      return ::CascadingConfiguration::Array.composite_array( self,
-                                                              configuration_name )
-    end
-  end
-  ##############################
-  #  attr_configuration_array  #
-  ##############################
-  # defines configuration in class or module
-  # configuration cascades downward to instance including all classes or modules in-between
-  def attr_configuration_array( *configuration_names )
-    return ::CascadingConfiguration::Variable.
-             define_cascading_configuration( self,
-                                             ::CascadingConfiguration::Array::Interface,
-                                             *configuration_names )
-  end
-  #####################################
-  #  attr_module_configuration_array  #
-  #####################################
-  # defines configuration in class or module
-  # configuration cascades downward to last class or module
-  def attr_module_configuration_array( *configuration_names )
-    return ::CascadingConfiguration::Variable.
-             define_module_configuration( self,
-                                          ::CascadingConfiguration::Array::Interface,
-                                          *configuration_names )
-  end
-  alias_method :attr_class_configuration_array, :attr_module_configuration_array
-  ####################################
-  #  attr_local_configuration_array  #
-  ####################################
-  # defines configuration in present class or module context
-  # configuration does not cascade
-  def attr_local_configuration_array( *configuration_names )
-    return ::CascadingConfiguration::Variable.
-             define_local_configuration( self,
-                                         ::CascadingConfiguration::Array::Interface,
-                                         *configuration_names )
-  end
-  #####################################
-  #  attr_object_configuration_array  #
-  #####################################
-  # defines configuration in present instance
-  # configuration does not cascade
-  def attr_object_configuration_array( *configuration_names )
-    return ::CascadingConfiguration::Variable.
-             define_object_configuration( self,
-                                          ::CascadingConfiguration::Array::Interface,
-                                          *configuration_names )
-  end
-  #######################################
-  #  attr_instance_configuration_array  #
-  #######################################
-  # defines configuration in present class or module context
-  # configuration does not cascade
-  def attr_instance_configuration_array( *configuration_names )
-    return ::CascadingConfiguration::Variable.
-             define_instance_configuration( self,
-                                            ::CascadingConfiguration::Array::Interface,
-                                            *configuration_names )
-  end
-end

data/lib/cascading-configuration-array/_private_/CascadingConfiguration/Array/CompositingArray.rb DELETED

@@ -1,865 +0,0 @@
-class ::CascadingConfiguration::Array::CompositingArray < ::Array
-  ################
-  #  initialize  #
-  ################
-  def initialize( configuration_instance, configuration_name )
-    @configuration_instance = configuration_instance
-    @configuration_name = configuration_name
-    # hash tracking index in self corresponding to index in parent
-    # this is since objects can be inserted before/between parent objects
-    @local_index_for_parent_index = { }
-    # we keep track of how many objects are interpolated between parent objects
-    # plus number of parent objects
-    @parent_and_interpolated_object_count = 0
-    @replaced_parents = {}
-    # arrays that inherit from us
-    @sub_composite_arrays = [ ]
-    # store self for sub composites
-    ::CascadingConfiguration::Variable.set_configuration_variable( configuration_instance,
-                                                                   configuration_name,
-                                                                   self )
-    # if first ancestor can have a composite array, register self with it
-    # in case it gets updated in the future
-    if ancestor = ::CascadingConfiguration::Variable.ancestor( configuration_instance,
-                                                               configuration_name )
-      @super_composite_array = ::CascadingConfiguration::Variable.
-                                 get_configuration_variable( ancestor, configuration_name )
-      if @super_composite_array.respond_to?( :register_sub_composite_array )
-        @super_composite_array.register_sub_composite_array( self )
-        push( *@super_composite_array )
-        @super_composite_array.count.times do |this_time|
-          @local_index_for_parent_index[ this_time ] = this_time
-        end
-        # since we have a super array we have to note how many objects it has before we insert any
-        @parent_and_interpolated_object_count = @super_composite_array.count
-      else
-        @super_composite_array = nil
-      end
-    end
-  end
-  ###################################  Sub-Array Management  #######################################
-  ##################################
-  #  register_sub_composite_array  #
-  ##################################
-  def register_sub_composite_array( sub_composite_array )
-    @sub_composite_arrays.push( sub_composite_array )
-    return self
-  end
-  ####################################
-  #  unregister_sub_composite_array  #
-  ####################################
-  def unregister_sub_composite_array( sub_composite_array )
-    @sub_composite_arrays.delete( sub_composite_array )
-    return self
-  end
-  #####################################  Self Management  ##########################################
-  #########
-  #  []=  #
-  #########
-  private
-    alias_method :non_cascading_set, :[]=
-  public
-  def []=( index, object )
-    # we are either replacing or adding at the end
-    # if we are replacing we are either replacing a parent element or an element in self
-    # * if replacing parent element, track and exclude parent changes
-    non_cascading_set( index, object )
-    if index_inside_parent_objects?( index )
-      @replaced_parents[ index ] = true
-    end
-    @sub_composite_arrays.each do |this_sub_array|
-      this_sub_array.instance_eval do
-        update_as_sub_array_for_parent_set( index, object )
-      end
-    end
-    return object
-  end
-  ############
-  #  insert  #
-  ############
-  private
-    alias_method :non_cascading_insert, :insert
-  public
-  def insert( index, *objects )
-    # if we have less elements in self than the index we are inserting at
-    # we need to make sure the nils inserted cascade
-    if index > count
-      nils_created = index - count
-      index -= nils_created
-      nils = [ ]
-      nils_created.times do |this_time|
-        nils.push( nil )
-      end
-      objects = nils.concat( objects )
-    end
-    non_cascading_insert( index, *objects )
-    if index_inside_parent_objects?( index )
-      update_corresponding_index_for_local_change( index, objects.count )
-    end
-    @sub_composite_arrays.each do |this_sub_array|
-      this_sub_array.instance_eval do
-        update_as_sub_array_for_parent_insert( index, *objects )
-      end
-    end
-    return self
-  end
-  ##########
-  #  push  #
-  ##########
-  def push( *objects )
-    insert( count, *objects )
-    return self
-  end
-  alias_method :<<, :push
-  ############
-  #  concat  #
-  ############
-  def concat( *arrays )
-    arrays.each do |this_array|
-      push( *this_array )
-    end
-    return self
-  end
-  alias_method :+, :concat
-  ############
-  #  delete  #
-  ############
-  def delete( object )
-    return_value = nil
-    if index = index( object )
-      return_value = delete_at( index )
-    end
-    return return_value
-  end
-  ####################
-  #  delete_objects  #
-  ####################
-  def delete_objects( *objects )
-    return_value = nil
-    indexes = [ ]
-    objects.each do |this_object|
-      this_index = index( this_object )
-      if this_index
-        indexes.push( this_index )
-      end
-    end
-    unless indexes.empty?
-      return_value = delete_at_indexes( *indexes )
-    end
-    return return_value
-  end
-  #######
-  #  -  #
-  #######
-  def -( *arrays )
-    arrays.each do |this_array|
-      delete_objects( *this_array )
-    end
-    return self
-  end
-  ###############
-  #  delete_at  #
-  ###############
-  private
-    alias_method :non_cascading_delete_at, :delete_at
-  public
-  def delete_at( index )
-    deleted_object = non_cascading_delete_at( index )
-    @replaced_parents.delete( index )
-    if index_inside_parent_objects?( index )
-      update_corresponding_index_for_local_change( index, -1 )
-    end
-    @sub_composite_arrays.each do |this_sub_array|
-      this_sub_array.instance_eval do
-        update_as_sub_array_for_parent_delete( index )
-      end
-    end
-    return deleted_object
-  end
-  #######################
-  #  delete_at_indexes  #
-  #######################
-  def delete_at_indexes( *indexes )
-    indexes = indexes.sort.uniq.reverse
-    objects = [ ]
-    indexes.each do |this_index|
-      objects.push( delete_at( this_index ) )
-    end
-    return objects
-  end
-  ###############
-  #  delete_if  #
-  ###############
-  def delete_if
-    return to_enum unless block_given?
-    indexes = [ ]
-    self.each_with_index do |this_object, index|
-      if yield( this_object )
-        indexes.push( index )
-      end
-    end
-    delete_at_indexes( *indexes )
-    return self
-  end
-  #############
-  #  keep_if  #
-  #############
-  def keep_if
-    indexes = [ ]
-    self.each_with_index do |this_object, index|
-      unless yield( this_object )
-        indexes.push( index )
-      end
-    end
-    delete_at_indexes( *indexes )
-    return self
-  end
-  ##############
-  #  compact!  #
-  ##############
-  def compact!
-    return keep_if do |object|
-      object != nil
-    end
-  end
-  ##############
-  #  flatten!  #
-  ##############
-  def flatten!
-    return_value = nil
-    indexes = [ ]
-    self.each_with_index do |this_object, index|
-      if this_object.is_a?( Array )
-        indexes.push( index )
-      end
-    end
-    unless indexes.empty?
-      indexes.sort!.reverse!
-      indexes.each do |this_index|
-        this_array = delete_at( this_index )
-        insert( this_index, *this_array )
-      end
-      return_value = self
-    end
-    return return_value
-  end
-  #############
-  #  reject!  #
-  #############
-  def reject!
-    return to_enum unless block_given?
-    return_value = nil
-    deleted_objects = 0
-    iteration_dup = dup
-    iteration_dup.each_with_index do |this_object, index|
-      if yield( this_object )
-        delete_at( index - deleted_objects )
-        deleted_objects += 1
-      end
-    end
-    if deleted_objects > 0
-      return_value = self
-    end
-    return return_value
-  end
-  #############
-  #  replace  #
-  #############
-  def replace( other_array )
-    clear
-    other_array.each_with_index do |this_object, index|
-      unless self[ index ] == this_object
-        self[ index ] = this_object
-      end
-    end
-    return self
-  end
-  ##############
-  #  reverse!  #
-  ##############
-  def reverse!
-    reversed_array = reverse
-    clear
-    reversed_array.each_with_index do |this_object, index|
-      self[ index ] = this_object
-    end
-    return self
-  end
-  #############
-  #  rotate!  #
-  #############
-  def rotate!( rotate_count = 1 )
-    reversed_array = rotate( rotate_count )
-    clear
-    reversed_array.each_with_index do |this_object, index|
-      self[ index ] = this_object
-    end
-    return self
-  end
-  #############
-  #  select!  #
-  #############
-  def select!
-    return to_enum unless block_given?
-    deleted_objects = 0
-    iteration_dup = dup
-    iteration_dup.each_with_index do |this_object, index|
-      unless yield( this_object )
-        delete_at( index - deleted_objects )
-        deleted_objects += 1
-      end
-    end
-    return self
-  end
-  ##############
-  #  shuffle!  #
-  ##############
-  def shuffle!( random_number_generator = nil )
-    shuffled_array = shuffle( random: random_number_generator )
-    clear
-    shuffled_array.each_with_index do |this_object, index|
-      self[ index ] = this_object
-    end
-    return self
-  end
-  ##############
-  #  collect!  #
-  #  map!      #
-  ##############
-  def collect!
-    return to_enum unless block_given?
-    self.each_with_index do |this_object, index|
-      replacement_object = yield( this_object )
-      self[ index ] = replacement_object
-    end
-    return self
-  end
-  alias_method :map!, :collect!
-  ###########
-  #  sort!  #
-  ###########
-  def sort!( & block )
-    sorted_array = sort( & block )
-    unless sorted_array == self
-      replace( sorted_array )
-    end
-    return self
-  end
-  ##############
-  #  sort_by!  #
-  ##############
-  def sort_by!( & block )
-    return to_enum unless block_given?
-    sorted_array = sort_by( & block )
-    unless sorted_array == self
-      replace( sorted_array )
-    end
-    return self
-  end
-  ###########
-  #  uniq!  #
-  ###########
-  def uniq!
-    return_value = nil
-    uniq_array = uniq
-    unless uniq_array == self
-      clear
-      replace( uniq_array )
-    end
-    return return_value
-  end
-  #############
-  #  unshift  #
-  #############
-  def unshift( object )
-    insert( 0, object )
-  end
-  #########
-  #  pop  #
-  #########
-  def pop
-    object = delete_at( count - 1 )
-    return object
-  end
-  ###########
-  #  shift  #
-  ###########
-  def shift
-    object = delete_at( 0 )
-    return object
-  end
-  ############
-  #  slice!  #
-  ############
-  def slice!( index_start_or_range, length = nil )
-    slice = nil
-    start_index = nil
-    end_index = nil
-    if index_start_or_range.is_a?( Range )
-      start_index = index_start_or_range.begin
-      end_index = index_start_or_range.end
-    elsif length
-      start_index = index_start_or_range
-      end_index = index_start_or_range + length
-    end
-    if end_index
-      indexes = [ ]
-      ( end_index - start_index ).times do |this_time|
-        indexes.push( end_index - this_time - 1 )
-      end
-      slice = delete_at_indexes( *indexes )
-    else
-      slice = delete_at( start_index )
-    end
-    return slice
-  end
-  ###########
-  #  clear  #
-  ###########
-  def clear
-    indexes = [ ]
-    count.times do |this_time|
-      indexes.push( count - this_time - 1 )
-    end
-    delete_at_indexes( *indexes )
-    return self
-  end
-  #############
-  #  freeze!  #
-  #############
-  # freezes configuration and prevents ancestors from changing this configuration in the future
-  def freeze!
-    # unregister with parent composite so we don't get future updates from it
-    if @super_composite_array
-      @super_composite_array.unregister_sub_composite_array( self )
-    end
-    return self
-  end
-  ##################################################################################################
-      private ######################################################################################
-  ##################################################################################################
-	################  Self Management for Inserts between Parent-Provided Elements  ##################
-  ###################################
-  #  index_inside_parent_objects?  #
-  ###################################
-  def index_inside_parent_objects?( index )
-    index_inside_parent_objects = false
-    if index < @parent_and_interpolated_object_count
-      index_inside_parent_objects = true
-    end
-    return index_inside_parent_objects
-  end
-  #################################################
-  #  update_corresponding_index_for_local_change  #
-  #################################################
-  def update_corresponding_index_for_local_change( index, step_value )
-    # update corresponding indexes for changes in self
-    indexes_to_delete = [ ]
-    @local_index_for_parent_index.each do |this_parent_index, this_local_index|
-      if this_parent_index >= index
-        existing_corresponding_value = @local_index_for_parent_index[ this_parent_index ]
-        new_corresponding_value = existing_corresponding_value + step_value
-        if new_corresponding_value >= 0
-          @local_index_for_parent_index[ this_parent_index ] = new_corresponding_value
-        else
-          indexes_to_delete.push( this_parent_index )
-        end
-      end
-    end
-    step_parent_and_interpolated_object_count( step_value )
-  end
-  #########################  Self-as-Sub Management for Parent Updates  ############################
-  ########################################
-  #  update_as_sub_array_for_parent_set  #
-  ########################################
-  def update_as_sub_array_for_parent_set( index, object )
-    # if our index is bigger than current parent set we are inserting
-    if index >= @parent_and_interpolated_object_count
-      update_as_sub_array_for_parent_insert( index, object )
-    # otherwise we are replacing and have a corresponding element defined already
-    else
-      unless @replaced_parents[ index ]
-        corresponding_index = @local_index_for_parent_index[ index ]
-        non_cascading_set( corresponding_index, object )
-        @sub_composite_arrays.each do |this_array|
-          this_array.instance_eval do
-            update_as_sub_array_for_parent_set( corresponding_index, object )
-          end
-        end
-      end
-    end
-  end
-  ###########################################
-  #  update_as_sub_array_for_parent_insert  #
-  ###########################################
-  def update_as_sub_array_for_parent_insert( index, *objects )
-    # new parent indexes have been inserted at index in parent
-    # we need the corresponding index in self where parallel insert will occur
-    if corresponding_index = @local_index_for_parent_index[ index ]
-      if corresponding_index < 0
-        corresponding_index = 0
-      else
-        update_corresponding_index_for_parent_change( index, objects.count )
-      end
-    else
-      corresponding_index = @parent_and_interpolated_object_count
-      @parent_and_interpolated_object_count += objects.count
-    end
-    # then we're going to increment existing correspondences
-    # now since we added a space for the new elements we can add their new correspondences
-    objects.count.times do |this_time|
-      new_parent_index = index + this_time
-      new_corresponding_index = corresponding_index + this_time
-      @local_index_for_parent_index[ new_parent_index ] = new_corresponding_index
-    end
-    non_cascading_insert( corresponding_index, *objects )
-    @sub_composite_arrays.each do |this_array|
-      this_array.instance_eval do
-        update_as_sub_array_for_parent_insert( corresponding_index, *objects )
-      end
-    end
-  end
-  ###########################################
-  #  update_as_sub_array_for_parent_delete  #
-  ###########################################
-  def update_as_sub_array_for_parent_delete( index )
-    corresponding_index = @local_index_for_parent_index[ index ]
-    object = non_cascading_delete_at( corresponding_index )
-    @parent_and_interpolated_object_count -= 1
-    @sub_composite_arrays.each do |this_array|
-      this_array.instance_eval do
-        update_as_sub_array_for_parent_delete( corresponding_index )
-      end
-    end
-  end
-  ##################################################
-  #  update_corresponding_index_for_parent_change  #
-  ##################################################
-  def update_corresponding_index_for_parent_change( parent_index, step_value )
-      # update corresponding indexes for changes in parent
-    stepped_indices = { }
-    # iterate the hash with all indices included and increment/decrement any >= parent_index
-    @local_index_for_parent_index.each do |this_parent_index, this_local_index|
-      if this_parent_index >= parent_index
-        new_index = this_parent_index + step_value
-        stepped_indices[ new_index ] = @local_index_for_parent_index.delete( this_parent_index ) + step_value
-      end
-    end
-    # merge stepped indices back in
-    @local_index_for_parent_index.merge!( stepped_indices )
-    step_parent_and_interpolated_object_count( step_value )
-  end
-  ###############################################
-  #  step_parent_and_interpolated_object_count  #
-  ###############################################
-  def step_parent_and_interpolated_object_count( step_value )
-    @parent_and_interpolated_object_count += step_value
-    if @parent_and_interpolated_object_count < 0
-      @parent_and_interpolated_object_count = 0
-    end
-  end
-end