hash-compositing 1.0.0

data/README.md

@@ -0,0 +1,65 @@
+# CompositingHash #
+
+http://rubygems.org/gems/hash-compositing
+
+# Description #
+
+Provides CompositingHash.
+
+# Summary #
+
+An implementation of Hash that permits chaining, where children inherit changes to parent and where parent settings can be overridden in children.
+
+# Install #
+
+* sudo gem install hash-compositing
+
+# Usage #
+
+```ruby
+compositing_hash = CompositingHash.new
+sub_compositing_hash = CompositingHash.new( compositing_hash )
+
+compositing_hash[ :some_key ] = :some_value
+# compositing_hash
+# => { :some_key => :some_value }
+# sub_compositing_hash
+# => { :some_key => :some_value }
+
+compositing_hash.delete( :some_key )
+# compositing_hash
+# => { }
+# sub_compositing_hash
+# => { }
+
+sub_compositing_hash[ :some_key ] = :some_value
+# compositing_hash
+# => { }
+# sub_compositing_hash
+# => { :some_key => :some_value }
+```
+
+# 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/hash-compositing.rb

@@ -0,0 +1,2 @@
+
+require_relative 'hash/compositing.rb'

data/lib/hash/compositing.rb

@@ -0,0 +1,14 @@
+
+require 'hash/hooked'
+
+# namespaces that have to be declared ahead of time for proper load order
+require_relative './namespaces'
+
+# source file requires
+require_relative './requires.rb'
+
+class ::CompositingHash < ::HookedHash
+
+  include ::CompositingHash::HashInterface
+  
+end

data/lib/hash/compositing/hash_interface.rb

