more_core_extensions 1.0.1 → 1.0.2

data/lib/more_core_extensions/core_ext/hash/nested.rb

@@ -36,7 +36,10 @@ module MoreCoreExtensions
         self[key] = value
       else
         child = self[key]
-        child = self[key] = {} unless child.kind_of?(Hash)
+        unless child.kind_of?(Hash)
+          self[key] = self.class.new
+          child = self[key]
+        end
         child.store_path(args[1..-1], value)
       end
     end

data/lib/more_core_extensions/version.rb

@@ -1,3 +1,3 @@
 module MoreCoreExtensions
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/core_ext/hash/nested_spec.rb

@@ -1,50 +1,63 @@
 require_relative "../../spec_helper"
 
-describe Hash do
-  let(:hash) do
-    {
-      "a" => 1,
-      "b" => {},
-      "c" => {"c1" => 2},
-      "d" => {"d1" => {"d2" => {"d3" => 3}}},
-      "e" => Hash.new(4),
-      "f" => Hash.new { |h, k| Hash.new }
-    }
+shared_examples_for "core_ext/hash/nested will not modify arguments" do |meth|
+  it "will not modify arguments" do
+    args = (meth == :store_path ? [1] : [])
+
+    key  = ["d", "d1", "d2", "d3"]
+    key2 = key.dup
+    hash.send(meth, key2, *args)
+    key2.should == key
+
+    key  = ["e", "e1", "e2"]
+    key2 = key.dup
+    hash.send(meth, key2, *args)
+    key2.should == key
   end
+end
 
-  it '#fetch_path' do
-    hash.fetch_path("a").should == 1
-    hash.fetch_path("b").should == {}
-    hash.fetch_path("b", "b1").should be_nil
-    hash.fetch_path("b", "b1", "b2").should be_nil
-    hash.fetch_path("c").should == {"c1" => 2}
-    hash.fetch_path("c", "c1").should == 2
-    hash.fetch_path("c", "c1", "c2").should be_nil
-    hash.fetch_path("d", "d1", "d2", "d3").should == 3
-    hash.fetch_path("d", "d1", "d2", "dx").should be_nil
-    hash.fetch_path("d", "d1", "d2", "d3", "d4").should be_nil
-    hash.fetch_path("e").should == {}
-    hash.fetch_path("e", "e1").should == 4
-    hash.fetch_path("e", "e1", "e2").should be_nil
-    hash.fetch_path("f").should == {}
-    hash.fetch_path("f", "f1").should == {}
-    hash.fetch_path("f", "f1", "f2").should be_nil
-
-    hash.fetch_path(nil).should be_nil
-    hash.fetch_path("d", nil, "d1").should be_nil
-    hash.fetch_path("e", nil).should == 4
-    hash.fetch_path("e", nil, "e1").should be_nil
-
-    lambda { hash.fetch_path }.should raise_error(ArgumentError)
+shared_examples_for "core_ext/hash/nested" do
+  context '#fetch_path' do
+    it "with various values" do
+      hash.fetch_path("a").should == 1
+      hash.fetch_path("b").should == {}
+      hash.fetch_path("b", "b1").should be_nil
+      hash.fetch_path("b", "b1", "b2").should be_nil
+      hash.fetch_path("c").should == {"c1" => 2}
+      hash.fetch_path("c", "c1").should == 2
+      hash.fetch_path("c", "c1", "c2").should be_nil
+      hash.fetch_path("d", "d1", "d2", "d3").should == 3
+      hash.fetch_path("d", "d1", "d2", "dx").should be_nil
+      hash.fetch_path("d", "d1", "d2", "d3", "d4").should be_nil
+      hash.fetch_path("e").should == {}
+      hash.fetch_path("e", "e1").should == 4
+      hash.fetch_path("e", "e1", "e2").should be_nil
+      hash.fetch_path("f").should == {}
+      hash.fetch_path("f", "f1").should == {}
+      hash.fetch_path("f", "f1", "f2").should be_nil
+    end
+
+    it "with a nil value" do
+      hash.fetch_path(nil).should be_nil
+      hash.fetch_path("d", nil, "d1").should be_nil
+      hash.fetch_path("e", nil).should == 4
+      hash.fetch_path("e", nil, "e1").should be_nil
+    end
+
+    it "with invalid values" do
+      lambda { hash.fetch_path }.should raise_error(ArgumentError)
+    end
+
+    include_examples "core_ext/hash/nested will not modify arguments", :fetch_path
   end
 
   context "#store_path" do
     it "on an empty hash" do
