/usr/lib/ruby/vendor_ruby/hashie/extensions/coercion.rb is in ruby-hashie 2.0.5-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | module Hashie
module Extensions
module Coercion
def self.included(base)
base.send :extend, ClassMethods
base.send :include, InstanceMethods
end
module InstanceMethods
def []=(key, value)
into = self.class.key_coercion(key) || self.class.value_coercion(value)
if value && into
if into.respond_to?(:coerce)
value = into.coerce(value)
else
value = into.new(value)
end
end
super(key, value)
end
def custom_writer(key, value)
self[key] = value
end
def replace(other_hash)
(keys - other_hash.keys).each { |key| delete(key) }
other_hash.each { |key, value| self[key] = value }
self
end
end
module ClassMethods
# Set up a coercion rule such that any time the specified
# key is set it will be coerced into the specified class.
# Coercion will occur by first attempting to call Class.coerce
# and then by calling Class.new with the value as an argument
# in either case.
#
# @param [Object] key the key or array of keys you would like to be coerced.
# @param [Class] into the class into which you want the key(s) coerced.
#
# @example Coerce a "user" subhash into a User object
# class Tweet < Hash
# include Hashie::Extensions::Coercion
# coerce_key :user, User
# end
def coerce_key(*attrs)
@key_coercions ||= {}
into = attrs.pop
attrs.each { |key| @key_coercions[key] = into }
end
alias :coerce_keys :coerce_key
# Returns a hash of any existing key coercions.
def key_coercions
@key_coercions || {}
end
# Returns the specific key coercion for the specified key,
# if one exists.
def key_coercion(key)
key_coercions[key.to_sym]
end
# Set up a coercion rule such that any time a value of the
# specified type is set it will be coerced into the specified
# class.
#
# @param [Class] from the type you would like coerced.
# @param [Class] into the class into which you would like the value coerced.
# @option options [Boolean] :strict (true) whether use exact source class only or include ancestors
#
# @example Coerce all hashes into this special type of hash
# class SpecialHash < Hash
# include Hashie::Extensions::Coercion
# coerce_value Hash, SpecialHash
#
# def initialize(hash = {})
# super
# hash.each_pair do |k,v|
# self[k] = v
# end
# end
# end
def coerce_value(from, into, options = {})
options = {:strict => true}.merge(options)
if options[:strict]
(@strict_value_coercions ||= {})[from] = into
else
while from.superclass && from.superclass != Object
(@lenient_value_coercions ||= {})[from] = into
from = from.superclass
end
end
end
# Return all value coercions that have the :strict rule as true.
def strict_value_coercions; @strict_value_coercions || {} end
# Return all value coercions that have the :strict rule as false.
def lenient_value_coercions; @value_coercions || {} end
# Fetch the value coercion, if any, for the specified object.
def value_coercion(value)
from = value.class
strict_value_coercions[from] || lenient_value_coercions[from]
end
end
end
end
end
|