- #
- A
- B
- C
- D
- E
- F
- I
- L
- M
- S
- T
- U
- Z
| COMMON_YEAR_DAYS_IN_MONTH | = | [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] |
| DATE_FORMATS | = | { :db => '%Y-%m-%d %H:%M:%S', :number => '%Y%m%d%H%M%S', :nsec => '%Y%m%d%H%M%S%9N', :time => '%H:%M', :short => '%d %b %H:%M', :long => '%B %d, %Y %H:%M', :long_ordinal => lambda { |time| day_format = ActiveSupport::Inflector.ordinalize(time.day) time.strftime("%B #{day_format}, %Y %H:%M") }, :rfc822 => lambda { |time| offset_format = time.formatted_offset(false) time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}") } } |
| [RW] | zone_default |
Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
# File activesupport/lib/active_support/core_ext/time/marshal.rb, line 8 def _load(marshaled_time) time = _load_without_zone(marshaled_time) time.instance_eval do if zone = defined?(@_zone) && remove_instance_variable('@_zone') ary = to_a ary[0] += subsec if ary[0] == sec ary[-1] = zone utc? ? Time.utc(*ary) : Time.local(*ary) else self end end end
Layers additional behavior on ::at so that ActiveSupport::TimeWithZone and DateTime instances can be used when called with a single argument
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 71 def at_with_coercion(*args) return at_without_coercion(*args) if args.size != 1 # Time.at can be called with a time or numerical value time_or_number = args.first if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime) at_without_coercion(time_or_number.to_f).getlocal else at_without_coercion(time_or_number) end end
Returns Time.zone.now when Time.zone or
config.time_zone are set, otherwise just returns
Time.now.
Return the number of days in the given month. If no year is specified, it will use the current year.
Returns a TimeZone instance or nil, or raises an ArgumentError for invalid timezones.
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 53 def find_zone!(time_zone) if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone) time_zone else # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone) unless time_zone.respond_to?(:period_for_local) time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone) end # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone if time_zone.is_a?(ActiveSupport::TimeZone) time_zone else ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone) end end rescue TZInfo::InvalidTimezoneIdentifier raise ArgumentError, "Invalid Timezone: #{time_zone}" end
DEPRECATED: Use +Time#local+ instead.
Wraps class method time_with_datetime_fallback with
utc_or_local set to :local.
DEPRECATED: Use +Time#utc+ or +Time#local+ instead.
Returns a new Time if requested year can be accommodated by Ruby's Time class (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture); otherwise returns a DateTime.
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 34 def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0) ActiveSupport::Deprecation.warn 'time_with_datetime_fallback is deprecated. Use Time#utc or Time#local instead', caller time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec) # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138. if time.year == year time else ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec) end rescue ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec) end
Allows override of Time.zone locally inside supplied block;
resets Time.zone to existing value when done.
DEPRECATED: Use +Time#utc+ instead.
Wraps class method time_with_datetime_fallback with
utc_or_local set to :utc.
Returns the TimeZone for the current request, if this has been set (via ::zone=). If Time.zone
has not been set for the current request, returns the TimeZone specified in
config.time_zone.
Sets Time.zone to a TimeZone object for the current
request/thread.
This method accepts any of the following:
-
A Rails TimeZone object.
-
An identifier for a Rails TimeZone object (e.g., “Eastern Time (US & Canada)”,
-5.hours). -
A TZInfo::Timezone object.
-
An identifier for a TZInfo::Timezone object (e.g., “America/New_York”).
Here's an example of how you might set Time.zone on a per
request basis and reset it when the request is done.
current_user.time_zone just needs to return a string
identifying the user's preferred time zone:
class ApplicationController < ActionController::Base
around_filter :set_time_zone
def set_time_zone
if logged_in?
Time.use_zone(current_user.time_zone) { yield }
else
yield
end
end
end
Duck-types as a Time-like class. See Object#acts_like?.
Uses Date to provide precise Time calculations for years, months, and days. The
options parameter takes a hash with any of these keys:
:years, :months, :weeks,
:days, :hours, :minutes,
:seconds.
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 134 def advance(options) unless options[:weeks].nil? options[:weeks], partial_weeks = options[:weeks].divmod(1) options[:days] = options.fetch(:days, 0) + 7 * partial_weeks end unless options[:days].nil? options[:days], partial_days = options[:days].divmod(1) options[:hours] = options.fetch(:hours, 0) + 24 * partial_days end d = to_date.advance(options) time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day) seconds_to_advance = options.fetch(:seconds, 0) + options.fetch(:minutes, 0) * 60 + options.fetch(:hours, 0) * 3600 if seconds_to_advance.zero? time_advanced_by_date else time_advanced_by_date.since(seconds_to_advance) end end
Returns a Range representing the whole week of the
current time. Week starts on start_day, default is
Date.week_start or config.week_start when set.
Returns a new Time representing the start of the hour (x:00)
Returns a new Time representing the start of the minute (x:xx:00)
Returns a new Time where one or more of the
elements have been changed according to the options parameter.
The time options (:hour, :min, :sec,
:usec) reset cascadingly, so if only the hour is passed, then
minute, sec, and usec is set to 0. If the hour and minute is passed, then
sec and usec is set to 0. The options parameter takes a hash
with any of these keys: :year, :month,
:day, :hour, :min,
:sec, :usec.
Time.new(2012, 8, 29, 22, 35, 0).change(day: 1) # => Time.new(2012, 8, 1, 22, 35, 0)
Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1) # => Time.new(1981, 8, 1, 22, 35, 0)
Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 112 def change(options) new_year = options.fetch(:year, year) new_month = options.fetch(:month, month) new_day = options.fetch(:day, day) new_hour = options.fetch(:hour, hour) new_min = options.fetch(:min, options[:hour] ? 0 : min) new_sec = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000)) if utc? ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec) elsif zone ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec) else ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset) end end
Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances can be chronologically compared with a Time
Returns a new Time representing the end of the day, 23:59:59.999999 (.999999999 in ruby1.9)
Returns a new Time representing the end of the hour, x:59:59.999999 (.999999999 in ruby1.9)
Returns a new Time representing the end of the minute, x:xx:59.999999 (.999999999 in ruby1.9)
Layers additional behavior on #eql? so that ActiveSupport::TimeWithZone instances can be eql? to an equivalent Time
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 294 def eql_with_coercion(other) # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison other = other.comparable_time if other.respond_to?(:comparable_time) eql_without_coercion(other) end
Returns the UTC offset as an +HH:MM formatted string.
Time.local(2000).formatted_offset # => "-06:00"
Time.local(2000).formatted_offset(false) # => "-0600"
Returns the simultaneous time in Time.zone.
Time.zone = 'Hawaii' # => 'Hawaii'
Time.utc(2000).in_time_zone # => Fri, 31 Dec 1999 14:00:00 HST -10:00
This method is similar to Time#localtime, except that it uses
Time.zone as the local zone instead of the operating
system's time zone.
You can also pass in a TimeZone instance or string that identifies a
TimeZone as an argument, and the conversion will be based on that zone
instead of Time.zone.
Time.utc(2000).in_time_zone('Alaska') # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
Time#- can also be used to determine the number of seconds between two Time instances. We're layering on additional behavior so that ActiveSupport::TimeWithZone instances are coerced into values that Time#- will recognize
Seconds since midnight: Time.now.seconds_since_midnight
Returns the number of seconds until 23:59:59.
Time.new(2012, 8, 29, 0, 0, 0).seconds_until_end_of_day # => 86399
Time.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
Time.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
Returns a new Time representing the time a number of seconds since the instance time
Converts to a formatted string. See DATE_FORMATS for builtin formats.
This method is aliased to to_s.
time = Time.now # => Thu Jan 18 06:10:17 CST 2007
time.to_formatted_s(:time) # => "06:10"
time.to_s(:time) # => "06:10"
time.to_formatted_s(:db) # => "2007-01-18 06:10:17"
time.to_formatted_s(:number) # => "20070118061017"
time.to_formatted_s(:short) # => "18 Jan 06:10"
time.to_formatted_s(:long) # => "January 18, 2007 06:10"
time.to_formatted_s(:long_ordinal) # => "January 18th, 2007 06:10"
time.to_formatted_s(:rfc822) # => "Thu, 18 Jan 2007 06:10:17 -0600"
Adding your own time formats to to_formatted_s
You can add your own formats to the Time::DATE_FORMATS hash. Use the format name as the hash key and either a strftime string or Proc instance that takes a time argument as the value.
# config/initializers/time_formats.rb
Time::DATE_FORMATS[:month_and_year] = '%B %Y'
Time::DATE_FORMATS[:short_ordinal] = ->(time) { time.strftime("%B #{time.day.ordinalize}") }