Object (original) (raw)

Namespace

• CLASS Object::HashWithIndifferentAccess
• CLASS Object::IntegrationTest
• CLASS Object::MissingSourceFile

Methods

A

• acts_like?,
• app

B

• blank?

C

• controller,
• create_fixtures

D

• duplicable?

H

• helper,
• html_safe?

I

• in?,
• instance_variable_names

N

• new_session

O

• options

P

• presence,
• present?

R

• reload!

T

• to_param,
• to_query,
• try

U

• unescape

W

• with_options

Included Modules

• FileUtils
• Java

Constants

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 extendsTime 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

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

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

def blank? respond_to?(:empty?) ? empty? : !self end

controller()

Source: show

def controller @controller ||= ApplicationController.new end

create_fixtures(*table_names, &block)

Source: show

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.

helper()

Source: show

def helper @helper ||= ApplicationController.helpers 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)

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

Source: show

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

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

def new_session app = Rails.application session = ActionDispatch::Integration::Session.new(app) yield session if block_given? session end

options()

Source: show

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 returnsnil. object.presence is equivalent toobject.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

def presence self if present? end

present?()

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

reload!(print=true)

reloads the environment

Source: show

def reload!(print=true) puts "Reloading..." if print ActionDispatch::Reloader.cleanup! ActionDispatch::Reloader.prepare! true end

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.

Source: show

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 RubyObject#send does.

Unlike that method however, a NoMethodErrorexception will not be raised and nil will be returned instead, if the receiving object is a nil object orNilClass.

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

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}

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

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

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

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 defaultoptions 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

def with_options(options) yield ActiveSupport::OptionMerger.new(self, options) end