Object

Integration	=	ActionDispatch::Integration

IntegrationTest	=	ActionDispatch::IntegrationTest

PerformanceTest	=	ActionDispatch::PerformanceTest

AbstractRequest	=	ActionController::Request = ActionDispatch::Request

AbstractResponse	=	ActionController::Response = ActionDispatch::Response

Routing	=	ActionDispatch::Routing

ALL	=	Mime::Type.new("/", :all, [])

MissingSourceFile	=	LoadError

RUBY_ENGINE	=	'ruby' unless defined?(RUBY_ENGINE)

HashWithIndifferentAccess	=	ActiveSupport::HashWithIndifferentAccess

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.

Source: show

# File activesupport/lib/active_support/core_ext/object/acts_like.rb, line 7
def acts_like?(duck)
  respond_to? :"acts_like_#{duck}?"
end

app(create=false)

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

Source: show

# File railties/lib/rails/console/app.rb, line 10
def app(create=false)
  @app_integration_instance = nil if create
  @app_integration_instance ||= new_session do |sess|
    sess.host! "www.example.com"
  end
end

blank?()

An object is blank if it’s false, empty, or a whitespace string. For example, “”, “ ”, nil, [], and {} are all blank.

This simplifies:

if address.nil? || address.empty?

…to:

if address.blank?

Source: show

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 12
def blank?
  respond_to?(:empty?) ? empty? : !self
end

controller()

Source: show

# File railties/lib/rails/console/helpers.rb, line 5
def controller
  @controller ||= ApplicationController.new
end

create_fixtures(*table_names, &block)

Source: show

# File railties/lib/rails/test_help.rb, line 42
def create_fixtures(*table_names, &block)
  Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
end

duplicable?()

Can you safely dup this object?

False for nil, false, true, symbols, numbers, class and module objects; true otherwise.

Source: show

# File activesupport/lib/active_support/core_ext/object/duplicable.rb, line 24
def duplicable?
  true
end

helper()

Source: show

# File railties/lib/rails/console/helpers.rb, line 1
def helper
  @helper ||= ApplicationController.helpers
end

html_safe?()

Source: show

# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 65
def html_safe?
  false
end

in?(another_object)

Returns true if this object is included in the argument. Argument must be any object which responds to #include?. Usage:

characters = ["Konata", "Kagami", "Tsukasa"]
"Konata".in?(characters) # => true

This will throw an ArgumentError if the argument doesn’t respond to #include?.

Source: show

# File activesupport/lib/active_support/core_ext/object/inclusion.rb, line 10
def in?(another_object)
  another_object.include?(self)
rescue NoMethodError
  raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
end

instance_variable_names()

Source: show

# File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 27
def instance_variable_names
  instance_variables.map { |var| var.to_s }
end

new_session()

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

Source: show

# File railties/lib/rails/console/app.rb, line 19
def new_session
  app = Rails.application
  session = ActionDispatch::Integration::Session.new(app)
  yield session if block_given?
  session
end

options()

Source: show

# File railties/lib/rails/commands/profiler.rb, line 6
def options
  options = {}
  defaults = ActiveSupport::Testing::Performance::DEFAULTS

  OptionParser.new do |opt|
    opt.banner = "Usage: rails benchmarker 'Ruby.code' 'Ruby.more_code' ... [OPTS]"
    opt.on('-r', '--runs N', Numeric, 'Number of runs.', "Default: #{defaults[:runs]}") { |r| options[:runs] = r }
    opt.on('-o', '--output PATH', String, 'Directory to use when writing the results.', "Default: #{defaults[:output]}") { |o| options[:output] = o }
    opt.on('-m', '--metrics a,b,c', Array, 'Metrics to use.', "Default: #{defaults[:metrics].join(",")}") { |m| options[:metrics] = m.map(&:to_sym) }
    opt.on('-f', '--formats x,y,z', Array, 'Formats to output to.', "Default: #{defaults[:formats].join(",")}") { |m| options[:formats] = m.map(&:to_sym) }
    opt.parse!(ARGV)
  end

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

Source: show

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 35
def presence
  self if present?
end

present?()

An object is present if it’s not blank?.

Source: show

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 17
def present?
  !blank?
end

reload!(print=true)

reloads the environment

Source: show

# File railties/lib/rails/console/app.rb, line 27
def reload!(print=true)
  puts "Reloading..." if print
  ActionDispatch::Reloader.cleanup!
  ActionDispatch::Reloader.prepare!
  true
end

to_param()

Alias of to_s.

Source: show

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

Source: show

# File activesupport/lib/active_support/core_ext/object/to_query.rb, line 8
def to_query(key)
  require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
  "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
end

try(*a, &b)

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.

If try is called without a method to call, it will yield any given block with the object.

Examples

Without try

@person && @person.name

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

Without a method argument try will yield to the block unless the receiver is nil.

@person.try { |p| "#{p.first_name} #{p.last_name}" }

Source: show

# File activesupport/lib/active_support/core_ext/object/try.rb, line 28
def try(*a, &b)
  if a.empty? && block_given?
    yield self
  else
    __send__(*a, &b)
  end
end

unescape(str, escaped = /%[a-fA-F\d]{2}/)

Source: show

# File activesupport/lib/active_support/core_ext/uri.rb, line 12
def unescape(str, escaped = /%[a-fA-F\d]{2}/)
  # TODO: Are we actually sure that ASCII == UTF-8?
  # YK: My initial experiments say yes, but let's be sure please
  enc = str.encoding
  enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
  str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
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.

Without with_options>, this code contains duplication:

class Account < ActiveRecord::Base
  has_many :customers, :dependent => :destroy
  has_many :products,  :dependent => :destroy
  has_many :invoices,  :dependent => :destroy
  has_many :expenses,  :dependent => :destroy
end

Using with_options, we can remove the duplication:

class Account < ActiveRecord::Base
  with_options :dependent => :destroy do |assoc|
    assoc.has_many :customers
    assoc.has_many :products
    assoc.has_many :invoices
    assoc.has_many :expenses
  end
end

It can also be used with an explicit receiver:

I18n.with_options :locale => user.locale, :scope => "newsletter" do |i18n|
  subject i18n.t :subject
  body    i18n.t :body, :user_name => user.name
end

with_options can also be nested since the call is forwarded to its receiver. Each nesting level will merge inherited defaults in addition to their own.

Source: show

# File activesupport/lib/active_support/core_ext/object/with_options.rb, line 40
def with_options(options)
  yield ActiveSupport::OptionMerger.new(self, options)
end

Class Object <

Examples