hash-hooked 1.0.0

data/CHANGELOG.rdoc

@@ -0,0 +1,8 @@
+
+== 6/15/2012
+
+Initial release - split from compositing-hash.
+
+== 6/30/2012
+
+Renamed from hooked-hash to hash-hooked. File schema updated to reflect gem name.

data/README.md

@@ -0,0 +1,58 @@
+# Hooked Hash #
+
+http://rubygems.org/gems/hash-hooked
+
+# Description #
+
+Provides ::Hash::Hooked and ::HookedHash.
+
+# Summary #
+
+A subclass of Hash that offers event hooks for pre-set/pre-delete, set/delete. ::HookedHash offers implicit reference to a configuration instance.
+
+# Install #
+
+* sudo gem install hash-hooked
+
+# Usage #
+
+Provides methods that can be overridden that will be called during every corresponding event:
+
+* pre_set_hook
+* post_set_hook
+* pre_get_hook
+* post_get_hook
+* pre_delete_hook
+* post_delete_hook
+
+As a result, several internal perform methods have been created:
+
+* perform_set_between_hooks
+* perform_delete_between_hooks
+
+Also provides methods corresponding to each already-existing method + '_without_hooks', which causes methods to bypass hooks.
+
+# 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-hooked.rb

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

data/lib/hash/hooked.rb

@@ -0,0 +1,29 @@
+
+require 'identifies_as'
+
+# namespaces that have to be declared ahead of time for proper load order
+require_relative './namespaces'
+
+# source file requires
+require_relative './requires.rb'
+
+class ::Hash::Hooked < ::Hash
+
+  # Alias to original :[]= method. Used to perform actual set between hooks.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element being stored.
+  # @return [Object] Element returned.
+  alias_method :perform_set_between_hooks, :store
+
+  # Alias to original :delete method. Used to perform actual delete between hooks.
+  # @param [Object] key Key where object is to be stored.
+  # @return [Object] Element returned.
+  alias_method :perform_delete_between_hooks, :delete
+
+  # Alias to original :merge method. Used to perform actual merge between hooks.
+  # @return [Object] Self.
+  alias_method :perform_merge_between_hooks!, :merge!
+
+  include ::Hash::Hooked::HashInterface
+  
+end

data/lib/hash/hooked/hash_interface.rb

@@ -0,0 +1,527 @@
+
+module ::Hash::Hooked::HashInterface
+  
+  instances_identify_as!( ::Hash::Hooked )
+  
+  ######################################  Subclass Hooks  ##########################################
+
+  ##################
+  #  pre_set_hook  #
+  ##################
+
+  # A hook that is called before setting a value; return value is used in place of object.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element being stored.
+  # @return [true,false] Return value is used in place of object.
+  def pre_set_hook( key, object )
+    
+    return object
+    
+  end
+
+  ###################
+  #  post_set_hook  #
+  ###################
+
+  # A hook that is called after setting a value.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element being stored.
+  # @return [Object] Ignored.
+  def post_set_hook( key, object )
+
+    return object
+    
+  end
+
+  ##################
+  #  pre_get_hook  #
+  ##################
+
+  # A hook that is called before getting a value; if return value is false, get does not occur.
+  # @param [Object] key Key where object is to be stored.
+  # @return [true,false] If return value is false, get does not occur.
+  def pre_get_hook( key )
+    
+    return true
+    
+  end
+
+  ###################
+  #  post_get_hook  #
+  ###################
+
+  # A hook that is called after getting a value.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element being stored.
+  # @return [Object] Object returned in place of get result.
+  def post_get_hook( key, object )
+    
+    return object
+    
+  end
+
+  #####################
+  #  pre_delete_hook  #
+  #####################
+
+  # A hook that is called before deleting a value; if return value is false, delete does not occur.
+  # @param [Object] key Key where object is to be stored.
+  # @return [true,false] If return value is false, delete does not occur.
+  def pre_delete_hook( key )
+    
+    return true
+    
+  end
+
+  ######################
+  #  post_delete_hook  #
+  ######################
+
+  # A hook that is called after deleting a value.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element deleted.
+  # @return [Object] Object returned in place of delete result.
+  def post_delete_hook( key, object )
+    
+    return object
+    
+  end
+
+  #####################################  Self Management  ##########################################
+
+  ########
+  #  []  #
+  ########
+
+  def []( key )
+
+    object = nil
+    
+    if @without_hooks
+      pre_get_hook_result = true
+    else
+      pre_get_hook_result = pre_get_hook( key )
+    end
+    
+    if pre_get_hook_result
+    
+      object = super( key )
+      
+      unless @without_hooks
+        object = post_get_hook( key, object )
+      end
+      
+    end
+      
+    return object
+    
+  end
+
+  #######################
+  #  get_without_hooks  #
+  #######################
+
+  # Alias to :[] that bypasses hooks.
+  # @param [Object] key Key where object is to be stored.
+  # @return [Object] Element returned.
+  def get_without_hooks( key )
+    
+    @without_hooks = true
+    
+    object = self[ key ]
+    
+    @without_hooks = false
+    
+    return object
+    
+  end
+  
+  #########
+  #  []=  #
+  #########
+  
+  def []=( key, object )
+    
+    unless @without_hooks
+      object = pre_set_hook( key, object )
+    end
+    
+    perform_set_between_hooks( key, object )
+
+    unless @without_hooks
+      object = post_set_hook( key, object )
+    end
+    
+    return object
+
+  end
+  
+  alias_method :store, :[]=
+
+  #########################
+  #  store_without_hooks  #
+  #########################
+
+  # Alias to :[]= that bypasses hooks.
+  # @param [Object] key Key where object is to be stored.
+  # @param [Object] object Element being set.
+  # @return [Object] Element returned.
+  def store_without_hooks( key, object )
+    
+    @without_hooks = true
+    
+    self[ key ] = object
+    
+    @without_hooks = false
+    
+    return object
+    
+  end
+
+  ############
+  #  delete  #
+  ############
+  
+  def delete( key )
+
+    object = nil
+    
+    if @without_hooks
+      pre_delete_result = true
+    else
+      pre_delete_result = pre_delete_hook( key )
+    end
+    
+    if pre_delete_result
+    
+      object = perform_delete_between_hooks( key )
+      
+      unless @without_hooks
+        object = post_delete_hook( key, object )
+      end
+      
+    end
+    
+    return object
+
+  end
+
+  ##########################
+  #  delete_without_hooks  #
+  ##########################
+
+  # Alias to :delete that bypasses hooks.
+  # @param [Object] object Element being deleted.
+  # @return [Object] Element returned.
+  def delete_without_hooks( key )
+    
+    @without_hooks = true
+    
+    object = delete( key )
+    
+    @without_hooks = false
+    
+    return object
+    
+  end
+
+  ###############
+  #  delete_if  #
+  ###############
+
+  def delete_if
+
+    return to_enum unless block_given?
+
+    indexes = [ ]
+    
+    self.each do |this_key, this_object|
+      if yield( this_key, this_object )
+        delete( this_key )
+      end
+    end
+        
+    return self
+
+  end
+
+  #############################
+  #  delete_if_without_hooks  #
+  #############################
+
+  # Alias to :delete_if that bypasses hooks.
+  # @yield Block passed to :delete_if.
+  # @return [Object] Deleted element.
+  def delete_if_without_hooks( & block )
+    
+    @without_hooks = true
+    
+    delete_if( & block )
+    
+    @without_hooks = false
+    
+  end
+
+  #############
+  #  reject!  #
+  #############
+
+  def reject!
+
+    return to_enum unless block_given?
+    
+    return_value = nil
+    
+    self.each do |this_key, this_object|
+      if yield( this_key, this_object )
+        delete( this_key )
+        return_value = self
+      end
+    end
+    
+    return return_value
+
+  end
+
+  ###########################
+  #  reject_without_hooks!  #
+  ###########################
+
+  # Alias to :reject that bypasses hooks.
+  # @yield Block passed to :keep_if.
+  # @return [Object] Self.
+  def reject_without_hooks!
+    
+    @without_hooks = true
+    
+    return_value = reject!( & block )
+    
+    @without_hooks = false
+    
+    return return_value
+    
+  end
+
+  #############
+  #  keep_if  #
+  #############
+
+  def keep_if
+
+    return to_enum unless block_given?
+
+    indexes = [ ]
+    
+    self.each do |this_key, this_object|
+      unless yield( this_key, this_object )
+        delete( this_key )
+      end
+    end
+        
+    return self
+
+
+  end
+  
+  ###########################
+  #  keep_if_without_hooks  #
+  ###########################
+
+  # Alias to :keep_if that bypasses hooks.
+  # @yield Block passed to :keep_if.
+  # @return [Object] Deleted element.
+  def keep_if_without_hooks( & block )
+    
+    @without_hooks = true
+    
+    keep_if( & block )
+    
+    @without_hooks = false
+    
+    return self
+    
+  end
+  
+  #############
+  #  select!  #
+  #############
+
+  def select!
+
+    return to_enum unless block_given?
+    
+    return_value = nil
+    
+    self.each do |this_key, this_object|
+      unless yield( this_key, this_object )
+        delete( this_key )
+        return_value = self
+      end
+    end
+    
+    return return_value
+
+  end
+
+  ###########################
+  #  select_without_hooks!  #
+  ###########################
+
+  # Alias to :select that bypasses hooks.
+  # @yield Block passed to :select!.
+  # @return [Object] Self.
+  def select_without_hooks!( & block )
+    
+    @without_hooks = true
+    
+    return_value = select!( & block )
+    
+    @without_hooks = false
+    
+    return return_value
+    
+  end
+
+  ############
+  #  merge!  #
+  #  update  #
+  ############
+
+  def merge!( other_hash )
+
+    other_hash.each do |this_key, this_object|
+      if @compositing_proc
+        self[ this_key ] = @compositing_proc.call( self, this_key, this_object )
+      else
+        self[ this_key ] = this_object
+      end
+    end
+
+    return self
+
+  end
+
+  alias_method :update, :merge!
+  
+  ##########################
+  #  merge_without_hooks!  #
+  #  update_without_hooks  #
+  ##########################
+
+  # Alias to :merge! that bypasses hooks.
+  # @return [Object] Self.
+  def merge_without_hooks!
+    
+    @without_hooks = true
+    
+    merge!( other_hash )
+    
+    @without_hooks = false
+    
+    return self
+    
+  end
+  
+  alias_method :update_without_hooks, :merge_without_hooks!
+  
+  #############
+  #  replace  #
+  #############
+  
+  def replace( other_hash )
+
+    # clear current values
+    clear
+
+    # merge replacement settings
+    merge!( other_hash )
+
+    return self
+
+  end
+
+  ###########################
+  #  replace_without_hooks  #
+  ###########################
+
+  # Alias to :replace that bypasses hooks.
+  # @param [Array] other_array Other array to replace self with.
+  # @return [Object] Self.
+  def replace_without_hooks( other_hash )
+    
+    @without_hooks = true
+    
+    replace( other_hash )
+    
+    @without_hooks = false
+    
+  end
+
+  ###########
+  #  shift  #
+  ###########
+  
+  def shift
+    
+    object = nil
+    
+    unless empty?
+      last_key = first[ 0 ]
+      object = delete( last_key )
+    end    
+
+    return [ last_key, object ]
+
+  end
+
+  #########################
+  #  shift_without_hooks  #
+  #########################
+
+  # Alias to :shift that bypasses hooks.
+  # @return [Object] Self.
+  def shift_without_hooks
+    
+    @without_hooks = true
+    
+    object = shift
+    
+    @without_hooks = false
+    
+    return object
+    
+  end
+
+  ###########
+  #  clear  #
+  ###########
+  
+  def clear
+
+    keys.each do |this_key|
+      delete( this_key )
+    end
+
+    return self
+
+  end
+  
+  #########################
+  #  clear_without_hooks  #
+  #########################
+
+  # Alias to :clear that bypasses hooks.
+  # @return [Object] Self.
+  def clear_without_hooks
+    
+    @without_hooks = true
+    
+    clear
+    
+    @without_hooks = false
+    
+    return self
+    
+  end
+  
+end

data/lib/hash/namespaces.rb

@@ -0,0 +1,6 @@
+
+class ::Hash::Hooked < ::Hash
+end
+
+class ::HookedHash < ::Hash::Hooked
+end

data/lib/hash/requires.rb

@@ -0,0 +1,26 @@
+
+basepath = 'hooked'
+
+files = [
+
+  'hash_interface'
+    
+]
+
+second_basepath = '../hooked_hash'
+
+second_files = [
+  
+  'hash_interface'
+  
+]
+
+files.each do |this_file|
+  require_relative( File.join( basepath, this_file ) + '.rb' )
+end
+second_files.each do |this_file|
+  require_relative( File.join( second_basepath, this_file ) + '.rb' )
+end
+
+require_relative( basepath + '.rb' )
+require_relative( second_basepath + '.rb' )

data/lib/hooked/hash.rb

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

data/lib/hooked_hash.rb

@@ -0,0 +1,6 @@
+
+class ::HookedHash < ::Hash::Hooked
+
+  include ::HookedHash::Interface
+  
+end

data/lib/hooked_hash/hash_interface.rb

@@ -0,0 +1,29 @@
+
+module ::HookedHash::Interface
+
+  instances_identify_as!( ::HookedHash )
+  
+  ################
+  #  initialize  #
+  ################
+
+  # Initialize with reference a configuration instance.
+  # @param [Object] object Object that HookedHash instance is attached to, primarily useful for
+  #  reference from hooks.
+  # @param [Hash<Object>] args Parameters passed through super to Hash#initialize.
+  # @return [true,false] Whether receiver identifies as object.
+  def initialize( configuration_instance = nil, *args )
+    
+    @configuration_instance = configuration_instance
+
+    super( *args )
+        
+  end
+
+  ############################
+  #  configuration_instance  #
+  ############################
+
+  attr_accessor :configuration_instance
+  
+end

data/spec/hash/hooked_spec.rb

@@ -0,0 +1,368 @@
+
+require_relative '../../lib/hash-hooked.rb'
+
+describe ::Hash::Hooked do
+
+  ################
+  #  initialize  #
+  ################
+
+  it 'can add initialize with an ancestor, inheriting its values and linking to it as a child' do
+  
+    cascading_composite_hash = ::Hash::Hooked.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 }
+
+  end
+
+  #########
+  #  []=  #
+  #########
+
+  it 'can add elements' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+    
+    cascading_composite_hash[ :some_setting ] = :some_value
+    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 }
+
+    cascading_composite_hash.method( :[]= ).should == cascading_composite_hash.method( :store )
+    
+  end
+
+  ############
+  #  delete  #
+  ############
+
+  it 'can delete elements' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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.delete( :some_setting )
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+
+  ###############
+  #  delete_if  #
+  ###############
+
+  it 'can delete elements with a block' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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.delete_if do |key, value|
+      key == :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+
+  #############
+  #  reject!  #
+  #############
+
+  it 'can delete elements with a block' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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.reject! do |key, value|
+      key == :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+  
+  #############
+  #  keep_if  #
+  #############
+
+  it 'can keep elements with a block' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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.keep_if do |key, value|
+      key != :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+
+  #############
+  #  select!  #
+  #############
+
+  it 'can keep elements with a block' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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.select! do |key, value|
+      key != :some_setting
+    end
+    cascading_composite_hash.should == { :other_setting => :some_value }
+
+  end
+  
+  ############
+  #  merge!  #
+  #  update  #
+  ############
+  
+  it 'can merge from another hash' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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 }
+
+  end
+  
+  #############
+  #  replace  #
+  #############
+  
+  it 'can replace existing elements with others' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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 }
+
+  end
+
+  ###########
+  #  shift  #
+  ###########
+  
+  it 'can shift the first element' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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 }
+
+  end
+
+  ###########
+  #  clear  #
+  ###########
+  
+  it 'can clear, causing present elements to be excluded' do
+
+    cascading_composite_hash = ::Hash::Hooked.new
+
+    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 }
+
+  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 ::Hash::Hooked::SubMockPreSet < ::Hash::Hooked
+      
+      def pre_set_hook( key, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    cascading_composite_hash = ::Hash::Hooked::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 ::Hash::Hooked::SubMockPostSet < ::Hash::Hooked
+      
+      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 = ::Hash::Hooked::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 ::Hash::Hooked::SubMockPreGet < ::Hash::Hooked
+      
+      def pre_get_hook( key )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_hash = ::Hash::Hooked::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 ::Hash::Hooked::SubMockPostGet < ::Hash::Hooked
+      
+      def post_get_hook( key, object )
+        self[ :some_other_key ] = :some_other_value
+        return object
+      end
+      
+    end
+    
+    cascading_composite_hash = ::Hash::Hooked::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 ::Hash::Hooked::SubMockPreDelete < ::Hash::Hooked
+      
+      def pre_delete_hook( key )
+        return false
+      end
+      
+    end
+    
+    cascading_composite_hash = ::Hash::Hooked::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 ::Hash::Hooked::SubMockPostDelete < ::Hash::Hooked
+      
+      def post_delete_hook( key, object )
+        unless key == :some_other_key
+          delete( :some_other_key )
+        end
+      end
+      
+    end
+    
+    cascading_composite_hash = ::Hash::Hooked::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
+
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: hash-hooked
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Asher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: identifies_as
+  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: A subclass of Hash that offers event hooks for pre-set/pre-delete, set/delete.
+  ::HookedHash offers implicit reference to a configuration instance.
+email: asher@ridiculouspower.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hash/hooked/hash_interface.rb
+- lib/hash/hooked.rb
+- lib/hash/namespaces.rb
+- lib/hash/requires.rb
+- lib/hash-hooked.rb
+- lib/hooked/hash.rb
+- lib/hooked_hash/hash_interface.rb
+- lib/hooked_hash.rb
+- spec/hash/hooked_spec.rb
+- README.md
+- CHANGELOG.rdoc
+homepage: http://rubygems.org/gems/hash-hooked
+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-hooked
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides ::Hash::Hooked and ::HookedHash.
+test_files: []
+has_rdoc: