Parent

Class/Module 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/misc.rb, line 89
def acts_like?(duck)
  respond_to? "acts_like_#{duck}?"
end
as_json(options = nil) click to toggle source
# File lib/active_support/json/encoders/object.rb, line 7
def as_json(options = nil)
  instance_values
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
def blank?
  respond_to?(:empty?) ? empty? : !self
end
class_eval(*args, &block) click to toggle source

class_eval on an object acts like singleton_class_eval.

# File lib/active_support/core_ext/object/singleton_class.rb, line 10
def class_eval(*args, &block)
  singleton_class.class_eval(*args, &block)
end
duplicable?() click to toggle source

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

# File lib/active_support/core_ext/duplicable.rb, line 4
def duplicable?
  true
end
html_safe?() click to toggle source
# File lib/active_support/core_ext/string/output_safety.rb, line 52
def html_safe?
  false
end
instance_exec(*args, &block) click to toggle source

Evaluate the block with the given arguments within the context of this object, so self is set to the method receiver.

From Mauricio's eigenclass.org/hiki/bounded+space+instance_exec

# File lib/active_support/core_ext/object/extending.rb, line 63
def instance_exec(*args, &block)
  begin
    old_critical, Thread.critical = Thread.critical, true
    n = 0
    n += 1 while respond_to?(method_name = "__instance_exec#{n}")
    InstanceExecMethods.module_eval { define_method(method_name, &block) }
  ensure
    Thread.critical = old_critical
  end

  begin
    send(method_name, *args)
  ensure
    InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
  end
end
instance_variable_defined?(variable) click to toggle source
# File lib/active_support/core_ext/object/instance_variables.rb, line 4
def instance_variable_defined?(variable)
  instance_variables.include?(variable.to_s)
end
instance_variable_names() click to toggle source
# File lib/active_support/core_ext/object/instance_variables.rb, line 37
def instance_variable_names
  instance_variables.map { |var| var.to_s }
end
metaclass() click to toggle source

Get object's meta (ghost, eigenclass, singleton) class.

Deprecated in favor of Object#singleton_class.

# File lib/active_support/core_ext/object/metaclass.rb, line 7
def metaclass
  class << self
    self
  end
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 35
def presence
  self if present?
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
def present?
  !blank?
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/misc.rb, line 40
def returning(value)
  ActiveSupport::Deprecation.warn('Kernel#returning has been deprecated in favor of Object#tap.', caller)
  yield(value)
  value
end
singleton_class() click to toggle source

Returns the object's singleton class.

# File lib/active_support/core_ext/object/singleton_class.rb, line 3
def singleton_class
  class << self
    self
  end
end
tap() click to toggle source

Yields x to the block, and then returns x. The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.

(1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
  tap    { |x| puts "array: #{x.inspect}" }.
  select { |x| x%2 == 0 }.
  tap    { |x| puts "evens: #{x.inspect}" }.
  map    { |x| x*x }.
  tap    { |x| puts "squares: #{x.inspect}" }
# File lib/active_support/core_ext/object/misc.rb, line 56
def tap
  yield self
  self
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/json/encoders/object.rb, line 3
def to_json(options = nil)
  ActiveSupport::JSON.encode(as_json(options))
end
to_param() click to toggle source

Alias of to_s.

# File lib/active_support/core_ext/object/conversions.rb, line 3
def to_param
  to_s
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/conversions.rb, line 11
def to_query(key)
  require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
  "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
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/try.rb, line 25
def try(method, *args, &block)
  send(method, *args, &block)
end
unescape(str, escaped = @regexp[:ESCAPED]) click to toggle source
# File lib/active_support/core_ext/uri.rb, line 10
def unescape(str, escaped = @regexp[:ESCAPED])
  enc = (str.encoding == Encoding::US_ASCII) ? Encoding::UTF_8 : str.encoding
  str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
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/misc.rb, line 80
def with_options(options)
  yield ActiveSupport::OptionMerger.new(self, options)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.