lib/hashie/extensions/method_access.rb
module Hashie
module Extensions
# MethodReader allows you to access keys of the hash
# via method calls. This gives you an OStruct like way
# to access your hash's keys. It will recognize keys
# either as strings or symbols.
#
# Note that while nil keys will be returned as nil,
# undefined keys will raise NoMethodErrors. Also note that
# #respond_to? has been patched to appropriately recognize
# key methods.
#
# @example
# class User < Hash
# include Hashie::Extensions::MethodReader
# end
#
# user = User.new
# user['first_name'] = 'Michael'
# user.first_name # => 'Michael'
#
# user[:last_name] = 'Bleigh'
# user.last_name # => 'Bleigh'
#
# user[:birthday] = nil
# user.birthday # => nil
#
# user.not_declared # => NoMethodError
module MethodReader
def respond_to_missing?(name, include_private = false)
return true if key?(name.to_s) || key?(name.to_sym)
super
end
def method_missing(name, *args)
if key?(name)
self[name]
else
sname = name.to_s
if key?(sname)
self[sname]
elsif sname[-1] == '?'
kname = sname[0..-2]
key?(kname) || key?(kname.to_sym)
else
super
end
end
end
end
# MethodWriter gives you #key_name= shortcuts for
# writing to your hash. Keys are written as strings,
# override #convert_key if you would like to have symbols
# or something else.
#
# Note that MethodWriter also overrides #respond_to such
# that any #method_name= will respond appropriately as true.
#
# @example
# class MyHash < Hash
# include Hashie::Extensions::MethodWriter
# end
#
# h = MyHash.new
# h.awesome = 'sauce'
# h['awesome'] # => 'sauce'
#
module MethodWriter
def respond_to_missing?(name, include_private = false)
return true if name.to_s =~ /=$/
super
end
def method_missing(name, *args)
if args.size == 1 && name.to_s =~ /(.*)=$/
return self[convert_key(Regexp.last_match[1])] = args.first
end
super
end
def convert_key(key)
key.to_s
end
end
# MethodQuery gives you the ability to check for the truthiness
# of a key via method calls. Note that it will return false if
# the key is set to a non-truthful value, not if the key isn't
# set at all. Use #key? for checking if a key has been set.
#
# MethodQuery will check against both string and symbol names
# of the method for existing keys. It also patches #respond_to
# to appropriately detect the query methods.
#
# @example
# class MyHash < Hash
# include Hashie::Extensions::MethodQuery
# end
#
# h = MyHash.new
# h['abc'] = 123
# h.abc? # => true
# h['def'] = nil
# h.def? # => false
# h.hji? # => NoMethodError
module MethodQuery
def respond_to_missing?(name, include_private = false)
if query_method?(name) && indifferent_key?(key_from_query_method(name))
true
else
super
end
end
def method_missing(name, *args)
return super unless args.empty?
if query_method?(name)
key = key_from_query_method(name)
if indifferent_key?(key)
!!(self[key] || self[key.to_sym])
else
super
end
else
super
end
end
private
def indifferent_key?(name)
name = name.to_s
key?(name) || key?(name.to_sym)
end
def key_from_query_method(query_method)
query_method.to_s[0..-2]
end
def query_method?(name)
name.to_s.end_with?('?')
end
end
# A macro module that will automatically include MethodReader,
# MethodWriter, and MethodQuery, giving you the ability to read,
# write, and query keys in a hash using method call shortcuts.
module MethodAccess
def self.included(base)
[MethodReader, MethodWriter, MethodQuery].each do |mod|
base.send :include, mod
end
end
end
# A module shared between MethodOverridingWriter and MethodOverridingInitializer
# to contained shared logic. This module aids in redefining existing hash methods.
module RedefineMethod
protected
def method?(name)
methods.map(&:to_s).include?(name)
end
def redefine_method(method_name)
eigenclass = class << self; self; end
eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
end
end
# MethodOverridingWriter gives you #key_name= shortcuts for
# writing to your hash. It allows methods to be overridden by
# #key_name= shortcuts and aliases those methods with two
# leading underscores.
#
# Keys are written as strings. Override #convert_key if you
# would like to have symbols or something else.
#
# Note that MethodOverridingWriter also overrides
# #respond_to_missing? such that any #method_name= will respond
# appropriately as true.
#
# @example
# class MyHash < Hash
# include Hashie::Extensions::MethodOverridingWriter
# end
#
# h = MyHash.new
# h.awesome = 'sauce'
# h['awesome'] # => 'sauce'
# h.zip = 'a-dee-doo-dah'
# h.zip # => 'a-dee-doo-dah'
# h.__zip # => [[['awesome', 'sauce'], ['zip', 'a-dee-doo-dah']]]
#
module MethodOverridingWriter
include RedefineMethod
def convert_key(key)
key.to_s
end
def method_missing(name, *args)
if args.size == 1 && name.to_s =~ /(.*)=$/
key = Regexp.last_match[1]
redefine_method(key) if method?(key) && !already_overridden?(key)
return self[convert_key(key)] = args.first
end
super
end
def respond_to_missing?(name, include_private = false)
return true if name.to_s.end_with?('=')
super
end
protected
def already_overridden?(name)
method?("__#{name}")
end
end
# A macro module that will automatically include MethodReader,
# MethodOverridingWriter, and MethodQuery, giving you the ability
# to read, write, and query keys in a hash using method call
# shortcuts that can override object methods. Any overridden
# object method is automatically aliased with two leading
# underscores.
module MethodAccessWithOverride
def self.included(base)
[MethodReader, MethodOverridingWriter,
MethodQuery, MethodOverridingInitializer].each do |mod|
base.send :include, mod
end
end
end
# MethodOverridingInitializer allows you to override default hash
# methods when passing in values from an existing hash. The overriden
# methods are aliased with two leading underscores.
#
# @example
# class MyHash < Hash
# include Hashie::Extensions::MethodOverridingInitializer
# end
#
# h = MyHash.new(zip: 'a-dee-doo-dah')
# h.zip # => 'a-dee-doo-dah'
# h.__zip # => [[['zip', 'a-dee-doo-dah']]]
module MethodOverridingInitializer
include RedefineMethod
def initialize(hash = {})
hash.each do |key, value|
skey = key.to_s
redefine_method(skey) if method?(skey)
self[skey] = value
end
end
end
end
end