@@ -0,0 +1,405 @@
+
+module ::CompositingHash::HashInterface
+    
+  ##########################
+  #  self.append_features  #
+  ##########################
+  
+  def self.append_features( instance )
+    
+    instance.module_eval do
+      
+      private
+        
+        alias_method :non_cascading_store, :[]=
+
+        alias_method :non_cascading_delete, :delete
+
+    end
+    
+    super
+
+  end
+  
+  ###################
+  #  self.included  #
+  ###################
+
+  def self.included( instance )
+    
+    instance.module_eval do
+      
+      alias_method :store, :[]=
+    
+    end
+    
+    super
+    
+  end
+
+  ################
+  #  initialize  #
+  ################
+  
+  def initialize( parent_composite_hash = nil, configuration_instance = nil )
+    
+    super( configuration_instance )
+        
+    @replaced_parents = { }
+    @parent_key_lookup = { }
+
+    # we may later have our own child composites that register with us
+    @sub_composite_hashes = [ ]
+
+    initialize_for_parent( parent_composite_hash )
+    
+  end
+
+  #############################
+  #  parent_composite_object  #
+  #  parent_composite_hash    #
+  #############################
+
+  attr_accessor :parent_composite_object
+
+  alias_method :parent_composite_hash, :parent_composite_object
+
+  ###################################  Sub-Hash Management  #######################################
+
+  ###########################
+  #  initialize_for_parent  #
+  ###########################
+
+  def initialize_for_parent( parent_composite_hash )
+
+    if @parent_composite_object = parent_composite_hash
+
+      @parent_composite_object.register_sub_composite_hash( self )
+
+      # @parent_key_lookup tracks keys that we have not yet received from parent
+      @parent_composite_object.each do |this_key, this_object|
+        @parent_key_lookup[ this_key ] = true
+        non_cascading_store( this_key, nil )
+      end
+      
+    end
+
+  end
+  
+  #################################
+  #  register_sub_composite_hash  #
+  #################################
+
+  def register_sub_composite_hash( sub_composite_hash )
+
+    @sub_composite_hashes.push( sub_composite_hash )
+
+    return self
+
+  end
+
+  ###################################
+  #  unregister_sub_composite_hash  #
+  ###################################
+
+  def unregister_sub_composite_hash( sub_composite_hash )
+
+    @sub_composite_hashes.delete( sub_composite_hash )
+
+    return self
+
+  end
+
+  ######################################  Subclass Hooks  ##########################################
+
+  ########################
+  #  child_pre_set_hook  #
+  ########################
+
+  def child_pre_set_hook( key, object )
+
+    return object
+    
+  end
+
+  #########################
+  #  child_post_set_hook  #
+  #########################
+
+  def child_post_set_hook( key, object )
+    
+    return object
+    
+  end
+
+  ###########################
+  #  child_pre_delete_hook  #
+  ###########################
+
+  def child_pre_delete_hook( key )
+    
+    # false means delete does not take place
+    return true
+    
+  end
+
+  ############################
+  #  child_post_delete_hook  #
+  ############################
+
+  def child_post_delete_hook( key, object )
+    
+    return object
+    
+  end
+  
+  #####################################  Self Management  ##########################################
+  
+  ########
+  #  ==  #
+  ########
+
+  def ==( object )
+    
+    load_parent_state
+    
+    super
+    
+  end
+  
+  ##########
+  #  each  #
+  ##########
+  
+  def each( *args, & block )
+    
+    load_parent_state
+
+    super
+    
+  end
+
+  ##########
+  #  to_s  #
+  ##########
+  
+  def to_s
+   
+    load_parent_state
+   
+    super
+    
+  end
+
+  #############
+  #  inspect  #
+  #############
+  
+  def inspect
+   
+    load_parent_state
+   
+    super
+    
+  end
+    
+  ########
+  #  []  #
+  ########
+  
+  def []( key )
+    
+    return_value = nil
+
+    if @parent_key_lookup[ key ]
+      return_value = lazy_set_parent_element_in_self( key, @parent_composite_object[ key ] )
+    else
+      return_value = super
+    end
+
+    return return_value
+    
+  end
+  
+  #########
+  #  []=  #
+  #########
+
+  def []=( key, object )
+
+    @replaced_parents[ key ] = true
+    
+    @parent_key_lookup.delete( key )
+    
+    super
+    
+    @sub_composite_hashes.each do |this_sub_hash|
+      this_sub_hash.instance_eval do
+        update_as_sub_hash_for_parent_store( key )
+      end
+    end
+        
+    return object
+
+  end
+
+  ############
+  #  delete  #
+  ############
+  
+  def delete( key )
+
+    @replaced_parents.delete( key )
+
+    @parent_key_lookup.delete( key )
+
+    object = super
+
+    @sub_composite_hashes.each do |this_sub_hash|
+      this_sub_hash.instance_eval do
+        update_as_sub_hash_for_parent_delete( key, object )
+      end
+    end
+
+    return object
+
+  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 @parent_composite_object
+      @parent_composite_object.unregister_sub_composite_hash( self )
+    end
+    
+    return self
+    
+  end
+
+  ##################################################################################################
+      private ######################################################################################
+  ##################################################################################################
+
+  #########################  Self-as-Sub Management for Parent Updates  ############################
+
+  ################################
+  #  lazy_set_parent_element_in_self  #
+  ################################
+  
+  def lazy_set_parent_element_in_self( key, object )
+
+    unless @without_child_hooks
+      object = child_pre_set_hook( key, object )
+    end
+    
+    unless @without_hooks
+      object = pre_set_hook( key, object )
+    end
+    
+    non_cascading_store( key, object )
+  
+    unless @without_hooks
+      object = post_set_hook( key, object )
+    end
+
+    unless @without_child_hooks
+      object = child_post_set_hook( key, object )
+    end
+    
+    return object
+    
+  end
+
+  #########################################
+  #  update_as_sub_hash_for_parent_store  #
+  #########################################
+
+  def update_as_sub_hash_for_parent_store( key )
+        
+    unless @replaced_parents[ key ]
+    
+      @parent_key_lookup[ key ] = true
+      
+      @sub_composite_hashes.each do |this_hash|
+        this_hash.instance_eval do
+          update_as_sub_hash_for_parent_store( key )
+        end
+      end
+    
+    end
+    
+  end
+  
+  ##########################################
+  #  update_as_sub_hash_for_parent_delete  #
+  ##########################################
+
+  def update_as_sub_hash_for_parent_delete( key, object )
+
+    unless @replaced_parents[ key ]
+            
+      if @without_child_hooks
+        child_pre_delete_hook_result = true
+      else
+        child_pre_delete_hook_result = child_pre_delete_hook( key )
+      end
+      
+      if @without_hooks
+        pre_delete_hook_result = true
+      else
+        pre_delete_hook_result = pre_delete_hook( key )
+      end
+
+      if child_pre_delete_hook_result and pre_delete_hook_result
+        
+        @parent_key_lookup.delete( key )
+        
+        object = non_cascading_delete( key )
+        
+        unless @without_hooks
+          post_delete_hook( key, object )
+        end
+
+        unless @without_child_hooks
+          child_post_delete_hook( key, object )
+        end
+      
+      else
+        
+        # if we were told not to delete in child when parent delete
+        # and the child does not yet have its parent value
+        # then we need to get it now
+        if @parent_key_lookup.delete( key )
+          lazy_set_parent_element_in_self( key, object )
+        end
+        
+      end
+      
+      @sub_composite_hashes.each do |this_hash|
+        this_hash.instance_eval do
+          update_as_sub_hash_for_parent_delete( key, object )
+        end
+      end
+    
+    end
+    
+  end
+
+  #######################
+  #  load_parent_state  #
+  #######################
+
+  def load_parent_state
+     
+    @parent_key_lookup.each do |this_key, true_value|
+      self[ this_key ]
+    end
+   
+  end
+  
+end