-      h = {}
+      h = described_class.new
       h.store_path("a", 1)
       h.should == {"a" => 1}
 
-      h = {}
+      h = described_class.new
       h.store_path("b", "b1", 2)
       h.should == {"b" => {"b1" => 2}}
     end
@@ -64,62 +77,121 @@ describe Hash do
     end
 
     it "with an array of keys" do
-      h = {}
+      h = described_class.new
       h.store_path(["d", "d1", "d2", "d3"], 3)
       h.should == {"d" => {"d1" => {"d2" => {"d3" => 3}}}}
     end
 
     it "with a nil value" do
-      h = {}
+      h = described_class.new
       h.store_path("a", "b", nil)
       h.should == {"a" => {"b" => nil}}
     end
 
+    it "with an Array value" do
+      h = described_class.new
+      h.store_path("a", "b", ["c", "d"])
+      h.should == {"a" => {"b" => ["c", "d"]}}
+    end
+
+    it "with a Hash value" do
+      h = described_class.new
+      h.store_path("a", "b", {"c" => "d"})
+      h.should == {"a" => {"b" => {"c" => "d"}}}
+    end
+
     it "with invalid values" do
-      lambda { {}.store_path }.should raise_error(ArgumentError)
-      lambda { {}.store_path(nil) }.should raise_error(ArgumentError)
+      lambda { described_class.new.store_path }.should raise_error(ArgumentError)
+      lambda { described_class.new.store_path(1) }.should raise_error(ArgumentError)
     end
-  end
 
-  it '#has_key_path?' do
-    hash.has_key_path?("a").should be_true
-    hash.has_key_path?("b").should be_true
-    hash.has_key_path?("b", "b1").should be_false
-    hash.has_key_path?("b", "b1", "b2").should be_false
-    hash.has_key_path?("c").should be_true
-    hash.has_key_path?("c", "c1").should be_true
-    hash.has_key_path?("c", "c1", "c2").should be_false
-    hash.has_key_path?("d", "d1", "d2", "d3").should be_true
-    hash.has_key_path?("d", "d1", "d2", "dx").should be_false
-    hash.has_key_path?("d", "d1", "d2", "d3", "d4").should be_false
-    hash.has_key_path?("e").should be_true
-    hash.has_key_path?("e", "e1").should be_false
-    hash.has_key_path?("e", "e1", "e2").should be_false
-    hash.has_key_path?("f").should be_true
-    hash.has_key_path?("f", "f1").should be_false
-    hash.has_key_path?("f", "f1", "f2").should be_false
-
-    hash.has_key_path?(nil).should be_false
-    hash.has_key_path?("d", nil, "d1").should be_false
-    hash.has_key_path?("e", nil).should be_false
-    hash.has_key_path?("e", nil, "e1").should be_false
-
-    lambda { hash.has_key_path? }.should raise_error(ArgumentError)
+    include_examples "core_ext/hash/nested will not modify arguments", :store_path
   end
 
