Create a deep dupe method and use it for facts

Author: kpaulisse

lib/octocatalog-diff/facts.rb

@@ -18,10 +18,9 @@ class Facts
     def initialize(options = {}, facts = nil)
       @node = options.fetch(:node, '')
       @timestamp = false
-      @options = OctocatalogDiff::Util::Util.safe_dup(options)
+      @options = options.dup
       if facts
-        @facts = {}
-        facts.each { |k, v| @facts[k] = OctocatalogDiff::Util::Util.safe_dup(v) }
+        @facts = OctocatalogDiff::Util::Util.deep_dup(facts)
       else
         case options[:backend]
         when :json
@@ -33,8 +32,7 @@ def initialize(options = {}, facts = nil)
         else
           raise ArgumentError, 'Invalid fact source backend'
         end
-        @facts = {}
-        @orig_facts.each { |k, v| @facts[k] = OctocatalogDiff::Util::Util.safe_dup(v) }
+        @facts = OctocatalogDiff::Util::Util.deep_dup(@orig_facts)
       end
     end
 

lib/octocatalog-diff/util/util.rb

@@ -20,11 +20,29 @@ def self.object_is_any_of?(object, classes)
       # Utility Method!
       # `.dup` can't be called on certain objects (Fixnum for example). This
       # method returns the original object if it can't be duplicated.
+      # @param object [?] Object to consider
+      # @return [?] Duplicated object if possible, otherwise the original object
       def self.safe_dup(object)
         object.dup
       rescue TypeError
         object
       end
+
+      # Utility Method!
+      # This does a "deep" duplication via recursion. Handles hashes and arrays.
+      # @param object [?] Object to consider
+      # @return [?] Duplicated object
+      def self.deep_dup(object)
+        if object.is_a?(Hash)
+          result = {}
+          object.each { |k, v| result[k] = deep_dup(v) }
+          result
+        elsif object.is_a?(Array)
+          object.map { |ele| deep_dup(ele) }
+        else
+          safe_dup(object)
+        end
+      end
     end
   end
 end

spec/octocatalog-diff/tests/util/util_spec.rb

@@ -58,4 +58,30 @@
       expect(object.object_id).not_to eq(result.object_id)
     end
   end
+
+  describe '#deep_dup' do
+    it 'should dupe a hash' do
+      hash1 = { 'foo' => 'bar' }
+      hash2 = { 'baz' => hash1 }
+      hash3 = { 'xxx' => hash2 }
+      result = described_class.deep_dup(hash3)
+      expect(result['xxx']).to eq(hash2)
+      expect(result['xxx'].object_id).not_to eq(hash2.object_id)
+    end
+
+    it 'should dupe an array' do
+      array1 = %w[foo bar baz]
+      array2 = ['foo', array1, 'baz']
+      array3 = ['foo', array2, 'baz']
+      result = described_class.deep_dup(array3)
+      expect(result[1]).to eq(array2)
+      expect(result[1].object_id).not_to eq(array2.object_id)
+    end
+
+    it 'should dupe a string' do
+      obj = 'Hello there'
+      result = described_class.deep_dup(obj)
+      expect(result).to eq(obj)
+    end
+  end
 end