Time (original) (raw)

Methods

A

B

C

D

E

F

I

L

M

N

P

S

T

U

W

Y

Z

Constants

COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
DATE_FORMATS = { :db => "%Y-%m-%d %H:%M:%S", :number => "%Y%m%d%H%M%S", :time => "%H:%M", :short => "%d %b %H:%M", :long => "%B %d, %Y %H:%M", :long_ordinal => lambda { |time time.strftime("%B #{ActiveSupport::Inflector.ordinalize(time.day)}, %Y %H:%M") }, :rfc822 => lambda {

Attributes

Class Public methods

===(other)

Source: show

def ===(other) super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone)) end

_load(marshaled_time)

Source: show

def _load(marshaled_time) time = _load_without_utc_flag(marshaled_time) time.instance_eval do if defined?(@marshal_with_utc_coercion) val = remove_instance_variable("@marshal_with_utc_coercion") end val ? utc : self end end

_load_without_utc_flag(marshaled_time)

_load_without_zone(marshaled_time)

current()

Returns Time.zone.now when Time.zone orconfig.time_zone are set, otherwise just returnsTime.now.

Source: show

def current ::Time.zone ? ::Time.zone.now : ::Time.now end

days_in_month(month, year = now.year)

Return the number of days in the given month. If no year is specified, it will use the current year.

Source: show

def days_in_month(month, year = now.year) return 29 if month == 2 && ::Date.gregorian_leap?(year) COMMON_YEAR_DAYS_IN_MONTH[month] end

find_zone(time_zone)

Source: show

def find_zone(time_zone) find_zone!(time_zone) rescue nil end

find_zone!(time_zone)

Returns a TimeZone instance or nil, or raises an ArgumentError for invalid timezones.

Source: show

def find_zone!(time_zone) return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)

unless time_zone.respond_to?(:period_for_local) time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone) end

time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone) rescue TZInfo::InvalidTimezoneIdentifier raise ArgumentError, "Invalid Timezone: #{time_zone}" end

local_time(*args)

Wraps class method time_with_datetime_fallback withutc_or_local set to :local.

Source: show

def local_time(*args) time_with_datetime_fallback(:local, *args) end

time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)

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.

Source: show

def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0) time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)

time.year == year ? time : ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec) rescue ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec) end

use_zone(time_zone)

Allows override of Time.zone locally inside supplied block; resets Time.zone to existing value when done.

Source: show

def use_zone(time_zone) new_zone = find_zone!(time_zone) begin old_zone, ::Time.zone = ::Time.zone, new_zone yield ensure ::Time.zone = old_zone end end

utc_time(*args)

Wraps class method time_with_datetime_fallback withutc_or_local set to :utc.

Source: show

def utc_time(*args) time_with_datetime_fallback(:utc, *args) end

zone()

Returns the TimeZone for the current request, if this has been set (via ::zone=). If Time.zonehas not been set for the current request, returns the TimeZone specified inconfig.time_zone.

Source: show

def zone Thread.current[:time_zone] || zone_default end

zone=(time_zone)

Sets Time.zone to a TimeZone object for the current request/thread.

This method accepts any of the following:

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 old_time_zone = Time.zone Time.zone = current_user.time_zone if logged_in? yield ensure Time.zone = old_time_zone end end

Source: show

def zone=(time_zone) Thread.current[:time_zone] = find_zone!(time_zone) end

Instance Public methods

_dump(*args)

Source: show

def _dump(*args) obj = dup obj.instance_variable_set('@marshal_with_utc_coercion', utc?) obj._dump_without_utc_flag(*args) end

_dump_without_utc_flag(*args)

_dump_without_zone(*args)

acts_like_time?()

Source: show

def acts_like_time? true end

advance(options)

Uses Date to provide precise Time calculations for years, months, and days. Theoptions parameter takes a hash with any of these keys::years, :months, :weeks,:days, :hours, :minutes,:seconds.

Source: show

def advance(options) unless options[:weeks].nil? options[:weeks], partial_weeks = options[:weeks].divmod(1) options[:days] = (options[:days] || 0) + 7 * partial_weeks end

unless options[:days].nil? options[:days], partial_days = options[:days].divmod(1) options[:hours] = (options[: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[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600 seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance) end

ago(seconds)

Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension

Source: show

def ago(seconds) since(-seconds) end

at_beginning_of_quarter()

beginning_of_day()

Returns a new Time representing the start of the day (0:00)

Source: show

def beginning_of_day

change(:hour => 0) end

beginning_of_month()

Returns a new Time representing the start of the month (1st of the month, 0:00)

Source: show

def beginning_of_month

change(:day => 1, :hour => 0) end

beginning_of_quarter()

Returns a new Time representing the start of the quarter (1st of january, april, july, october, 0:00)

Source: show

def beginning_of_quarter beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= month }) end

beginning_of_week()

Returns a new Time representing the “start” of this week (Monday, 0:00)

Source: show

def beginning_of_week days_to_monday = wday!=0 ? wday-1 : 6 (self - days_to_monday.days).midnight end

beginning_of_year()

Returns a new Time representing the start of the year (1st of january, 0:00)

Source: show

def beginning_of_year change(:month => 1, :day => 1, :hour => 0) end

change(options)

