class Hash

def _deep_transform_keys_in_object(object, &block)
  case object
  when Hash
    object.each_with_object({}) 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 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
  Hash[subset.map { |k, v| [k.to_s, options ? v.as_json(options.dup) : v.as_json] }]
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
  self.select { |_, value| !value.nil? }
end

def compact!
  self.reject! { |_, value| value.nil? }
end

def deep_dup
  hash = dup
  each_pair do |key, value|
    if key.frozen? && ::String === 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_hash, &block)
  dup.deep_merge!(other_hash, &block)
end

def deep_merge!(other_hash, &block)
  other_hash.each_pair do |current_key, other_value|
    this_value = self[current_key]
    self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
      this_value.deep_merge(other_value, &block)
    else
      if block_given? && key?(current_key)
        block.call(current_key, this_value, other_value)
      else
        other_value
      end
    end
  end
  self
end

def deep_stringify_keys
  deep_transform_keys(&:to_s)
end

def deep_stringify_keys!
  deep_transform_keys!(&: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 except(*keys)
  dup.except!(*keys)
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 reverse_merge(other_hash)
  other_hash.merge(self)
end

def reverse_merge!(other_hash)
  # right wins if there is no left
  merge!( other_hash ){|key,left,right| left }
end

def slice(*keys)
  keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
  keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
end

def slice!(*keys)
  keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
  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(&:to_s)
end

def stringify_keys!
  transform_keys!(&: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)
  collect do |key, value|
    unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
    end
  end.compact.sort! * '&'
end

def to_xml(options = {})
  require 'active_support/builder' unless defined?(Builder)
  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 transform_keys
  return enum_for(:transform_keys) { size } unless block_given?
  result = {}
  each_key do |key|
    result[yield(key)] = self[key]
  end
  result
end

def transform_keys!
  return enum_for(:transform_keys!) { size } unless block_given?
  keys.each do |key|
    self[yield(key)] = delete(key)
  end
  self
end

def transform_values
  return enum_for(:transform_values) { size } unless block_given?
  return {} if empty?
  result = self.class.new
  each do |key, value|
    result[key] = yield(value)
  end
  result
end unless method_defined? :transform_values

def transform_values!
  return enum_for(:transform_values!) { size } unless block_given?
  each do |key, value|
    self[key] = yield(value)
  end
end unless method_defined? :transform_values!

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