Methods
Included Modules
Public Class methods
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.

    # File railties/lib/rails_generator/lookup.rb, line 10
10:     def lookup_missing_generator(class_id)
11:       if md = /(.+)Generator$/.match(class_id.to_s)
12:         name = md.captures.first.demodulize.underscore
13:         Rails::Generator::Base.lookup(name).klass
14:       else
15:         const_missing_before_generators(class_id)
16:       end
17:     end
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.

    # File activesupport/lib/active_support/core_ext/object/misc.rb, line 86
86:   def acts_like?(duck)
87:     respond_to? "acts_like_#{duck}?"
88:   end
as_json(options = nil)
   # File activesupport/lib/active_support/json/encoders/object.rb, line 7
7:   def as_json(options = nil)
8:     instance_values
9:   end
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?
    # File activesupport/lib/active_support/core_ext/object/blank.rb, line 12
12:   def blank?
13:     respond_to?(:empty?) ? empty? : !self
14:   end
class_eval(*args, &block)

class_eval on an object acts like singleton_class_eval.

    # File activesupport/lib/active_support/core_ext/object/singleton_class.rb, line 10
10:   def class_eval(*args, &block)
11:     singleton_class.class_eval(*args, &block)
12:   end
duplicable?()

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

   # File activesupport/lib/active_support/core_ext/duplicable.rb, line 4
4:   def duplicable?
5:     true
6:   end
html_safe?()
    # File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 52
52:   def html_safe?
53:     false
54:   end
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

    # File activesupport/lib/active_support/core_ext/object/extending.rb, line 63
63:     def instance_exec(*args, &block)
64:       begin
65:         old_critical, Thread.critical = Thread.critical, true
66:         n = 0
67:         n += 1 while respond_to?(method_name = "__instance_exec#{n}")
68:         InstanceExecMethods.module_eval { define_method(method_name, &block) }
69:       ensure
70:         Thread.critical = old_critical
71:       end
72: 
73:       begin
74:         send(method_name, *args)
75:       ensure
76:         InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
77:       end
78:     end
instance_variable_defined?(variable)
   # File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 4
4:     def instance_variable_defined?(variable)
5:       instance_variables.include?(variable.to_s)
6:     end
instance_variable_names()
    # File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 37
37:     def instance_variable_names
38:       instance_variables.map { |var| var.to_s }
39:     end
metaclass()

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

Deprecated in favor of Object#singleton_class.

    # File activesupport/lib/active_support/core_ext/object/metaclass.rb, line 7
 7:   def metaclass
 8:     class << self
 9:       self
10:     end
11:   end
presence()

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 activesupport/lib/active_support/core_ext/object/blank.rb, line 35
35:   def presence
36:     self if present?
37:   end
present?()

An object is present if it‘s not blank.

    # File activesupport/lib/active_support/core_ext/object/blank.rb, line 17
17:   def present?
18:     !blank?
19:   end
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']
    # File activesupport/lib/active_support/core_ext/object/misc.rb, line 38
38:   def returning(value)
39:     yield(value)
40:     value
41:   end
singleton_class()

Returns the object‘s singleton class.

   # File activesupport/lib/active_support/core_ext/object/singleton_class.rb, line 3
3:   def singleton_class
4:     class << self
5:       self
6:     end
7:   end
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}" }
    # File activesupport/lib/active_support/core_ext/object/misc.rb, line 53
53:   def tap
54:     yield self
55:     self
56:   end
to_json(options = nil)

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

   # File activesupport/lib/active_support/json/encoders/object.rb, line 3
3:   def to_json(options = nil)
4:     ActiveSupport::JSON.encode(as_json(options))
5:   end
to_param()
   # File actionpack/lib/action_controller/routing/routing_ext.rb, line 2
2:   def to_param
3:     to_s
4:   end
to_param()

Alias of to_s.

   # File activesupport/lib/active_support/core_ext/object/conversions.rb, line 3
3:   def to_param
4:     to_s
5:   end
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.

    # File activesupport/lib/active_support/core_ext/object/conversions.rb, line 11
11:   def to_query(key)
12:     require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
13:     "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
14:   end
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}
    # File activesupport/lib/active_support/core_ext/try.rb, line 25
25:   def try(method, *args, &block)
26:     send(method, *args, &block)
27:   end
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
    # File activesupport/lib/active_support/core_ext/object/misc.rb, line 77
77:   def with_options(options)
78:     yield ActiveSupport::OptionMerger.new(self, options)
79:   end