data/lib/hash/hooked/compositing.rb

@@ -0,0 +1,2 @@
+
+require_relative '../compositing.rb'

data/lib/hash/namespaces.rb

@@ -0,0 +1,3 @@
+
+class ::CompositingHash < ::HookedHash
+end

data/lib/hash/requires.rb

@@ -0,0 +1,3 @@
+
+require_relative 'compositing/hash_interface.rb'
+require_relative 'compositing.rb'

data/spec/hash/compositing_spec.rb

@@ -0,0 +1,648 @@
+
+require_relative '../../lib/hash-compositing.rb'
+
+describe ::CompositingHash do
+
+  before :all do
+
+    module ::CompositingHash::MockA
+      # needed for ccv ancestor determination
+      def self.some_configuration
+      end
+    end
+    module ::CompositingHash::MockB
+    end
+      
+    @configuration_instance = ::CompositingHash::MockA
+    @sub_configuration_instance = ::CompositingHash::MockB
+    
+  end
+
+  ################
+  #  initialize  #
+  ################
+
+  it 'can add initialize with an ancestor, inheriting its values and linking to it as a child' do
+  
+    cascading_composite_hash = ::CompositingHash.new
+
+    cascading_composite_hash.instance_variable_get( :@parent_composite_object ).should == nil
+    cascading_composite_hash.should == {}
+    cascading_composite_hash[ :A ] = 1
+    cascading_composite_hash[ :B ] = 2
+    cascading_composite_hash[ :C ] = 3
+    cascading_composite_hash[ :D ] = 4
+    cascading_composite_hash.should == { :A => 1,
+                                         :B => 2,
+                                         :C => 3,
+                                         :D => 4 }
+    
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+    sub_cascading_composite_hash.instance_variable_get( :@parent_composite_object ).should == cascading_composite_hash
+    sub_cascading_composite_hash.should == { :A => 1,
+                                             :B => 2,
+                                             :C => 3,
+                                             :D => 4 }
+
+  end
+
+  ##################################################################################################
+  #    private #####################################################################################
+  ##################################################################################################
+
+  #########################################
+  #  update_as_sub_hash_for_parent_store  #
+  #########################################
+
+  it 'can update for a parent store' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    cascading_composite_hash[ :A ] = 1
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+    
+    sub_cascading_composite_hash.instance_eval do
+      update_as_sub_hash_for_parent_store( :A )
+      self.should == { :A => 1 }
+    end
+    
+  end
+
+  ##########################################
+  #  update_as_sub_hash_for_parent_delete  #
+  ##########################################
+
+  it 'can update for a parent delete' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+    
+    cascading_composite_hash[ :A ] = 1
+    cascading_composite_hash.should == { :A => 1 }
+    sub_cascading_composite_hash.should == { :A => 1 }
+
+    sub_cascading_composite_hash.instance_eval do
+      update_as_sub_hash_for_parent_delete( :A, 1 )
+      self.should == { }
+    end
+    
+  end
+
+  ##################################################################################################
+  #    public ######################################################################################
+  ##################################################################################################
+
+  #########
+  #  []=  #
+  #########
+
+  it 'can add elements' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+    
+    cascading_composite_hash[ :some_setting ] = :some_value
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting => :some_value }
+
+    cascading_composite_hash[ :other_setting ] = :some_value
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+
+    sub_cascading_composite_hash[ :yet_another_setting ] = :some_value
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting        => :some_value,
+                                             :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+
+    cascading_composite_hash.method( :[]= ).should == cascading_composite_hash.method( :store )
+    
+  end
+
+  ############
+  #  delete  #
+  ############
+
+  it 'can delete elements' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting   => :some_value }
+
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+
+    cascading_composite_hash.delete( :some_setting )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+
+    sub_cascading_composite_hash.delete( :other_setting )
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+
+  ###############
+  #  delete_if  #
+  ###############
+
+  it 'can delete elements with a block' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting => :some_value }
+
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+    cascading_composite_hash.delete_if do |key, value|
+      key == :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.delete_if do |key, value|
+      key == :other_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+
+  end
+
+  #############
+  #  reject!  #
+  #############
+
+  it 'can delete elements with a block' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting => :some_value }
+
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+    cascading_composite_hash.reject! do |key, value|
+      key == :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.reject! do |key, value|
+      key == :other_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+
+  end
+  
+  #############
+  #  keep_if  #
+  #############
+
+  it 'can keep elements with a block' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting => :some_value }
+
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+    cascading_composite_hash.keep_if do |key, value|
+      key != :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.keep_if do |key, value|
+      key != :other_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+
+  end
+
+  #############
+  #  select!  #
+  #############
+
+  it 'can keep elements with a block' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting => :some_value }
+
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :some_setting  => :some_value,
+                                             :other_setting => :some_value }
+    cascading_composite_hash.select! do |key, value|
+      key != :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.select! do |key, value|
+      key != :other_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+
+  end
+  
+  ############
+  #  merge!  #
+  #  update  #
+  ############
+  
+  it 'can merge from another hash' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.merge!( :some_setting => :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    cascading_composite_hash.merge!( :other_setting => :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+
+    sub_cascading_composite_hash.should == { :some_setting    => :some_value,
+                                             :other_setting   => :some_value }
+    sub_cascading_composite_hash.merge!( :yet_another_setting => :some_value )
+    sub_cascading_composite_hash.should == { :some_setting        => :some_value,
+                                             :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+
+  end
+  
+  #############
+  #  replace  #
+  #############
+  
+  it 'can replace existing elements with others' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.replace( :some_setting => :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    cascading_composite_hash.replace( :other_setting => :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.should == { :other_setting   => :some_value }
+    sub_cascading_composite_hash.replace( :yet_another_setting => :some_value )
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+
+  end
+
+  ###########
+  #  shift  #
+  ###########
+  
+  it 'can shift the first element' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    cascading_composite_hash.shift
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.should == { :other_setting   => :some_value }
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.shift
+    sub_cascading_composite_hash.should == { :yet_another_setting => :some_value }
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+
+  ###########
+  #  clear  #
+  ###########
+  
+  it 'can clear, causing present elements to be excluded' do
+
+    cascading_composite_hash = ::CompositingHash.new
+    sub_cascading_composite_hash = ::CompositingHash.new( cascading_composite_hash )
+
+    cascading_composite_hash.store( :some_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting => :some_value }
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :some_setting  => :some_value,
+                                         :other_setting => :some_value }
+    cascading_composite_hash.clear
+    cascading_composite_hash.should == { }
+    cascading_composite_hash.store( :other_setting, :some_value )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+    sub_cascading_composite_hash.should == { :other_setting   => :some_value }
+    sub_cascading_composite_hash.store( :yet_another_setting, :some_value )
+    sub_cascading_composite_hash.should == { :other_setting       => :some_value,
+                                             :yet_another_setting => :some_value }
+    sub_cascading_composite_hash.clear
+    sub_cascading_composite_hash.should == { }
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  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 ::CompositingHash::SubMockPreSet < ::CompositingHash
+      
+      def pre_set_hook( key, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPreSet.new
+
+    cascading_composite_hash[ :some_key ] = :some_value
+    
+    cascading_composite_hash.should == { :some_key => :some_other_value }
+    
+  end
+
+  ###################
+  #  post_set_hook  #
+  ###################
+
+  it 'has a hook that is called after setting a value' do
+
+    class ::CompositingHash::SubMockPostSet < ::CompositingHash
+      
+      def post_set_hook( key, object, is_insert = false )
+        unless key == :some_other_key
+          self[ :some_other_key ] = :some_other_value
+        end
+        return object
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPostSet.new
+
+    cascading_composite_hash[ :some_key ] = :some_value
+    
+    cascading_composite_hash.should == { :some_key => :some_value,
+                                          :some_other_key => :some_other_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 ::CompositingHash::SubMockPreGet < ::CompositingHash
+      
+      def pre_get_hook( key )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPreGet.new
+    
+    cascading_composite_hash[ :some_key ] = :some_value
+    cascading_composite_hash[ :some_key ].should == nil
+    
+    cascading_composite_hash.should == { :some_key => :some_value }
+    
+  end
+
+  ###################
+  #  post_get_hook  #
+  ###################
+
+  it 'has a hook that is called after getting a value' do
+
+    class ::CompositingHash::SubMockPostGet < ::CompositingHash
+      
+      def post_get_hook( key, object )
+        self[ :some_other_key ] = :some_other_value
+        return object
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPostGet.new
+    
+    cascading_composite_hash[ :some_key ] = :some_value
+
+    cascading_composite_hash.should == { :some_key => :some_value }
+    
+    cascading_composite_hash[ :some_key ].should == :some_value
+    
+    cascading_composite_hash.should == { :some_key => :some_value,
+                                         :some_other_key => :some_other_value }
+    
+  end
+
+  #####################
+  #  pre_delete_hook  #
+  #####################
+
+  it 'has a hook that is called before deleting an key; if return value is false, delete does not occur' do
+    
+    class ::CompositingHash::SubMockPreDelete < ::CompositingHash
+      
+      def pre_delete_hook( key )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPreDelete.new
+    
+    cascading_composite_hash[ :some_key ] = :some_value
+    cascading_composite_hash.delete( :some_key )
+    
+    cascading_composite_hash.should == { :some_key => :some_value }
+    
+  end
+
+  ######################
+  #  post_delete_hook  #
+  ######################
+
+  it 'has a hook that is called after deleting an key' do
+    
+    class ::CompositingHash::SubMockPostDelete < ::CompositingHash
+      
+      def post_delete_hook( key, object )
+        unless key == :some_other_key
+          delete( :some_other_key )
+        end
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockPostDelete.new
+    
+    cascading_composite_hash[ :some_key ] = :some_value
+    cascading_composite_hash[ :some_other_key ] = :some_other_value
+    cascading_composite_hash.delete( :some_key )
+    
+    cascading_composite_hash.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 ::CompositingHash::SubMockChildPreSet < ::CompositingHash
+      
+      def child_pre_set_hook( key, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockChildPreSet.new
+    sub_cascading_composite_hash = ::CompositingHash::SubMockChildPreSet.new( cascading_composite_hash )
+
+    cascading_composite_hash[ :some_key ] = :some_value
+
+    cascading_composite_hash.should == { :some_key => :some_value }
+    sub_cascading_composite_hash.should == { :some_key => :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 ::CompositingHash::SubMockChildPostSet < ::CompositingHash
+      
+      def child_post_set_hook( key, object, is_insert = false )
+        self[ :some_other_key ] = :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockChildPostSet.new
+    sub_cascading_composite_hash = ::CompositingHash::SubMockChildPostSet.new( cascading_composite_hash )
+    cascading_composite_hash[ :some_key ] = :some_value
+
+    cascading_composite_hash.should == { :some_key => :some_value }
+    sub_cascading_composite_hash.should == { :some_key => :some_value,
+                                             :some_other_key => :some_other_value }
+    
+  end
+
+  ###########################
+  #  child_pre_delete_hook  #
+  ###########################
+
+  it 'has a hook that is called before deleting an key that has been passed by a parent; if return value is false, delete does not occur' do
+
+    class ::CompositingHash::SubMockChildPreDelete < ::CompositingHash
+      
+      def child_pre_delete_hook( key )
+        false
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockChildPreDelete.new
+    sub_cascading_composite_hash = ::CompositingHash::SubMockChildPreDelete.new( cascading_composite_hash )
+    cascading_composite_hash[ :some_key ] = :some_value
+    cascading_composite_hash.delete( :some_key )
+
+    cascading_composite_hash.should == { }
+    sub_cascading_composite_hash.should == { :some_key => :some_value }
+    
+  end
+
+  ############################
+  #  child_post_delete_hook  #
+  ############################
+
+  it 'has a hook that is called after deleting an key passed by a parent' do
+
+    class ::CompositingHash::SubMockChildPostDelete < ::CompositingHash
+      
+      def child_post_delete_hook( key, object )
+        delete( :some_other_key )
+      end
+      
+    end
+    
+    cascading_composite_hash = ::CompositingHash::SubMockChildPostDelete.new
+    sub_cascading_composite_hash = ::CompositingHash::SubMockChildPostDelete.new( cascading_composite_hash )
+    cascading_composite_hash[ :some_key ] = :some_value
+    sub_cascading_composite_hash[ :some_other_key ] = :some_other_value
+    cascading_composite_hash.delete( :some_key )
+
+    cascading_composite_hash.should == { }
+    sub_cascading_composite_hash.should == { }
+    
+  end
+  
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: hash-compositing
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Asher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hash-hooked
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An implementation of Hash that permits chaining, where children inherit
+  changes to parent and where parent settings can be overridden in children.
+email: asher@ridiculouspower.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hash/compositing/hash_interface.rb
+- lib/hash/compositing.rb
+- lib/hash/hooked/compositing.rb
+- lib/hash/namespaces.rb
+- lib/hash/requires.rb
+- lib/hash-compositing.rb
+- spec/hash/compositing_spec.rb
+- README.md
+- README.rdoc
+homepage: http://rubygems.org/gems/hash-compositing
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: hash-compositing
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides Hash::Compositing.
+test_files: []
+has_rdoc: