hash-deep-merge 0.1.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--drb

data/Gemfile

@@ -0,0 +1,14 @@
+source 'http://rubygems.org'
+
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'rspec'    #, "~> 2.3.0"
+  gem 'bundler'  #, "~> 1.0.0"
+  gem 'jeweler'  #, "~> 1.6.0"
+  gem 'rcov'     #, ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.0)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.0)
+    rcov (0.9.9)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.2)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler
+  rcov
+  rspec

data/LICENSE.txt

@@ -0,0 +1,7 @@
+No Copyright
+
+The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
+
+You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
+
+http://creativecommons.org/publicdomain/zero/1.0/

data/README.rdoc

@@ -0,0 +1,59 @@
+= hash-deep-merge
+
+== Introduction
+This little gem add a method to the Hash class, allowing to merge hashes containing other hashes. (This is known as "deep merge" or "recursive merge".)
+
+You (may) already know the standard hash merge :
+   h1 = { 'a' => 1, 'b' => 2,  'c' => 3}
+   h2 = {           'b' => 33,           'd' => 42 }
+   h1.merge(h2)
+     -> { 'a' => 1, 'b' => 33, 'c' => 3, 'd' => 42 }
+ 
+But now, what if the hash contains other hashes ?
+   h1 = { :option1 => true, :option2 => false, :option_group1 => { :sub_option1 => 23, :sub_option2 => "hey !" } }
+   h2 = { :option2 => true,    :option3 => 27, :option_group1 => { :sub_option1 => 18 } }
+traditional merge doesn't handle that... Here come deep_merge !
+   h1.deep_merge(h2)
+     -> { :option1 => true, :option2 => true,  :option_group1 => { :sub_option1 => 18, :sub_option2 => "hey !" }, :option3 => 27 }
+
+Of course, a deep_merge! (note the !) is available, like merge!
+
+This should be included in Ruby, but there are some discussions about extra features that prevent it from going forward, cf. http://www.misuse.org/science/2008/05/19/deep_merge-ruby-recursive-merging-for-hashes/
+
+The version I give you is the simplest one, doing what you need 99% of the time.
+
+There are plenty of code snippets for deep merge :
+* http://snippets.dzone.com/posts/show/4706
+* http://rexchung.com/2007/02/01/hash-recursive-merge-in-ruby/
+* https://gist.github.com/6391
+
+But they were not packaged it into a gem. It's done now for your convenience (and mine).
+
+NOTE : I since found a gem containing a more powerful deep merge, able to not only merge hashes but arrays and strings as well with many options. You may want to look at it :
+https://github.com/peritor/deep_merge
+
+== Installation
+
+If you use bundler, just throw that in your gemfile :
+  gem 'hash-deep-merge'
+
+You may also install the gem manually :
+  gem install hash-deep-merge
+
+Isn't it so easy ?
+
+== Contributing to hash-deep-merge
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Offirmo. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "hash-deep-merge"
+  gem.homepage = "http://github.com/Offirmo/hash-deep-merge"
+  gem.license = "CC0 1.0"
+  gem.summary = %Q{add the deep merge feature to class Hash.}
+  gem.description = <<-EOF
+This gem add the "deep merge" feature to class Hash.
+It means that if you want to merge hashes that contains other hashes (and so on...), those sub-hashes will be merged as well.
+This is very handy, for example for merging data taken from YAML files.
+EOF
+  gem.email = "offirmo.net@gmail.com"
+  gem.authors = ["Offirmo"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hash-deep-merge #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/hash-deep-merge.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hash-deep-merge}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Offirmo"]
+  s.date = %q{2011-05-23}
+  s.description = %q{This gem add the "deep merge" feature to class Hash.
+It means that if you want to merge hashes that contains other hashes (and so on...), those sub-hashes will be merged as well.
+This is very handy, for example for merging data taken from YAML files.
+}
+  s.email = %q{offirmo.net@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "hash-deep-merge.gemspec",
+    "lib/hash_deep_merge.rb",
+    "spec/hash-deep-merge_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/Offirmo/hash-deep-merge}
+  s.licenses = ["CC0 1.0"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{add the deep merge feature to class Hash.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/hash_deep_merge.rb

@@ -0,0 +1,47 @@
+class Hash
+	
+	def deep_merge!(specialized_hash)
+		return internal_deep_merge!(self, specialized_hash)
+	end
+	
+	
+	def deep_merge(specialized_hash)
+		return internal_deep_merge!(Hash.new.replace(self), specialized_hash)
+	end
+	
+	
+	protected
+		
+		# better, recursive, preserving method
+		# OK OK this is not the most efficient algorithm,
+		# but at last it's *perfectly clear and understandable*
+		# so fork and improve if you need 5% more speed, ok ?
+		def internal_deep_merge!(source_hash, specialized_hash)
+			
+			#puts "starting deep merge..."
+			
+			specialized_hash.each_pair do |rkey, rval|
+				#puts "   potential replacing entry : " + rkey.inspect
+				
+				if source_hash.has_key?(rkey) then
+					#puts "   found potentially conflicting entry for #{rkey.inspect} : #{rval.inspect}, will merge :"
+					if rval.is_a?(Hash) and source_hash[rkey].is_a?(Hash) then
+						#puts "      recursing..."
+						internal_deep_merge!(source_hash[rkey], rval)
+					elsif rval == source_hash[rkey] then
+						#puts "      same value, skipping."
+					else
+						#puts "      replacing."
+						source_hash[rkey] = rval
+					end
+				else
+					#puts "   found new entry #{rkey.inspect}, adding it..."
+					source_hash[rkey] = rval
+				end
+			end
+			
+			#puts "deep merge done."
+			
+			return source_hash
+		end
+end

data/spec/hash-deep-merge_spec.rb

@@ -0,0 +1,458 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "HashDeepMerge" do
+	
+	
+	######################################################################
+	describe "handling of ordinary hashes" do
+		
+		before(:each) do
+			# When hashes don't contain other hashes, deep_merge works the same as merge.
+			@hash1 = { 3 => 2,    :test => 1, 'toto' => 'titi', :foo => :bar }
+			@hash2 = { 3 => '42', :test => 2, 'toto' => 'titi',               :fooz => :barz }
+			
+			# Expected results, computed manually.
+			@expected_result_1to2 = { 3 => '42', :test => 2, 'toto' => 'titi', :foo  => :bar,  :fooz => :barz }
+			@expected_result_2to1 = { 3 => 2,    :test => 1, 'toto' => 'titi', :fooz => :barz, :foo  => :bar }
+			
+			# We store copie to check for modifications,
+			# because some functions are expected to change the values and some not.
+			@hash1_copy = Hash.new.replace(@hash1)
+			@hash2_copy = Hash.new.replace(@hash2)
+			
+			# This is not really a test, it's just to remember prerequisites for following tests.
+			# (If we want to test no modifications, we just have to merge a hash with itself)
+			@expected_result_1to2.should_not == @hash1
+			@expected_result_1to2.should_not == @hash2
+			@expected_result_2to1.should_not == @hash1
+			@expected_result_2to1.should_not == @hash2
+		end
+		
+		######################## MERGE ########################
+		describe "merge function" do
+			it "should behave the same (exact identity case)" do
+				
+				expected_result = @hash1_copy
+				
+				# first we do it with the ordinary "merge" function, to check.
+				result = @hash1.merge(@hash1) # merge to itself
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				
+				# Now we do it with deep_merge
+				result = @hash1.deep_merge(@hash1)
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should behave the same (shuffled identity case)" do
+				# really needed ?
+				pending
+			end
+			
+			it "should behave the same (different case)" do
+				expected_result = @expected_result_1to2
+				
+				# first we do it with the ordinary "merge" function, to check.
+				result = @hash1.merge(@hash2)
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				
+				# Now we do it with deep_merge
+				result = @hash1.deep_merge(@hash2)
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should behave the same (different case reversed)" do
+				expected_result = @expected_result_2to1
+				
+				# first we do it with the ordinary "merge" function, to check.
+				result = @hash2.merge(@hash1)
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				
+				# Now we do it with deep_merge
+				result = @hash2.deep_merge(@hash1)
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+		end # merge
+		
+		######################## MERGE!!! ########################
+		describe "merge!" do
+			it "should behave the same (exact identity case)" do
+				
+				expected_result = @hash1_copy
+				
+				# first we do it with the ordinary "merge" function, to check.
+				@hash1.merge!(@hash1) # merge to itself
+				result = @hash1
+				@hash1.should == @hash1_copy # should be equal
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				
+				# restore @hash1
+				@hash1 = Hash.new.replace(@hash1_copy)
+				@hash1.should == @hash1_copy # should have been restored
+				
+				# Now we do it with deep_merge
+				@hash1.deep_merge!(@hash1)
+				result = @hash1
+				@hash1.should == @hash1_copy # should be equal
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should behave the same (shuffled identity case)" do
+				# really needed ?
+				pending
+			end
+			
+			it "should behave the same (different case)" do
+				expected_result = @expected_result_1to2
+				
+				# first we do it with the ordinary "merge!" function, to check.
+				@hash1.merge!(@hash2) # XXX with ! XXX
+				result = @hash1
+				@hash1.should_not == @hash1_copy # *should* have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				
+				# restore @hash1
+				@hash1 = Hash.new.replace(@hash1_copy)
+				@hash1.should == @hash1_copy # should have been restored
+				
+				# Now we do it with deep_merge
+				result = @hash1.deep_merge!(@hash2) # XXX with ! XXX
+				@hash1.should_not == @hash1_copy # *should* have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should behave the same (different case reversed)" do
+				expected_result = @expected_result_2to1
+				
+				# first we do it with the ordinary "merge!" function, to check.
+				@hash2.merge!(@hash1)
+				result = @hash2
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should_not == @hash2_copy # *should* have been modified
+				result.should == expected_result
+				
+				# restore @hash2
+				@hash2 = Hash.new.replace(@hash2_copy)
+				@hash2.should == @hash2_copy # should not have been modified
+				
+				# Now we do it with deep_merge
+				@hash2.deep_merge!(@hash1)
+				result = @hash2
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should_not == @hash2_copy # *should* have been modified
+				result.should == expected_result
+			end
+		end # merge!
+	end # handling of ordinary hashes
+	
+	
+	
+	######################################################################
+	describe "handling of hashes containing hashes" do
+		
+		before(:each) do
+			# same as before, but with sub hashes
+			@hash1 = { 3 => 2,    :test => 1, 'toto' => 'titi', :foo => :bar,
+			           'sub hash 1' => {
+			                   3 => 2,    :test => 1, 'toto' => 'titi', :foo => :bar },
+			           'sub hash 2' => {
+			                   'hello' => 'world' },
+			          }
+			@hash2 = { 3 => '42', :test => 2, 'toto' => 'titi',               :fooz => :barz,
+			           'sub hash 1' => {
+			                   3 => '42', :test => 2, 'toto' => 'titi',               :fooz => :barz },
+			           'sub hash 3' => {
+			                   'hello' => 'world' },
+			          }
+			
+			# Expected results, computed manually.
+			@expected_result_1to2 = { 3            => '42',
+			                          :test        => 2,
+			                          'toto'       => 'titi',
+			                          :foo         => :bar,
+			                          'sub hash 1' => {
+			                                     3 => '42', :test => 2, 'toto' => 'titi', :foo => :bar, :fooz => :barz},
+			                          'sub hash 2' => {
+			                                     'hello' => 'world' },
+			                          'sub hash 3' => {
+			                                     'hello' => 'world' },
+			                          :fooz        => :barz,
+			                         }
+			@expected_result_2to1 = { 3            => 2,
+			                          :test        => 1,
+			                          'toto'       => 'titi',
+			                          :fooz        => :barz,
+			                          'sub hash 1' => {
+			                                     3 => 2, :test => 1, 'toto' => 'titi', :fooz => :barz, :foo => :bar},
+			                          'sub hash 3' => {
+			                                     'hello' => 'world' },
+			                          'sub hash 2' => {
+			                                     'hello' => 'world' },
+			                          :foo         => :bar,
+			                         }
+			
+			# We store copie to check for modifications,
+			# because some functions are expected to change the values and some not.
+			@hash1_copy = Hash.new.replace(@hash1)
+			@hash2_copy = Hash.new.replace(@hash2)
+			
+			# This is not really a test, it's just to remember prerequisites for following tests.
+			# (If we want to test no modifications, we just have to merge a hash with itself)
+			@expected_result_1to2.should_not == @hash1
+			@expected_result_1to2.should_not == @hash2
+			@expected_result_2to1.should_not == @hash1
+			@expected_result_2to1.should_not == @hash2
+		end
+		
+		######################## MERGE ########################
+		describe "merge" do
+			
+			it "should work (exact identity case)" do
+				
+				expected_result = @hash1_copy
+				result = @hash1.deep_merge(@hash1)
+				
+				@hash1.should == @hash1_copy # should be equal
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should work (shuffled identity case)" do
+				# really needed ?
+				pending
+			end
+			
+			it "should work (different case)" do
+			
+				expected_result = @expected_result_1to2
+				result = @hash1.deep_merge(@hash2)
+				
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				result['sub hash 1'].should have(expected_result['sub hash 1'].length).entries
+				result['sub hash 1'].should ==   expected_result['sub hash 1']
+				result['sub hash 2'].should have(expected_result['sub hash 2'].length).entries
+				result['sub hash 2'].should ==   expected_result['sub hash 2']
+				result['sub hash 3'].should have(expected_result['sub hash 3'].length).entries
+				result['sub hash 3'].should ==   expected_result['sub hash 3']
+			end
+			
+			it "should work (different case reversed)" do
+			
+				expected_result = @expected_result_2to1
+				result = @hash2.deep_merge(@hash1)
+				
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				result['sub hash 1'].should have(expected_result['sub hash 1'].length).entries
+				result['sub hash 1'].should ==   expected_result['sub hash 1']
+				result['sub hash 2'].should have(expected_result['sub hash 2'].length).entries
+				result['sub hash 2'].should ==   expected_result['sub hash 2']
+				result['sub hash 3'].should have(expected_result['sub hash 3'].length).entries
+				result['sub hash 3'].should ==   expected_result['sub hash 3']
+			end
+			
+		end # merge
+		
+		######################## MERGE!!! ########################
+		describe "merge!" do
+			
+			it "should work (exact identity case)" do
+				
+				expected_result = @hash1_copy
+				@hash1.deep_merge!(@hash1)
+				result = @hash1
+				
+				@hash1.should == @hash1_copy # should be equal
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should work (shuffled identity case)" do
+				# really needed ?
+				pending
+			end
+			
+			it "should work (different case)" do
+			
+				expected_result = @expected_result_1to2
+				@hash1.deep_merge!(@hash2)
+				result = @hash1
+				
+				@hash1.should_not == @hash1_copy # *should* have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				result['sub hash 1'].should have(expected_result['sub hash 1'].length).entries
+				result['sub hash 1'].should ==   expected_result['sub hash 1']
+				result['sub hash 2'].should have(expected_result['sub hash 2'].length).entries
+				result['sub hash 2'].should ==   expected_result['sub hash 2']
+				result['sub hash 3'].should have(expected_result['sub hash 3'].length).entries
+				result['sub hash 3'].should ==   expected_result['sub hash 3']
+			end
+			
+			it "should work (different case reversed)" do
+			
+				expected_result = @expected_result_2to1
+				@hash2.deep_merge!(@hash1)
+				result = @hash2
+				
+				@hash1.should == @hash1_copy # should not have been modified
+				@hash2.should_not == @hash2_copy # *should* have been modified
+				result.should == expected_result
+				result['sub hash 1'].should have(expected_result['sub hash 1'].length).entries
+				result['sub hash 1'].should ==   expected_result['sub hash 1']
+				result['sub hash 2'].should have(expected_result['sub hash 2'].length).entries
+				result['sub hash 2'].should ==   expected_result['sub hash 2']
+				result['sub hash 3'].should have(expected_result['sub hash 3'].length).entries
+				result['sub hash 3'].should ==   expected_result['sub hash 3']
+			end
+			
+		end # merge
+	end # hash with sub hashes
+	
+	######################################################################
+	describe "handling of hashes containing hashes containing hashes" do
+		before(:each) do
+			# same as before, but with sub sub hashes
+			# things start to get complicated, isn't it ?
+			@hash1 = {
+				3            => 2,
+				:test        => 1,
+				'toto'       => 'titi',
+				:foo         => :bar,
+				'sub hash 1' => {
+					3                => 2,
+					:test            => 1,
+					'toto'           => 'titi',
+					:foo             => :bar,
+					'sub sub hash 1' => {
+						3      => '42',
+						:test  => 2,
+						'toto' => 'titi',
+						:fooz  => :barz
+					},
+				},
+				'sub hash 2' => {
+					'hello' => 'world'
+				},
+			}
+			@hash2 = {
+				3            => '42',
+				:test        => 2,
+				'toto'       => 'titi',
+				:fooz        => :barz,
+				'sub hash 1' => {
+					3                => '42',
+					:test            => 2,
+					'toto'           => 'titi',
+					:fooz            => :barz,
+					'sub sub hash 1' => {
+						3      => 2,
+						:test  => 1,
+						'toto' => 'titi',
+						:foo   => :bar
+					},
+				},
+				'sub hash 2' => {
+					'hello' => 'worldy'
+				},
+			}
+			
+			# Expected results, computed manually.
+			@expected_result_1to2 = {
+				3            => '42',
+				:test        => 2,
+				'toto'       => 'titi',
+				:foo         => :bar,
+				'sub hash 1' => {
+					3                => '42',
+					:test            => 2,
+					'toto'           => 'titi',
+					:foo             => :bar,
+					'sub sub hash 1' => {
+						3      => 2,
+						:test  => 1,
+						'toto' => 'titi',
+						:fooz  => :barz,
+						:foo   => :bar
+					},
+					:fooz => :barz
+				},
+				'sub hash 2' => {
+					'hello' => 'worldy'
+				},
+				:fooz        => :barz,
+			}
+			
+			# Gaaah ! My head burns !
+			
+			# We store copie to check for modifications,
+			# because some functions are expected to change the values and some not.
+			@hash1_copy = Hash.new.replace(@hash1)
+			@hash2_copy = Hash.new.replace(@hash2)
+			
+			# This is not really a test, it's just to remember prerequisites for following tests.
+			# (If we want to test no modifications, we just have to merge a hash with itself)
+			@expected_result_1to2.should_not == @hash1
+			@expected_result_1to2.should_not == @hash2
+		end
+		
+		######################## MERGE ########################
+		describe "merge" do
+			
+			it "should work (exact identity case)" do
+			
+				expected_result = @hash1_copy
+				@hash1.deep_merge!(@hash1)
+				result = @hash1
+				
+				@hash1.should == @hash1_copy # should be equal
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+			end
+			
+			it "should work (shuffled identity case)" do
+				# really needed ?
+				pending
+			end
+			
+			it "should work (different case)" do
+			
+				expected_result = @expected_result_1to2
+				@hash1.deep_merge!(@hash2)
+				result = @hash1
+				
+				@hash1.should_not == @hash1_copy # *should* have been modified
+				@hash2.should == @hash2_copy # should not have been modified
+				result.should == expected_result
+				result['sub hash 1'].should ==   expected_result['sub hash 1']
+				result['sub hash 1']['sub sub hash 1'].should ==   expected_result['sub hash 1']['sub sub hash 1']
+				result['sub hash 2'].should ==   expected_result['sub hash 2']
+			end
+		end # merge
+	end
+	
+	######################################################################
+	describe "handling of hashes containing hashes containing hashes containing hashes" do
+		# herm... maybe we'll stop here ;-)
+		# I'm mad enough already...
+	end
+	
+end # describe "HashDeepMerge"

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'hash_deep_merge'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+# I add some display to clearly mark the beginning of the tests
+puts "*\n"*12
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: hash-deep-merge
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Offirmo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-05-23 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &78820430 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78820430
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &78820190 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78820190
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &78819910 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78819910
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &78819670 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78819670
+description: ! 'This gem add the "deep merge" feature to class Hash.
+
+  It means that if you want to merge hashes that contains other hashes (and so on...),
+  those sub-hashes will be merged as well.
+
+  This is very handy, for example for merging data taken from YAML files.
+
+'
+email: offirmo.net@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- hash-deep-merge.gemspec
+- lib/hash_deep_merge.rb
+- spec/hash-deep-merge_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Offirmo/hash-deep-merge
+licenses:
+- CC0 1.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 814986959
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: add the deep merge feature to class Hash.
+test_files: []