Parent

Class Index [+]

Quicksearch

Object

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 all blank.

This simplifies:

  if address.nil? || address.empty?

…to:

  if address.blank?
    # File lib/active_support/core_ext/object/blank.rb, line 15
15:   def blank?
16:     respond_to?(:empty?) ? empty? : !self
17:   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 24
24:   def duplicable?
25:     true
26:   end
html_safe?() click to toggle source
    # File lib/active_support/core_ext/string/output_safety.rb, line 76
76:   def html_safe?
77:     false
78:   end
in?(*args) click to toggle source

Returns true if this object is included in the argument(s). Argument must be any object which responds to # or optionally, multiple arguments can be passed in. Usage:

  characters = ["Konata", "Kagami", "Tsukasa"]
  "Konata".in?(characters) # => true
  
  character = "Konata"
  character.in?("Konata", "Kagami", "Tsukasa") # => true

This will throw an ArgumentError if a single argument is passed in and it doesn’t respond to #.

    # File lib/active_support/core_ext/object/inclusion.rb, line 13
13:   def in?(*args)
14:     if args.length > 1
15:       args.include? self
16:     else
17:       another_object = args.first
18:       if another_object.respond_to? :include?
19:         another_object.include? self
20:       else
21:         raise ArgumentError.new("The single parameter passed to #in? must respond to #include?")
22:       end
23:     end
24:   end
instance_variable_names() click to toggle source
    # File lib/active_support/core_ext/object/instance_variables.rb, line 27
27:     def instance_variable_names
28:       instance_variables.map { |var| var.to_s }
29:     end
presence() click to toggle source

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'
    # File lib/active_support/core_ext/object/blank.rb, line 38
38:   def presence
39:     self if present?
40:   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 20
20:   def present?
21:     !blank?
22:   end
to_json(options = nil) click to toggle source

Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.

    # File lib/active_support/core_ext/object/to_json.rb, line 15
15:     def to_json(options = nil)
16:       ActiveSupport::JSON.encode(self, options)
17:     end
to_param() click to toggle source

Alias of to_s.

   # File lib/active_support/core_ext/object/to_param.rb, line 3
3:   def to_param
4:     to_s
5:   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_param)}=#{CGI.escape(to_param.to_s)}"
11:   end
try(*a, &b) 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.

If try is called without a method to call, it will yield any given block with the object.

Please also note that try is defined on Object, therefore it won’t work with subclasses of BasicObject. For example, using try with SimpleDelegator will delegate try to target instead of calling it on delegator itself.

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}" }
    # File lib/active_support/core_ext/object/try.rb, line 32
32:   def try(*a, &b)
33:     if a.empty? && block_given?
34:       yield self
35:     else
36:       __send__(*a, &b)
37:     end
38:   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.

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.

    # File lib/active_support/core_ext/object/with_options.rb, line 40
40:   def with_options(options)
41:     yield ActiveSupport::OptionMerger.new(self, options)
42:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.