Returns a new Time where one or more of the elements have been changed according to the options parameter. The time options (hour, minute, 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.

Source: show

def change(options) ::Time.send( utc? ? :utc_time : :local_time, options[:year] || year, options[:month] || month, options[:day] || day, options[:hour] || hour, options[:min] || (options[:hour] ? 0 : min), options[:sec] || ((options[:hour] || options[:min]) ? 0 : sec), options[:usec] || ((options[:hour] || options[:min] || options[:sec]) ? 0 : usec) ) end

compare_with_coercion(other)

Also aliased as: <=>

Source: show

def compare_with_coercion(other)

other.is_a?(Time) ? compare_without_coercion(other.to_time) : to_datetime <=> other end

compare_without_coercion(other)

end_of_day()

Returns a new Time representing the end of the day, 23:59:59.999999 (.999999999 in ruby1.9)

Source: show

def end_of_day change(:hour => 23, :min => 59, :sec => 59, :usec => 999999.999) end

end_of_month()

Returns a new Time representing the end of the month (end of the last day of the month)

Source: show

def end_of_month

last_day = ::Time.days_in_month(month, year) change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999) end

end_of_quarter()

Returns a new Time representing the end of the quarter (end of the last day of march, june, september, december)

Source: show

def end_of_quarter beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= month }).end_of_month end

end_of_week()

Returns a new Time representing the end of this week, (end of Sunday)

Source: show

def end_of_week days_to_sunday = wday!=0 ? 7-wday : 0 (self + days_to_sunday.days).end_of_day end

end_of_year()

Returns a new Time representing the end of the year (end of the 31st of december)

Source: show

def end_of_year change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999) end

formatted_offset(colon = true, alternate_utc_string = nil)

Returns the UTC offset as an +HH:MM formatted string.

Time.local(2000).formatted_offset
Time.local(2000).formatted_offset(false)

Source: show

def formatted_offset(colon = true, alternate_utc_string = nil) utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon) end

future?()

Tells whether the Time object’s time lies in the future

Source: show

def future? self > ::Time.current end

in_time_zone(zone = ::Time.zone)

Returns the simultaneous time in Time.zone.

Time.zone = 'Hawaii'
Time.utc(2000).in_time_zone

This method is similar to Time#localtime, except that it usesTime.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')

Source: show

def in_time_zone(zone = ::Time.zone) return self unless zone

ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone)) end

minus_with_coercion(other)

Time#- can also be used to determine the number of seconds between two Time instances. We’re layering on additional behavior so that ActiveSupport::TimeWithZoneinstances are coerced into values that Time#- will recognize

Also aliased as: -

Source: show

def minus_with_coercion(other) other = other.comparable_time if other.respond_to?(:comparable_time) other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other) end

minus_without_coercion(other)

minus_without_duration(other)

months_ago(months)

Returns a new Time representing the time a number of specified months ago

Source: show

def months_ago(months) advance(:months => -months) end

months_since(months)

Returns a new Time representing the time a number of specified months in the future

Source: show

def months_since(months) advance(:months => months) end

next_month()

Source: show

def next_month months_since(1) end

next_week(day = :monday)

Returns a new Time representing the start of the given day in next week (default is Monday).

Source: show

def next_week(day = :monday) since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0) end

next_year()

Source: show

def next_year years_since(1) end

past?()

Tells whether the Time object’s time lies in the past

Source: show

def past? self < ::Time.current end

prev_month()

Source: show

def prev_month months_ago(1) end

prev_week(day = :monday)

Returns a new Time representing the start of the given day in the previous week (default is Monday).

Source: show

def prev_week(day = :monday) ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0) end

prev_year()

Source: show

def prev_year years_ago(1) end

seconds_since_midnight()

Source: show

def seconds_since_midnight to_i - change(:hour => 0).to_i + (usec / 1.0e+6) end

since(seconds)

Returns a new Time representing the time a number of seconds since the instance time

Also aliased as: in

Source: show

def since(seconds) self + seconds rescue to_datetime.since(seconds) end

to_date()

Converts a Time object to a Date, dropping hour, minute, and second precision.

my_time = Time.now
my_time.to_date

your_time = Time.parse("1/13/2009 1:13:03 P.M.")
your_time.to_date

Source: show

def to_date ::Date.new(year, month, day) end

to_datetime()

Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.

my_time = Time.now
my_time.to_datetime

your_time = Time.parse("1/13/2009 1:13:03 P.M.")
your_time.to_datetime

Source: show

def to_datetime ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400)) end

to_default_s(format = :default)

to_formatted_s(format = :default)

Converts to a formatted string. See DATE_FORMATS for builtin formats.

This method is aliased to to_s.

time = Time.now

time.to_formatted_s(:time)
time.to_s(:time)

time.to_formatted_s(:db)
time.to_formatted_s(:number)
time.to_formatted_s(:short)
time.to_formatted_s(:long)
time.to_formatted_s(:long_ordinal)
time.to_formatted_s(:rfc822)

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.

Time::DATE_FORMATS[:month_and_year] = "%B %Y" Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }

Also aliased as: to_s

Source: show

def to_formatted_s(format = :default) if formatter = DATE_FORMATS[format] formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter) else to_default_s end end

to_time()

A method to keep Time, Dateand DateTime instances interchangeable on conversions. In this case, it simply returns self.

today?()

Tells whether the Time object’s time is today

Source: show

def today? to_date == ::Date.current end

tomorrow()

Convenience method which returns a new Timerepresenting the time 1 day since the instance time

Source: show

def tomorrow advance(:days => 1) end

weeks_ago(weeks)

Returns a new Time representing the time a number of specified weeks ago.

Source: show

def weeks_ago(weeks) advance(:weeks => -weeks) end

years_ago(years)

Returns a new Time representing the time a number of specified years ago

Source: show

def years_ago(years) advance(:years => -years) end

years_since(years)

Returns a new Time representing the time a number of specified years in the future

Source: show

def years_since(years) advance(:years => years) end

yesterday()

Convenience method which returns a new Timerepresenting the time 1 day ago

Source: show

def yesterday advance(:days => -1) end