Use ActiveSupport Hash#deep_merge

And delete our own implementation.

Library/Homebrew/dev-cmd/bottle.rb

@@ -412,7 +412,7 @@ module Homebrew
     write = args.write?
 
     bottles_hash = ARGV.named.reduce({}) do |hash, json_file|
-      deep_merge_hashes hash, JSON.parse(IO.read(json_file))
+      hash.deep_merge(JSON.parse(IO.read(json_file)))
     end
 
     bottles_hash.each do |formula_name, bottle_hash|

Library/Homebrew/global.rb

@@ -131,6 +131,7 @@ require "extend/module"
 require "extend/predicable"
 require "extend/string"
 require "active_support/core_ext/object/blank"
+require "active_support/core_ext/hash/deep_merge"
 
 require "constants"
 require "exceptions"

Library/Homebrew/utils.rb

@@ -5,7 +5,6 @@ require "utils/fork"
 require "utils/formatter"
 require "utils/git"
 require "utils/github"
-require "utils/hash"
 require "utils/inreplace"
 require "utils/link"
 require "utils/popen"

Library/Homebrew/utils/hash.rb

@@ -1,10 +0,0 @@
-def deep_merge_hashes(hash1, hash2)
-  merger = proc do |_key, v1, v2|
-    if v1.is_a?(Hash) && v2.is_a?(Hash)
-      v1.merge v2, &merger
-    else
-      v2
-    end
-  end
-  hash1.merge hash2, &merger
-end

Library/Homebrew/vendor/bundle-standalone/ruby/2.3.0/gems/activesupport-5.2.1/lib/active_support/core_ext/hash/deep_merge.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+end