right_support 2.8.37 → 2.8.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 695bd84c95a2c978873deaf2b85ac85e9f72a10c
-  data.tar.gz: 855562b8a7497925dfdc17951e852e8263724227
+  metadata.gz: e0cb72f5d96896f6a249867296e5a6ee14021caa
+  data.tar.gz: 930f29d6b579d374ddadf6636c3687aeb12f394e
 SHA512:
-  metadata.gz: acfa03c38cb1e5dd0edba374ffe3a3000b411415743d0a60a6f60866cd3515bd8445df5145995ec709117b4f8f083785298530209b2e5ddde7ec360cc5b2b2eb
-  data.tar.gz: 304ca6549fcbcdb76a4a7a53a71f18d90ddbe12d6600523a47523fde823bfb6c2d0a5474c74953ee84d2c0e9488f12fc46abba133b61484ad9e150fff04e68c6
+  metadata.gz: 9bc745e71199150c1c3097efe6ba4ec77549e6c5d34ae7fdd899710f5122adde38e77b01a56f4e826e8e49a297eed2534fc1be78cf72ffb924e79beb6335b064
+  data.tar.gz: e823929462c375b3bb12f51c91fd39780de10eec2194232d32c5ea649166709f523bc2cad31f4030d588a9f95eebd38ba84d969c6f4aa9a195f223d188fbac28

data/VERSION

@@ -1 +1 @@
-2.8.37
+2.8.38

data/lib/right_support/data/hash_tools.rb

@@ -138,6 +138,13 @@ module RightSupport::Data
     # === Return
     # @return [Hash] deep cloned hash
     def self.deep_clone(original, &leaf_callback)
+      # note that .clone preserves .frozen? state so this legacy method will
+      # attempt to modify a still-frozen hash/array and raise an exception.
+      # see deep_clone2 which clones by creating a new instance of the object
+      # class and produce an unfrozen clone of the hash/array.
+      # as a side note, calling .dup does not preserve .frozen? state but is has
+      # its own side effects, which is why we have more specific logic like
+      # leaf_callback and .duplicable?
       result = original.clone
       result.each do |k, v|
         if hashable?(v)
@@ -196,8 +203,36 @@ module RightSupport::Data
       end
     end
 
-    # Deeply mashes and duplicates (clones) a hashable using deep_clone2 after
-    # checking that extlib is available.
+    # Deeply freezes the given hash/array and all of their non-hierarchical
+    # elements in a hierarchichal data structure such that an attempt to modify
+    # any part of it will raise an exception.
+    #
+    # === Parameters
+    # @param [Object] any kind of object
+    #
+    # === Return
+    # @return [Object] deeply frozen object
+    def self.deep_freeze!(any)
+      if hashable?(any)
+        # clone to a new instance of hashable class with deep cloning.
+        any.each do |k, v|
+          # notes:
+          #  a) either key or value of a hash could be a complex type.
+          #  b) Hash freezes simple type keys upon insertion out of necessity to
+          #     avoid spontaneous rehashing. Hash will not freeze complex types
+          #     used as keys so we will (re)freeze all keys for safety.
+          deep_freeze!(k)
+          deep_freeze!(v)
+        end
+      elsif any.kind_of?(::Array)
+        # traverse arrays
+        any.each { |e| deep_freeze!(e) }
+      end
+      any.freeze
+    end
+
+    # Deeply mashes and duplicates (clones) a hashable using deep_clone2 and our
+    # own version of Mash.
     #
     # The advantage of Mash over Hash is, of course, to be able to use either
     # a String or Symbol as a key for the same value.
@@ -221,7 +256,39 @@ module RightSupport::Data
       deep_clone2(any, options, &leaf_callback)
     end
 
-    # Performs a deep merge (but not a deep clone) of one hash into another.
+    # Performs a deep clone and merge of one hash into another, similar in
+    # behavior to Hash#merge
+    #
+    # === Parameters
+    # @param [Hash] target hash containing original data to be replaced in the
+    #  resulting hash
+    # @param [Hash] source hash containing data to recursively assign or nil or
+    #  empty
+    #
+    # === Return
+    # @return [Hash] to_hash result of merge
+    def self.deep_merge(target, source)
+      # merge or replace any values that appear in source.
+      result = target.class.new
+      (source || {}).each do |k, v|
+        if hashable?(target[k]) && hashable?(v)
+          result[k] = deep_merge(target[k], v)
+        else
+          result[k] = v
+        end
+      end
+
+      # deep clone any target-only value.
+      target.each do |k, v|
+        unless result.has_key?(k)
+          result[k] = deep_clone2(v)
+        end
+      end
+      result
+    end
+
+    # Performs a deep merge (but not a deep clone) of one hash into another,
+    # similar in behavior to Hash#merge!
     #
     # === Parameters
     # @param [Hash] target hash to contain original and merged data

