Class

Object

Inheritance
Included Modules
InstanceExecMethods

Same as above, except in Object.

Aliases

Method Alias Description
__send__ → try
method_added → blank_slate_method_added

Methods

Class

Visibility Signature
public find_hidden_method (name)
public lookup_missing_generator (class_id)
public method_added (name)

Instance

Visibility Signature
public acts_like? (duck)
public blank? ()
public class_eval (*args, &block)
public duplicable? ()
public instance_exec (*args, &block)
public instance_variable_defined? (variable)
public instance_variable_names ()
public metaclass ()
public present? ()
public returning (value) {|value| ...}
public tap () {|self| ...}
public to_json (options = {})
public to_param ()
public to_param ()
public to_query (key)
public try (method, *args, &block)
public with_options (options) {|ActiveSupport::OptionMerger.new(self, options)| ...}

Class Method Detail

find_hidden_method(name)

lookup_missing_generator(class_id)

Lookup missing generators using const_missing. This allows any generator to reference another without having to know its location: RubyGems, ~/.rails/generators, and RAILS_ROOT/generators.

method_added(name)

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

Instance Method Detail

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()

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