class Hashie::Mash

def self.disable_warnings
  fail CannotDisableMashWarnings if self == Hashie::Mash
  @disable_warnings = true
end

def self.disable_warnings?
  !!@disable_warnings
end

def self.inherited(subclass)
  super
  subclass.disable_warnings if disable_warnings?
end

def self.load(path, options = {})
  @_mashes ||= new
  return @_mashes[path] if @_mashes.key?(path)
  fail ArgumentError, "The following file doesn't exist: #{path}" unless File.file?(path)
  parser = options.fetch(:parser) {  Hashie::Extensions::Parsers::YamlErbParser }
  @_mashes[path] = new(parser.perform(path)).freeze
end

def assign_property(name, value)
  self[name] = value
end

def convert_key(key) #:nodoc:
  key.to_s
end

def convert_value(val, duping = false) #:nodoc:
  case val
  when self.class
    val.dup
  when Hash
    duping ? val.dup : val
  when ::Hash
    val = val.dup if duping
    self.class.new(val)
  when Array
    val.map { |e| convert_value(e) }
  when ::Array
    Array.new(val.map { |e| convert_value(e) })
  else
    val
  end
end

def custom_reader(key)
  default_proc.call(self, key) if default_proc && !key?(key)
  value = regular_reader(convert_key(key))
  yield value if block_given?
  value
end

def custom_writer(key, value, convert = true) #:nodoc:
  key_as_symbol = (key = convert_key(key)).to_sym
  log_built_in_message(key_as_symbol) if log_collision?(key_as_symbol)
  regular_writer(key, convert ? convert_value(value) : value)
end

def deep_merge(other_hash, &blk)
  dup.deep_update(other_hash, &blk)
end

def deep_update(other_hash, &blk)
  other_hash.each_pair do |k, v|
    key = convert_key(k)
    if regular_reader(key).is_a?(Mash) && v.is_a?(::Hash)
      custom_reader(key).deep_update(v, &blk)
    else
      value = convert_value(v, true)
      value = convert_value(blk.call(key, self[k], value), true) if blk && self.key?(k)
      custom_writer(key, value, false)
    end
  end
  self
end

def delete(key)
  super(convert_key(key))
end

def dig(*keys)
  super(*keys.map { |key| convert_key(key) })
end

def dup
  self.class.new(self, default)
end

def extractable_options?
  true
end

def fetch(key, *args)
  super(convert_key(key), *args)
end

def initialize(source_hash = nil, default = nil, &blk)
  deep_update(source_hash) if source_hash
  default ? super(default) : super(&blk)
end

def initializing_reader(key)
  ck = convert_key(key)
  regular_writer(ck, self.class.new) unless key?(ck)
  regular_reader(ck)
end

def key?(key)
  super(convert_key(key))
end

def log_built_in_message(method_key)
  return if self.class.disable_warnings?
  method_information = Hashie::Utils.method_information(method(method_key))
  Hashie.logger.warn(
    'You are setting a key that conflicts with a built-in method ' \
    "#{self.class}##{method_key} #{method_information}. " \
    'This can cause unexpected behavior when accessing the key via as a ' \
    'property. You can still access the key via the #[] method.'
  )
end

def log_collision?(method_key)
  respond_to?(method_key) && !self.class.disable_warnings? &&
    !(regular_key?(method_key) || regular_key?(method_key.to_s))
end

def method_missing(method_name, *args, &blk)
  return self.[](method_name, &blk) if key?(method_name)
  name, suffix = method_name_and_suffix(method_name)
  case suffix
  when '='.freeze
    assign_property(name, args.first)
  when '?'.freeze
    !!self[name]
  when '!'.freeze
    initializing_reader(name)
  when '_'.freeze
    underbang_reader(name)
  else
    self[method_name]
  end
end

def method_name_and_suffix(method_name)
  method_name = method_name.to_s
  if method_name.end_with?(*ALLOWED_SUFFIXES)
    [method_name[0..-2], method_name[-1]]
  else
    [method_name[0..-1], nil]
  end
end

def method_suffix(method_name)
  method_name = method_name.to_s
  method_name[-1] if method_name.end_with?(*ALLOWED_SUFFIXES)
end

def prefix_method?(method_name)
  method_name = method_name.to_s
  method_name.end_with?(*ALLOWED_SUFFIXES) && key?(method_name.chop)
end

def replace(other_hash)
  (keys - other_hash.keys).each { |key| delete(key) }
  other_hash.each { |key, value| self[key] = value }
  self
end

def respond_to_missing?(method_name, *args)
  return true if key?(method_name)
  suffix = method_suffix(method_name)
  if suffix
    true
  else
    super
  end
end

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

def shallow_merge(other_hash)
  dup.shallow_update(other_hash)
end

def shallow_update(other_hash)
  other_hash.each_pair do |k, v|
    regular_writer(convert_key(k), convert_value(v, true))
  end
  self
end

def to_module(mash_method_name = :settings)
  mash = self
  Module.new do |m|
    m.send :define_method, mash_method_name.to_sym do
      mash
    end
  end
end

def underbang_reader(key)
  ck = convert_key(key)
  if key?(ck)
    regular_reader(ck)
  else
    self.class.new
  end
end

def values_at(*keys)
  super(*keys.map { |key| convert_key(key) })
end