Namespace
Methods
A
B
C
D
H
I
O
P
T
U
W
Included Modules
Constants
MissingSourceFile = LoadError
 
HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
 
RUBY_ENGINE = 'ruby' unless defined?(RUBY_ENGINE)
 
Instance Public methods
acts_like?(duck)

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 activesupport/lib/active_support/core_ext/object/acts_like.rb, line 7
def acts_like?(duck)
  respond_to? :"acts_like_#{duck}?"
end
blank?()

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 activesupport/lib/active_support/core_ext/object/blank.rb, line 14
def blank?
  respond_to?(:empty?) ? empty? : !self
end
create_fixtures(*table_names, &block)
# File railties/lib/rails/test_help.rb, line 41
def create_fixtures(*table_names, &block)
  Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
end
duplicable?()

Can you safely dup this object?

False for nil, false, true, symbols, numbers, class and module objects; true otherwise.

# File activesupport/lib/active_support/core_ext/object/duplicable.rb, line 24
def duplicable?
  true
end
html_safe?()
# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 76
def html_safe?
  false
end
in?(*args)

Returns true if this object is included in the argument(s). Argument must be any object which responds to #include?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 #include?.

# File activesupport/lib/active_support/core_ext/object/inclusion.rb, line 13
def in?(*args)
  if args.length > 1
    args.include? self
  else
    another_object = args.first
    if another_object.respond_to? :include?
      another_object.include? self
    else
      raise ArgumentError.new("The single parameter passed to #in? must respond to #include?")
    end
  end
end
instance_variable_names()
# File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 27
def instance_variable_names
  instance_variables.map { |var| var.to_s }
end
options()
# File railties/lib/rails/commands/benchmarker.rb, line 8
def options
  options = {}
  defaults = ActiveSupport::Testing::Performance::DEFAULTS

  OptionParser.new do |opt|
    opt.banner = "Usage: rails benchmarker 'Ruby.code' 'Ruby.more_code' ... [OPTS]"
    opt.on('-r', '--runs N', Numeric, 'Number of runs.', "Default: #{defaults[:runs]}") { |r| options[:runs] = r }
    opt.on('-o', '--output PATH', String, 'Directory to use when writing the results.', "Default: #{defaults[:output]}") { |o| options[:output] = o }
    opt.on('-m', '--metrics a,b,c', Array, 'Metrics to use.', "Default: #{defaults[:metrics].join(",")}") { |m| options[:metrics] = m.map(&:to_sym) }
    opt.parse!(ARGV)
  end

  options
end
presence()

Returns object if it's present?otherwise returns nil. object.presenceis 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 activesupport/lib/active_support/core_ext/object/blank.rb, line 37
def presence
  self if present?
end
present?()

An object is present if it's not blank?.

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 19
def present?
  !blank?
end
to_json(options = nil)

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

# File activesupport/lib/active_support/core_ext/object/to_json.rb, line 15
def to_json(options = nil)
  ActiveSupport::JSON.encode(self, options)
end
to_param()

Alias of to_s.

# File activesupport/lib/active_support/core_ext/object/to_param.rb, line 3
def to_param
  to_s
end
to_query(key)

Converts an object into a string suitable for use as a URL query string, using the given keyas the param name.

Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.

# File activesupport/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)

Invokes the method identified by the symbol method, passing it any arguments and/or the block specified, just like the regular Ruby Object#senddoes.

Unlikethat method however, a NoMethodError exception will notbe raised and nilwill be returned instead, if the receiving object is a nilobject or NilClass.

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

Please also note that tryis defined on Object, therefore it won't work with subclasses of BasicObject. For example, using try with SimpleDelegatorwill delegate tryto target instead of calling it on delegator itself.

Examples

Without try

@person && @person.name

or

@person ? @person.name : nil

With try

@person.try(:name)

tryalso 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 activesupport/lib/active_support/core_ext/object/try.rb, line 32
def try(*a, &b)
  if a.empty? && block_given?
    yield self
  else
    __send__(*a, &b)
  end
end
unescape(str, escaped = /%[a-fA-F\d]{2}/)
# File activesupport/lib/active_support/core_ext/uri.rb, line 12
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
with_options(options)

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 optionshash 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_optionscan also be nested since the call is forwarded to its receiver. Each nesting level will merge inherited defaults in addition to their own.

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