Methods
A
B
C
D
F
H
I
L
M
N
P
R
T
W
Included Modules
Classes and Modules
Class Public 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
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/misc.rb, line 71
71:   def acts_like?(duck)
72:     respond_to? "acts_like_#{duck}?"
73:   end
app(create=false)

reference the global “app” instance, created on demand. To recreate the instance, pass a non-false value as the parameter.

    # File railties/lib/console_app.rb, line 8
 8: def app(create=false)
 9:   @app_integration_instance = nil if create
10:   @app_integration_instance ||= new_session do |sess|
11:     sess.host! "www.example.com"
12:   end
13: 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/blank.rb, line 12
12:   def blank?
13:     respond_to?(:empty?) ? empty? : !self
14:   end
class_eval(*args, &block)

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

    # File activesupport/lib/active_support/core_ext/object/metaclass.rb, line 10
10:   def class_eval(*args, &block)
11:     metaclass.class_eval(*args, &block)
12:   end
create_fixtures(*table_names)
    # File railties/lib/test_help.rb, line 17
17: def create_fixtures(*table_names)
18:   Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
19: 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
find_cmd(*commands)
    # File railties/lib/commands/dbconsole.rb, line 22
22: def find_cmd(*commands)
23:   dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
24:   commands += commands.map{|cmd| "#{cmd}.exe"} if RUBY_PLATFORM =~ /win32/
25:   commands.detect do |cmd|
26:     dirs_on_path.detect do |path|
27:       File.executable? File.join(path, cmd)
28:     end
29:   end || abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
30: end
helper(*helper_names)
    # File railties/lib/console_with_helpers.rb, line 13
13: def helper(*helper_names)
14:   returning @helper_proxy ||= Object.new do |helper|
15:     helper_names.each { |h| helper.extend "#{h}_helper".classify.constantize }
16:   end
17: 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

   # File activesupport/lib/active_support/core_ext/object/metaclass.rb, line 3
3:   def metaclass
4:     class << self
5:       self
6:     end
7:   end
new_session()

create a new session. If a block is given, the new session will be yielded to the block before being returned.

    # File railties/lib/console_app.rb, line 17
17: def new_session
18:   session = ActionController::Integration::Session.new
19:   yield session if block_given?
20:   session
21: end
present?()

An object is present if it’s not blank.

    # File activesupport/lib/active_support/core_ext/blank.rb, line 17
17:   def present?
18:     !blank?
19:   end
reload!()

reloads the environment

    # File railties/lib/console_app.rb, line 24
24: def reload!
25:   puts "Reloading..."
26:   dispatcher = ActionController::Dispatcher.new($stdout)
27:   dispatcher.cleanup_application
28:   dispatcher.reload_application
29:   true
30: end
returning(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
to_json(options = {})

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 = {})
4:     ActiveSupport::JSON.encode(instance_values, options)
5:   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_param()
   # File actionpack/lib/action_controller/routing/routing_ext.rb, line 2
2:   def to_param
3:     to_s
4:   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:     "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
13:   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 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 62
62:   def with_options(options)
63:     yield ActiveSupport::OptionMerger.new(self, options)
64:   end