-  [:fetch_path, :has_key_path?, :store_path, :delete_path].each do |meth|
-    it "##{meth} will not modify arguments" do
-      args = (meth == :store_path ? [1] : [])
+  context '#has_key_path?' do
+    it "with various values" do
+      hash.has_key_path?("a").should be_true
+      hash.has_key_path?("b").should be_true
+      hash.has_key_path?("b", "b1").should be_false
+      hash.has_key_path?("b", "b1", "b2").should be_false
+      hash.has_key_path?("c").should be_true
+      hash.has_key_path?("c", "c1").should be_true
+      hash.has_key_path?("c", "c1", "c2").should be_false
+      hash.has_key_path?("d", "d1", "d2", "d3").should be_true
+      hash.has_key_path?("d", "d1", "d2", "dx").should be_false
+      hash.has_key_path?("d", "d1", "d2", "d3", "d4").should be_false
+      hash.has_key_path?("e").should be_true
+      hash.has_key_path?("e", "e1").should be_false
+      hash.has_key_path?("e", "e1", "e2").should be_false
+      hash.has_key_path?("f").should be_true
+      hash.has_key_path?("f", "f1").should be_false
+      hash.has_key_path?("f", "f1", "f2").should be_false
+    end
 
-      key  = ["d", "d1", "d2", "d3"]
-      key2 = key.dup
-      hash.send(meth, key2, *args)
-      key2.should == key
+    it "with a nil value" do
+      hash.has_key_path?(nil).should be_false
+      hash.has_key_path?("d", nil, "d1").should be_false
+      hash.has_key_path?("e", nil).should be_false
+      hash.has_key_path?("e", nil, "e1").should be_false
+    end
 
-      key  = ["e", "e1", "e2"]
-      key2 = key.dup
-      hash.send(meth, key2, *args)
-      key2.should == key
+    it "with invalid values" do
+      lambda { hash.has_key_path? }.should raise_error(ArgumentError)
     end
+
+    include_examples "core_ext/hash/nested will not modify arguments", :has_key_path?
+  end
+
+  context "#delete_path" do
+    include_examples "core_ext/hash/nested will not modify arguments", :delete_path
+  end
+end
+
+describe Hash do
+  let(:hash) do
+    {
+      "a" => 1,
+      "b" => {},
+      "c" => {"c1" => 2},
+      "d" => {"d1" => {"d2" => {"d3" => 3}}},
+      "e" => Hash.new(4),
+      "f" => Hash.new { |h, k| h[k] = Hash.new }
+    }
   end
+
+  include_examples "core_ext/hash/nested"
+end
+
+require 'active_support/core_ext/hash'
+describe HashWithIndifferentAccess do
+  let(:hash) do
+    described_class.new.merge(
+      "a" => 1,
+      "b" => {},
+      "c" => {"c1" => 2},
+      "d" => {"d1" => {"d2" => {"d3" => 3}}},
+      "e" => Hash.new(4),
+      "f" => described_class.new { |h, k| h[k] = described_class.new }
+    )
+
+    # NOTE: "f" has to be initialized in that way due to a bug in
+    #   HashWithIndifferentAccess and assigning a Hash with a default proc.
+    #
+    # 1.9.3 :001 > h1 = Hash.new
+    # 1.9.3 :002 > h1[:a] = Hash.new { |h, k| h[k] = Hash.new }
+    # 1.9.3 :003 > h1[:a].class
+    #  => Hash
+    # 1.9.3 :004 > h1[:a][:b].class
+    #  => Hash
+    #
+    # 1.9.3 :005 > require 'active_support/all'
+    # 1.9.3 :006 > h2 = HashWithIndifferentAccess.new
+    # 1.9.3 :007 > h2[:a] = Hash.new { |h, k| h[k] = Hash.new }
+    # 1.9.3 :008 > h2[:a].class
+    #  => ActiveSupport::HashWithIndifferentAccess
+    # 1.9.3 :009 > h2[:a][:b].class
+    #  => NilClass
+  end
+
+  include_examples "core_ext/hash/nested"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: more_core_extensions
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -146,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2540507193161773470
+      hash: 1712580559107520706
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -155,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2540507193161773470
+      hash: 1712580559107520706
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25