class Hash

def _deep_transform_keys_in_object(object, &block)
  case object
  when Hash
    object.each_with_object(self.class.new) do |(key, value), result|
      result[yield(key)] = _deep_transform_keys_in_object(value, &block)
    end
  when Array
    object.map { |e| _deep_transform_keys_in_object(e, &block) }
  else
    object
  end
end

def _deep_transform_keys_in_object!(object, &block)
  case object
  when Hash
    object.keys.each do |key|
      value = object.delete(key)
      object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
    end
    object
  when Array
    object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
  else
    object
  end
end

def _deep_transform_values_in_object(object, &block)
  case object
  when Hash
    object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
  when Array
    object.map { |e| _deep_transform_values_in_object(e, &block) }
  else
    yield(object)
  end
end

def _deep_transform_values_in_object!(object, &block)
  case object
  when Hash
    object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
  when Array
    object.map! { |e| _deep_transform_values_in_object!(e, &block) }
  else
    yield(object)
  end
end

def as_json(options = nil) # :nodoc:
  # create a subset of the hash by applying :only or :except
  subset = if options
    if attrs = options[:only]
      slice(*Array(attrs))
    elsif attrs = options[:except]
      except(*Array(attrs))
    else
      self
    end
  else
    self
  end
  result = {}
  if options
    options = options.dup.freeze unless options.frozen?
    subset.each { |k, v| result[k.to_s] = v.as_json(options) }
  else
    subset.each { |k, v| result[k.to_s] = v.as_json }
  end
  result
end

def assert_valid_keys(*valid_keys)
  valid_keys.flatten!
  each_key do |k|
    unless valid_keys.include?(k)
      raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
    end
  end
end

def compact_blank # :nodoc:
  reject { |_k, v| v.blank? }
end

def compact_blank!
  # use delete_if rather than reject! because it always returns self even if nothing changed
  delete_if { |_k, v| v.blank? }
end

def deep_dup
  hash = dup
  each_pair do |key, value|
    if ::String === key || ::Symbol === key
      hash[key] = value.deep_dup
    else
      hash.delete(key)
      hash[key.deep_dup] = value.deep_dup
    end
  end
  hash
end

def deep_merge?(other) # :nodoc:
  other.is_a?(Hash)
end

def deep_stringify_keys
  deep_transform_keys { |k| Symbol === k ? k.name : k.to_s }
end

def deep_stringify_keys!
  deep_transform_keys! { |k| Symbol === k ? k.name : k.to_s }
end

def deep_symbolize_keys
  deep_transform_keys { |key| key.to_sym rescue key }
end

def deep_symbolize_keys!
  deep_transform_keys! { |key| key.to_sym rescue key }
end

def deep_transform_keys(&block)
  _deep_transform_keys_in_object(self, &block)
end

def deep_transform_keys!(&block)
  _deep_transform_keys_in_object!(self, &block)
end

def deep_transform_values(&block)
  _deep_transform_values_in_object(self, &block)
end

def deep_transform_values!(&block)
  _deep_transform_values_in_object!(self, &block)
end

def except!(*keys)
  keys.each { |key| delete(key) }
  self
end

def extract!(*keys)
  keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
end

def extractable_options?
  instance_of?(Hash)
end

def from_trusted_xml(xml)
  from_xml xml, []
end

def from_xml(xml, disallowed_types = nil)
  ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
end

def present? # :nodoc:
  !empty?
end

def reverse_merge(other_hash)
  other_hash.merge(self)
end

def reverse_merge!(other_hash)
  replace(reverse_merge(other_hash))
end

def slice!(*keys)
  omit = slice(*self.keys - keys)
  hash = slice(*keys)
  hash.default      = default
  hash.default_proc = default_proc if default_proc
  replace(hash)
  omit
end

def stringify_keys
  transform_keys { |k| Symbol === k ? k.name : k.to_s }
end

def stringify_keys!
  transform_keys! { |k| Symbol === k ? k.name : k.to_s }
end

def symbolize_keys
  transform_keys { |key| key.to_sym rescue key }
end

def symbolize_keys!
  transform_keys! { |key| key.to_sym rescue key }
end

def to_query(namespace = nil)
  query = filter_map do |key, value|
    unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
    end
  end
  query.sort! unless namespace.to_s.include?("[]")
  query.join("&")
end

def to_xml(options = {})
  require "active_support/builder" unless defined?(Builder::XmlMarkup)
  options = options.dup
  options[:indent]  ||= 2
  options[:root]    ||= "hash"
  options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
  builder = options[:builder]
  builder.instruct! unless options.delete(:skip_instruct)
  root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
  builder.tag!(root) do
    each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
    yield builder if block_given?
  end
end

def with_indifferent_access
  ActiveSupport::HashWithIndifferentAccess.new(self)
end