Deep Merge Initializer Extension

CHANGELOG.md

@@ -13,7 +13,7 @@ scheme are considered to be bugs.
 ### Added
 
 * [#381](https://github.com/intridea/hashie/pull/381): Add a logging layer that lets us report potential issues to our users. As the first logged issue, report when a `Hashie::Mash` is attempting to overwrite a built-in method, since that is one of our number one questions - [@michaelherold](https://github.com/michaelherold).
-* Your contribution here.
+* [#382](https://github.com/intridea/hashie/pull/382): `DeepMergeInitializer` extension - [@sazor](https://github.com/sazor).
 
 ### Changed
 

README.md

@@ -206,6 +206,10 @@ Hashie.stringify_keys hash # => Returns a copy of hash with keys stringified.
 
 The MergeInitializer extension simply makes it possible to initialize a Hash subclass with another Hash, giving you a quick short-hand.
 
+### DeepMergeInitializer
+
+The DeepMergeInitializer acts the same as MergeInitializer but also cast all nested hashes to extendable class.
+
 ### MethodAccess
 
 The MethodAccess extension allows you to quickly build method-based reading, writing, and querying into your Hash descendant. It can also be included as individual modules, i.e. `Hashie::Extensions::MethodReader`, `Hashie::Extensions::MethodWriter` and `Hashie::Extensions::MethodQuery`.

lib/hashie.rb

@@ -47,6 +47,7 @@ module Extensions
     autoload :StrictKeyAccess,   'hashie/extensions/strict_key_access'
     autoload :RubyVersion,       'hashie/extensions/ruby_version'
     autoload :RubyVersionCheck,  'hashie/extensions/ruby_version_check'
+    autoload :DeepMergeInitializer, 'hashie/extensions/deep_merge_initializer'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'

lib/hashie/extensions/deep_merge_initializer.rb

@@ -0,0 +1,37 @@
+module Hashie
+  module Extensions
+    # The DeepMergeInitializer is a super-simple mixin that allows
+    # you to initialize a subclass of Hash with another Hash
+    # to give you faster startup time for Hash subclasses.
+    # It's almost the same as MergeInitializer but nested hashes
+    # are same type as main object. Note
+    # that you can still provide a default value as a second
+    # argument to the initializer.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::DeepMergeInitializer
+    #   end
+    #
+    #   h = MyHash.new(abc: 'def', hashy: { abc: 'def' })
+    #   h[:abc] # => 'def'
+    #   h[:hashy].class # => MyHash
+    #
+    module DeepMergeInitializer
+      def self.included(base)
+        base.class_eval do
+          def initialize(hash = {}, default = nil, &block)
+            default ? super(default) : super(&block)
+            hash.each do |key, value|
+              self[key] = if value.is_a?(::Hash)
+                            self.class.new(value, default, &block)
+                          else
+                            value
+                          end
+            end
+          end
+        end
+      end
+    end
+  end
+end

spec/hashie/extensions/deep_merge_initializer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::DeepMergeInitializer do
+  class DeepInitializerHash < Hash
+    include Hashie::Extensions::DeepMergeInitializer
+  end
+
+  subject { DeepInitializerHash }
+
+  it 'creates nested hash with the same type as parent hash' do
+    s = subject.new({ a: :b, hash: { c: :d } })[:hash]
+    pp s.class
+    expect(subject.new({ a: :b, hash: { c: :d } })[:hash]).to be_a(subject)
+  end
+end