data/right_support.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: right_support 2.8.37 ruby lib
+# stub: right_support 2.8.38 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "right_support"
-  s.version = "2.8.37"
+  s.version = "2.8.38"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Tony Spataro", "Sergey Sergyenko", "Ryan Williamson", "Lee Kirchhoff", "Alexey Karpik", "Scott Messier"]
-  s.date = "2014-11-26"
+  s.date = "2014-12-05"
   s.description = "A toolkit of useful, reusable foundation code created by RightScale."
   s.email = "support@rightscale.com"
   s.extra_rdoc_files = [
@@ -148,7 +148,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "https://github.com/rightscale/right_support"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.0"
+  s.rubygems_version = "2.2.2"
   s.summary = "Reusable foundation code."
 
   if s.respond_to? :specification_version then

data/spec/data/hash_tools_spec.rb

@@ -257,6 +257,72 @@ describe RightSupport::Data::HashTools do
     end
   end
 
+  context '#deep_freeze!' do
+    it "should deep freeze hashes and arrays" do
+      original = {
+        'a' => ' s ',
+        'b' => {
+          'h' => ' s2 ',
+          'a' => [ 1, { :nested => ' s3 ' } ]
+        }
+      }
+      original.each do |k, v|
+        # note that Hash freezes keys upon insertion out of necessity to avoid
+        # spontaneous rehashing.
+        k.should be_frozen
+        v.should_not be_frozen
+      end
+      original['b']['a'][1][:nested].should_not be_frozen
+      subject.deep_freeze!(original)
+      original.each do |k, v|
+        k.should be_frozen
+        v.should be_frozen
+      end
+      original['b']['a'][1][:nested].should be_frozen
+    end
+  end
+
+  context '#deep_merge' do
+    {
+      :identical => {
+        :left     => { :one => 1 },
+        :right    => { :one => 1 },
+        :expected => { :one => 1 } },
+      :disjoint => {
+        :left     => { :one => 1 },
+        :right    => { :two => 1 },
+        :expected => { :one => 1, :two => 1 } },
+      :value_diff => {
+        :left     => { :one => 1 },
+        :right    => { :one => 2 },
+        :expected => { :one => 2 } },
+      :recursive_disjoint => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1 }, :two => 3 },
+        :expected => { :one => { :a => 1, :b => 2 }, :two => 3 } },
+      :recursive_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2 }, :two => 3 },
+        :right    => { :one => { :a => 1, :b => 3 }, :two => 3 },
+        :expected => { :one => { :a => 1, :b => 3 }, :two => 3 } },
+      :recursive_disjoint_and_value_diff => {
+        :left     => { :one => { :a => 1, :b => 2, :c => 3 }, :two => 3, :three => 4 },
+        :right    => { :one => { :a => 1, :b => 3, :d => 4 }, :two => 5, :four => 6 },
+        :expected => { :one => { :a => 1, :b => 3, :c => 3 , :d => 4 }, :two => 5, :three => 4, :four => 6 } }
+    }.each do |kind, data|
+      it "should deep merge #{kind} hashes" do
+        left_same_as_expected = data[:left] == data[:expected]
+        actual = subject.deep_merge(data[:left], data[:right])
+        actual.should == data[:expected]
+
+        # original should be unmodified.
+        actual.object_id.should_not == data[:left].object_id
+        unless left_same_as_expected
+          data[:left].should_not == data[:expected]
+        end
+      end
+    end
+  end
+
   context '#deep_merge!' do
     {
       :identical => {
@@ -287,6 +353,7 @@ describe RightSupport::Data::HashTools do
       it "should deep merge #{kind} hashes" do
         actual = subject.deep_merge!(data[:left], data[:right])
         actual.should == data[:expected]
+        actual.object_id.should == data[:left].object_id  # original returned modified
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: right_support
 version: !ruby/object:Gem::Version
-  version: 2.8.37
+  version: 2.8.38
 platform: ruby
 authors:
 - Tony Spataro
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-26 00:00:00.000000000 Z
+date: 2014-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -239,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Reusable foundation code.