Parent

Class Index [+]

Quicksearch

Object

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.

Public Instance Methods

acts_like?(duck) click to toggle source

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.

   # File lib/active_support/core_ext/object/acts_like.rb, line 7
7:   def acts_like?(duck)
8:     respond_to? :"acts_like_#{duck}?"
9:   end
blank?() click to toggle source

An object is blank if it’s false, empty, or a whitespace string. For example, “”, “ “, nil, [], and {} are blank.

This simplifies:

  if !address.nil? && !address.empty?

…to:

  if !address.blank?
    # File lib/active_support/core_ext/object/blank.rb, line 12
12:   def blank?
13:     respond_to?(:empty?) ? empty? : !self
14:   end
duplicable?() click to toggle source

Can you safely .dup this object? False for nil, false, true, symbols, numbers, class and module objects; true otherwise.

    # File lib/active_support/core_ext/object/duplicable.rb, line 20
20:   def duplicable?
21:     true
22:   end
html_safe?() click to toggle source
    # File lib/active_support/core_ext/string/output_safety.rb, line 55
55:   def html_safe?
56:     false
57:   end
instance_variable_names() click to toggle source
    # File lib/active_support/core_ext/object/instance_variables.rb, line 30
30:     def instance_variable_names
31:       instance_variables.map { |var| var.to_s }
32:     end
presence() click to toggle source

Returns object if it’s # 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'
    # File lib/active_support/core_ext/object/blank.rb, line 35
35:   def presence
36:     self if present?
37:   end
present?() click to toggle source

An object is present if it’s not blank.

    # File lib/active_support/core_ext/object/blank.rb, line 17
17:   def present?
18:     !blank?
19:   end
returning(value) click to toggle source

Returns value after yielding value to the block. This simplifies the process of constructing an object, performing work on the object, and then returning the object from a method. It is a Ruby-ized realization of the K combinator, courtesy of Mikael Brockman.

Examples

 # Without returning
 def foo
   values = []
   values << "bar"
   values << "baz"
   return values
 end

 foo # => ['bar', 'baz']

 # returning with a local variable
 def foo
   returning values = [] do
     values << 'bar'
     values << 'baz'
   end
 end

 foo # => ['bar', 'baz']

 # returning with a block argument
 def foo
   returning [] do |values|
     values << 'bar'
     values << 'baz'
   end
 end

 foo # => ['bar', 'baz']
    # File lib/active_support/core_ext/object/returning.rb, line 38
38:   def returning(value)
39:     ActiveSupport::Deprecation.warn('Object#returning has been deprecated in favor of Object#tap.', caller)
40:     yield(value)
41:     value
42:   end
to_param() click to toggle source

Alias of to_s.

   # File lib/active_support/core_ext/object/to_param.rb, line 5
5:   def to_param
6:     to_s
7:   end
to_query(key) click to toggle source

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.

    # File lib/active_support/core_ext/object/to_query.rb, line 8
 8:   def to_query(key)
 9:     require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
10:     "#{CGI.escape(key.to_s).gsub(/%(5B|5D)/n) { [$1].pack('H*') }}=#{CGI.escape(to_param.to_s)}"
11:   end
try(method, *args, &block) click to toggle source

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.

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}
    # File lib/active_support/core_ext/object/try.rb, line 25
25:   def try(method, *args, &block)
26:     send(method, *args, &block)
27:   end
unescape(str, escaped = /%[a-fA-F\d]{2}/) click to toggle source
    # File lib/active_support/core_ext/uri.rb, line 13
13:       def unescape(str, escaped = /%[a-fA-F\d]{2}/)
14:         # TODO: Are we actually sure that ASCII == UTF-8?
15:         # YK: My initial experiments say yes, but let's be sure please
16:         enc = str.encoding
17:         enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
18:         str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
19:       end
with_options(options) click to toggle source

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.

  with_options :order => 'created_at', :class_name => 'Comment' do |post|
    post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
    post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
    post.has_many :all_comments
  end

Can also be used with an explicit receiver:

  map.with_options :controller => "people" do |people|
    people.connect "/people",     :action => "index"
    people.connect "/people/:id", :action => "show"
  end
    # File lib/active_support/core_ext/object/with_options.rb, line 23
23:   def with_options(options)
24:     yield ActiveSupport::OptionMerger.new(self, options)
25:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.