Class | Object

In:

lib/active_support/core_ext/blank.rb
lib/active_support/core_ext/duplicable.rb
lib/active_support/core_ext/kernel/agnostics.rb
lib/active_support/core_ext/object/conversions.rb
lib/active_support/core_ext/object/extending.rb
lib/active_support/core_ext/object/instance_variables.rb
lib/active_support/core_ext/object/metaclass.rb
lib/active_support/core_ext/object/misc.rb
lib/active_support/core_ext/try.rb
lib/active_support/json/encoders/object.rb
lib/active_support/vendor/builder-2.1.2/blankslate.rb

Parent: | Object

Same as above, except in Object.

### Methods

acts_like? blank? class_eval duplicable? find_hidden_method instance_exec instance_variable_defined? instance_variable_names metaclass method_added present? returning tap to_json to_param to_query try with_options

### Included Modules

InstanceExecMethods

### External Aliases

__send__ | -> | try
method_added | -> | blank_slate_method_added

### Public Class methods

find_hidden_method(name)
method_added(name)

Detect method additions to Object and remove them in the BlankSlate class.

### Public Instance 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.

blank?()

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?

class_eval(*args, &block)

If class_eval is called on an object, add those methods to its metaclass

duplicable?()

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

instance_exec(*args, &block)

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

instance_variable_defined?(variable)
instance_variable_names()
metaclass()

Get object‘s meta (ghost, eigenclass, singleton) class

present?()

An object is present if it‘s not blank.

returning(value) {|value| ...}

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']

tap() {|self| ...}

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}" }

to_json(options = {})

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

to_param()

Alias of `to_s`.

to_query(key)

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.

try(method, *args, &block)

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}

with_options(options) {|ActiveSupport::OptionMerger.new(self, 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 `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

[Validate]