- A
- B
- C
- D
- H
- I
- P
- T
- U
- W
- Java
MissingSourceFile | = | LoadError |
HashWithIndifferentAccess | = | ActiveSupport::HashWithIndifferentAccess |
Implements a hash where keys
Internally symbols are mapped to strings when used as keys in the entire
writing interface (calling
You are guaranteed that the key is returned as a string:
Technically other types of keys are accepted:
but this class is intended for use cases where strings or symbols are the
expected keys and it is convenient to understand both as the same. For
example the Note that core extensions define
which may be handy. |
A duck-type assistant method. For example, Active Support extends Date to define an acts_like_date?
method,
and extends Time to define acts_like_time?
. As a result, we
can do x.acts_like?(:time)
and
x.acts_like?(:date)
to do duck-type-safe comparisons, since
classes that we want to act like Time simply need to define an
acts_like_time?
method.
An object is blank if it's false, empty, or a whitespace string. For
example, '', ' ', nil
, [], and {} are all
blank.
This simplifies
address.nil? || address.empty?
to
address.blank?
@return [true, false]
Returns a deep copy of object if it's duplicable. If it's not
duplicable, returns self
.
object = Object.new
dup = object.deep_dup
dup.instance_variable_set(:@a, 1)
object.instance_variable_defined?(:@a) # => false
dup.instance_variable_defined?(:@a) # => true
Can you safely dup this object?
False for nil
, false
, true
, symbol,
and number objects; true otherwise.
Returns true if this object is included in the argument. Argument must be
any object which responds to #include?
. Usage:
characters = ["Konata", "Kagami", "Tsukasa"]
"Konata".in?(characters) # => true
This will throw an ArgumentError if the argument doesn't respond to
#include?
.
Returns a hash with string keys that maps instance variable names without “@” to their corresponding values.
class C
def initialize(x, y)
@x, @y = x, y
end
end
C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
Returns an array of instance variable names as strings including “@”.
class C
def initialize(x, y)
@x, @y = x, y
end
end
C.new(0, 1).instance_variable_names # => ["@y", "@x"]
Returns the receiver if it's present otherwise returns
nil
. object.presence
is equivalent to
object.present? ? object : nil
For example, something like
state = params[:state] if params[:state].present?
country = params[:country] if params[:country].present?
region = state || country || 'US'
becomes
region = params[:state].presence || params[:country].presence || 'US'
@return [Object]
Returns the receiver if it's included in the argument otherwise returns
nil
. Argument must be any object which responds to
#include?
. Usage:
params[:bucket_type].presence_in %w( project calendar )
This will throw an ArgumentError if the argument doesn't respond to
#include?
.
@return [Object]
An object is present if it's not blank.
@return [true, false]
# File activesupport/lib/active_support/core_ext/object/json.rb, line 31 def to_json_with_active_support_encoder(options = nil) if options.is_a?(::JSON::State) # Called from JSON.{generate,dump}, forward it to JSON gem's to_json self.to_json_without_active_support_encoder(options) else # to_json is being invoked directly, use ActiveSupport's encoder ActiveSupport::JSON.encode(self, options) end end
Alias of to_s
.
Converts an object into a string suitable for use as a URL query string,
using the given key
as the param name.
Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
Invokes the public method whose name goes as first argument just like
public_send
does, except that if the receiver does not respond
to it the call returns nil
rather than raising an exception.
This method is defined to be able to write
@person.try(:name)
instead of
@person ? @person.name : nil
try
returns nil
when called on nil
regardless of whether it responds to the method:
nil.try(:to_i) # => nil, rather than 0
Arguments and blocks are forwarded to the method if invoked:
@posts.try(:each_slice, 2) do |a, b|
...
end
The number of arguments in the signature must match. If the object responds
to the method the call is attempted and ArgumentError
is still
raised otherwise.
If try
is called without arguments it yields the receiver to a
given block unless it is nil
:
@person.try do |p|
...
end
Please also note that try
is defined on Object
,
therefore it won't work with instances of classes that do not have
Object
among their ancestors, like direct subclasses of
BasicObject
. For example, using try
with
SimpleDelegator
will delegate try
to the target
instead of calling it on delegator itself.
Same as try, but will raise a NoMethodError exception if the receiving is not nil and does not implement the tried method.
# File activesupport/lib/active_support/core_ext/uri.rb, line 9 def unescape(str, escaped = /%[a-fA-F\d]{2}/) # TODO: Are we actually sure that ASCII == UTF-8? # YK: My initial experiments say yes, but let's be sure please enc = str.encoding enc = Encoding::UTF_8 if enc == Encoding::US_ASCII str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc) end
An elegant way to factor duplication out of options passed to a series of
method calls. Each method called in the block, with the block variable as
the receiver, will have its options merged with the default
options
hash provided. Each method called on the block
variable must take an options hash as its final argument.
Without with_options>
, this code contains duplication:
class Account < ActiveRecord::Base
has_many :customers, dependent: :destroy
has_many :products, dependent: :destroy
has_many :invoices, dependent: :destroy
has_many :expenses, dependent: :destroy
end
Using with_options
, we can remove the duplication:
class Account < ActiveRecord::Base
with_options dependent: :destroy do |assoc|
assoc.has_many :customers
assoc.has_many :products
assoc.has_many :invoices
assoc.has_many :expenses
end
end
It can also be used with an explicit receiver:
I18n.with_options locale: user.locale, scope: 'newsletter' do |i18n|
subject i18n.t :subject
body i18n.t :body, user_name: user.name
end
with_options
can also be nested since the call is forwarded to
its receiver. Each nesting level will merge inherited defaults in addition
to their own.