- CLASS Object::HashWithIndifferentAccess
- CLASS Object::IntegrationTest
- CLASS Object::MissingSourceFile
- A
- B
- C
- D
- H
- I
- N
- O
- P
- R
- T
- U
- W
- FileUtils
- Java
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 |
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
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
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
Source: show
# File railties/lib/rails/console/helpers.rb, line 5 def controller @controller ||= ApplicationController.new end
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
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
Source: show
# File railties/lib/rails/console/helpers.rb, line 1 def helper @helper ||= ApplicationController.helpers end
Source: show
# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 65 def html_safe? false end
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
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
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
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
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
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
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
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
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
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
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
# 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
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
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