Class: Object
- Inherits:
- BasicObject
- Defined in:
- lib/active_support/core_ext/object/duplicable.rb,
lib/active_support/json/encoding.rb,
lib/active_support/core_ext/object/try.rb,
lib/active_support/core_ext/object/blank.rb,
lib/active_support/core_ext/object/to_param.rb,
lib/active_support/core_ext/object/to_query.rb,
lib/active_support/core_ext/kernel/agnostics.rb,
lib/active_support/core_ext/object/acts_like.rb,
lib/active_support/core_ext/object/inclusion.rb,
lib/active_support/core_ext/object/with_options.rb,
lib/active_support/core_ext/string/output_safety.rb,
lib/active_support/core_ext/object/instance_variables.rb
Overview
– Most objects are cloneable, but not all. For example you can’t dup nil
:
nil.dup # => TypeError: can't dup NilClass
Classes may signal their instances are not duplicable removing dup
/clone
or raising exceptions from them. So, to dup an arbitrary object you normally use an optimistic approach and are ready to catch an exception, say:
arbitrary_object.dup rescue object
Rails dups objects in a few critical spots where they are not that arbitrary. That rescue is very expensive (like 40 times slower than a predicate), and it is often triggered.
That’s why we hardcode the following cases and check duplicable? instead of using that rescue idiom. ++
Instance Method Summary collapse
-
#`(command) ⇒ Object
Makes backticks behave (somewhat more) similarly on all platforms.
-
#acts_like?(duck) ⇒ Boolean
A duck-type assistant method.
-
#as_json(options = nil) ⇒ Object
:nodoc:.
-
#blank? ⇒ Boolean
An object is blank if it’s false, empty, or a whitespace string.
-
#duplicable? ⇒ Boolean
Can you safely dup this object?.
- #html_safe? ⇒ Boolean
-
#in?(another_object) ⇒ Boolean
Returns true if this object is included in the argument.
-
#instance_values ⇒ Object
Returns a hash that maps instance variable names without “@” to their corresponding values.
-
#presence ⇒ Object
Returns object if it’s
present?
otherwise returnsnil
. -
#present? ⇒ Boolean
An object is present if it’s not
blank?
. -
#to_param ⇒ Object
Alias of
to_s
. -
#to_query(key) ⇒ Object
Converts an object into a string suitable for use as a URL query string, using the given
key
as the param name. -
#try(*a, &b) ⇒ Object
Invokes the method identified by the symbol
method
, passing it any arguments and/or the block specified, just like the regular RubyObject#send
does. -
#with_options(options) {|ActiveSupport::OptionMerger.new(self, options)| ... } ⇒ Object
An elegant way to factor duplication out of options passed to a series of method calls.
Instance Method Details
#`(command) ⇒ Object
Makes backticks behave (somewhat more) similarly on all platforms. On win32 ‘nonexistent_command` raises Errno::ENOENT; on Unix, the spawned shell prints a message to stderr and sets $?. We emulate Unix on the former but not the latter.
6 7 8 9 10 |
# File 'lib/active_support/core_ext/kernel/agnostics.rb', line 6 def `(command) #:nodoc: super rescue Errno::ENOENT => e STDERR.puts "#$0: #{e}" end |
#acts_like?(duck) ⇒ Boolean
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.
7 8 9 |
# File 'lib/active_support/core_ext/object/acts_like.rb', line 7 def acts_like?(duck) respond_to? :"acts_like_#{duck}?" end |
#as_json(options = nil) ⇒ Object
:nodoc:
148 149 150 151 152 153 154 |
# File 'lib/active_support/json/encoding.rb', line 148 def as_json( = nil) #:nodoc: if respond_to?(:to_hash) to_hash else instance_values end end |
#blank? ⇒ Boolean
An object is blank if it’s false, empty, or a whitespace string. For example, “”, “ ”, nil
, [], and {} are all blank.
This simplifies:
if address.nil? || address.empty?
…to:
if address.blank?
12 13 14 |
# File 'lib/active_support/core_ext/object/blank.rb', line 12 def blank? respond_to?(:empty?) ? empty? : !self end |
#duplicable? ⇒ Boolean
Can you safely dup this object?
False for nil
, false
, true
, symbols, numbers, class and module objects; true otherwise.
24 25 26 |
# File 'lib/active_support/core_ext/object/duplicable.rb', line 24 def duplicable? true end |
#html_safe? ⇒ Boolean
76 77 78 |
# File 'lib/active_support/core_ext/string/output_safety.rb', line 76 def html_safe? false end |
#in?(another_object) ⇒ Boolean
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?
.
10 11 12 13 14 |
# File 'lib/active_support/core_ext/object/inclusion.rb', line 10 def in?(another_object) another_object.include?(self) rescue NoMethodError raise ArgumentError.new("The parameter passed to #in? must respond to #include?") end |
#instance_values ⇒ Object
Returns a hash that maps instance variable names without “@” to their corresponding values. Keys are strings both in Ruby 1.8 and 1.9.
class C
def initialize(x, y)
@x, @y = x, y
end
end
C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
12 13 14 |
# File 'lib/active_support/core_ext/object/instance_variables.rb', line 12 def instance_values #:nodoc: Hash[instance_variables.map { |name| [name.to_s[1..-1], instance_variable_get(name)] }] end |
#presence ⇒ Object
Returns object if it’s present?
otherwise returns nil
. object.presence
is equivalent to object.present? ? object : nil
.
This is handy for any representation of objects where blank is the same as not present at all. For example, this simplifies a common check for HTTP POST/query parameters:
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'
35 36 37 |
# File 'lib/active_support/core_ext/object/blank.rb', line 35 def presence self if present? end |
#present? ⇒ Boolean
An object is present if it’s not blank?
.
17 18 19 |
# File 'lib/active_support/core_ext/object/blank.rb', line 17 def present? !blank? end |
#to_param ⇒ Object
Alias of to_s
.
3 4 5 |
# File 'lib/active_support/core_ext/object/to_param.rb', line 3 def to_param to_s end |
#to_query(key) ⇒ Object
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.
8 9 10 11 |
# File 'lib/active_support/core_ext/object/to_query.rb', line 8 def to_query(key) require 'cgi' unless defined?(CGI) && defined?(CGI::escape) "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}" end |
#try(*a, &b) ⇒ Object
Invokes the method identified by the symbol method
, passing it any arguments and/or the block specified, just like the regular Ruby Object#send
does.
Unlike that method however, a NoMethodError
exception will not be raised and nil
will be returned instead, if the receiving object is a nil
object or NilClass.
If try is called without a method to call, it will yield any given block with the object.
Examples
Without try
@person && @person.name
or
@person ? @person.name : nil
With try
@person.try(:name)
try
also accepts arguments and/or a block, for the method it is trying
Person.try(:find, 1)
@people.try(:collect) {|p| p.name}
Without a method argument try will yield to the block unless the receiver is nil.
@person.try { |p| "#{p.first_name} #{p.last_name}" }
– try
behaves like Object#send, unless called on NilClass
.
28 29 30 31 32 33 34 |
# File 'lib/active_support/core_ext/object/try.rb', line 28 def try(*a, &b) if a.empty? && block_given? yield self else __send__(*a, &b) end end |
#with_options(options) {|ActiveSupport::OptionMerger.new(self, options)| ... } ⇒ Object
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
: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. :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.
40 41 42 |
# File 'lib/active_support/core_ext/object/with_options.rb', line 40 def () yield ActiveSupport::OptionMerger.new(self, ) end |