Skip to Content Skip to Search

class Time

Inherits From

Constants

[nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
{
db: "%Y-%m-%d %H:%M:%S",
inspect: "%Y-%m-%d %H:%M:%S.%9N %z",
number: "%Y%m%d%H%M%S",
nsec: "%Y%m%d%H%M%S%9N",
usec: "%Y%m%d%H%M%S%6N",
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}")
},
iso8601: lambda { |time| time.iso8601 }
}

Attributes

[RW] zone_default

Public class methods

Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 18
def ===(other)
  super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
end

Also aliased as: at_without_coercion.

Alias for: at_with_coercion.

Also aliased as: at.

Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime instances can be used when called with a single argument

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 45
def at_with_coercion(time_or_number, *args)
  if args.empty?
    if time_or_number.is_a?(ActiveSupport::TimeWithZone)
      at_without_coercion(time_or_number.to_r).getlocal
    elsif time_or_number.is_a?(DateTime)
      at_without_coercion(time_or_number.to_f).getlocal
    else
      at_without_coercion(time_or_number)
    end
  else
    at_without_coercion(time_or_number, *args)
  end
end

Alias for: at.

Returns Time.zone.now when Time.zone or config.time_zone are set, otherwise just returns Time.now.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 39
def current
  ::Time.zone ? ::Time.zone.now : ::Time.now
end

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 24
def days_in_month(month, year = current.year)
  if month == 2 && ::Date.gregorian_leap?(year)
    29
  else
    COMMON_YEAR_DAYS_IN_MONTH[month]
  end
end

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 34
def days_in_year(year = current.year)
  days_in_month(2, year) + 337
end

Returns a TimeZone instance matching the time zone provided. Accepts the time zone in any format supported by Time.zone=. Returns nil for invalid time zones.

Time.find_zone "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
Time.find_zone "NOT-A-TIMEZONE"   # => nil
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 93
def find_zone(time_zone)
  find_zone!(time_zone) rescue nil
end

Returns a TimeZone instance matching the time zone provided. Accepts the time zone in any format supported by Time.zone=. Raises an ArgumentError for invalid time zones.

Time.find_zone! "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
Time.find_zone! "EST"              # => #<ActiveSupport::TimeZone @name="EST" ...>
Time.find_zone! -5.hours           # => #<ActiveSupport::TimeZone @name="Bogota" ...>
Time.find_zone! nil                # => nil
Time.find_zone! false              # => false
Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 81
def find_zone!(time_zone)
  return time_zone unless time_zone

  ActiveSupport::TimeZone[time_zone] || raise(ArgumentError, "Invalid Timezone: #{time_zone}")
end

Creates a Time instance from an RFC 3339 string.

Time.rfc3339('1999-12-31T14:00:00-10:00') # => 2000-01-01 00:00:00 -1000

If the time or offset components are missing then an ArgumentError will be raised.

Time.rfc3339('1999-12-31') # => ArgumentError: invalid date
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 69
def rfc3339(str)
  parts = Date._rfc3339(str)

  raise ArgumentError, "invalid date" if parts.empty?

  Time.new(
    parts.fetch(:year),
    parts.fetch(:mon),
    parts.fetch(:mday),
    parts.fetch(:hour),
    parts.fetch(:min),
    parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
    parts.fetch(:offset)
  )
end

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

class ApplicationController < ActionController::Base
  around_action :set_time_zone

  private
    def set_time_zone
      Time.use_zone(current_user.timezone) { yield }
    end
end

NOTE: This won’t affect any ActiveSupport::TimeWithZone objects that have already been created, e.g. any model timestamp attributes that have been read before the block will remain in the application’s default timezone.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 61
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

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 14
def zone
  ::ActiveSupport::IsolatedExecutionState[:time_zone] || zone_default
end

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_action :set_time_zone

  def set_time_zone
    if logged_in?
      Time.use_zone(current_user.time_zone) { yield }
    else
      yield
    end
  end
end
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/zones.rb, line 41
def zone=(time_zone)
  ::ActiveSupport::IsolatedExecutionState[:time_zone] = find_zone!(time_zone)
end

Public instance methods

Also aliased as: minus_without_duration, minus_without_coercion.

Alias for: minus_with_coercion.

Also aliased as: compare_without_coercion.

Alias for: compare_with_coercion.

Uses Date to provide precise Time calculations for years, months, and days according to the proleptic Gregorian calendar. The options parameter takes a hash with any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.

Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700

Just like Date#advance, increments are applied in order of time units from largest to smallest. This order can affect the result around the end of a month.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 187
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.gregorian.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 new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 213
def ago(seconds)
  since(-seconds)
end

Alias for: beginning_of_day.

Alias for: beginning_of_hour.

Alias for: beginning_of_minute.

Alias for: end_of_day.

Alias for: end_of_hour.

Alias for: end_of_minute.

Alias for: middle_of_day.

Alias for: middle_of_day.

Alias for: beginning_of_day.

Alias for: middle_of_day.

Also aliased as: midnight, at_midnight, at_beginning_of_day.

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 226
def beginning_of_day
  change(hour: 0)
end

Also aliased as: at_beginning_of_hour.

Returns a new Time representing the start of the hour (x:00)

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 255
def beginning_of_hour
  change(min: 0)
end

Also aliased as: at_beginning_of_minute.

Returns a new Time representing the start of the minute (x:xx:00)

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 271
def beginning_of_minute
  change(sec: 0)
end

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, :nsec) reset cascadingly, so if only the hour is passed, then minute, sec, usec, and nsec is set to 0. If the hour and minute is passed, then sec, usec, and nsec is set to 0. The options parameter takes a hash with any of these keys: :year, :month, :day, :hour, :min, :sec, :usec, :nsec, :offset. Pass either :usec or :nsec, not both.

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)
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 123
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_offset = options.fetch(:offset, nil)

  if new_nsec = options[:nsec]
    raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
    new_usec = Rational(new_nsec, 1000)
  else
    new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
  end

  raise ArgumentError, "argument out of range" if new_usec >= 1000000

  new_sec += Rational(new_usec, 1000000)

  if new_offset
    ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
  elsif utc?
    ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
  elsif zone.respond_to?(:utc_to_local)
    new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)

    # When there are two occurrences of a nominal time due to DST ending,
    # `Time.new` chooses the first chronological occurrence (the one with a
    # larger UTC offset). However, for `change`, we want to choose the
    # occurrence that matches this time's UTC offset.
    #
    # If the new time's UTC offset is larger than this time's UTC offset, the
    # new time might be a first chronological occurrence. So we add the offset
    # difference to fast-forward the new time, and check if the result has the
    # desired UTC offset (i.e. is the second chronological occurrence).
    offset_difference = new_time.utc_offset - utc_offset
    if offset_difference > 0 && (new_time_2 = new_time + offset_difference).utc_offset == utc_offset
      new_time_2
    else
      new_time
    end
  elsif zone
    ::Time.local(new_sec, new_min, new_hour, new_day, new_month, new_year, nil, nil, isdst, nil)
  else
    ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
  end
end

Also aliased as: <=>.

Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances can be chronologically compared with a Time

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 317
def compare_with_coercion(other)
  # we're avoiding Time#to_datetime and Time#to_time because they're expensive
  if other.class == Time
    compare_without_coercion(other)
  elsif other.is_a?(Time)
    compare_without_coercion(other.to_time)
  else
    to_datetime <=> other
  end
end

Alias for: <=>.

Also aliased as: at_end_of_day.

Returns a new Time representing the end of the day, 23:59:59.999999

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 244
def end_of_day
  change(
    hour: 23,
    min: 59,
    sec: 59,
    usec: Rational(999999999, 1000)
  )
end

Also aliased as: at_end_of_hour.

Returns a new Time representing the end of the hour, x:59:59.999999

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 261
def end_of_hour
  change(
    min: 59,
    sec: 59,
    usec: Rational(999999999, 1000)
  )
end

Also aliased as: at_end_of_minute.

Returns a new Time representing the end of the minute, x:xx:59.999999

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 277
def end_of_minute
  change(
    sec: 59,
    usec: Rational(999999999, 1000)
  )
end

Also aliased as: eql_without_coercion.

Alias for: eql_with_coercion.

Also aliased as: eql?.

Layers additional behavior on Time#eql? so that ActiveSupport::TimeWithZone instances can be eql? to an equivalent Time

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 332
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

Alias for: eql?.

Returns a formatted string of the offset from UTC, or an alternative string if the time zone is already UTC.

Time.local(2000).formatted_offset        # => "-06:00"
Time.local(2000).formatted_offset(false) # => "-0600"
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/conversions.rb, line 69
def formatted_offset(colon = true, alternate_utc_string = nil)
  utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
end

Alias for: since.

Alias for: middle_of_day.

Also aliased as: midday, noon, at_midday, at_noon, at_middle_of_day.

Returns a new Time representing the middle of the day (12:00)

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 234
def middle_of_day
  change(hour: 12)
end

Alias for: beginning_of_day.

Also aliased as: -.

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 308
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

Alias for: -.

Alias for: -.

Returns a new time the specified number of days in the future.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 346
def next_day(days = 1)
  advance(days: days)
end

Returns a new time the specified number of months in the future.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 356
def next_month(months = 1)
  advance(months: months)
end

Returns a new time the specified number of years in the future.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 366
def next_year(years = 1)
  advance(years: years)
end

Alias for: middle_of_day.

Returns a new time the specified number of days ago.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 341
def prev_day(days = 1)
  advance(days: -days)
end

Returns a new time the specified number of months ago.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 351
def prev_month(months = 1)
  advance(months: -months)
end

Returns a new time the specified number of years ago.

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 361
def prev_year(years = 1)
  advance(years: -years)
end

Returns the fraction of a second as a Rational

Time.new(2012, 8, 29, 0, 0, 0.5).sec_fraction # => (1/2)
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 107
def sec_fraction
  subsec
end

Returns the number of seconds since 00:00:00.

Time.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0.0
Time.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296.0
Time.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399.0
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 91
def seconds_since_midnight
  to_i - change(hour: 0).to_i + (usec / 1.0e+6)
end

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
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 100
def seconds_until_end_of_day
  end_of_day.to_i - to_i
end

Also aliased as: in.

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

Source code GitHub
# File activesupport/lib/active_support/core_ext/time/calculations.rb, line 218
def since(seconds)
  self + seconds
rescue
  to_datetime.since(seconds)
end

Alias for: to_fs.

Also aliased as: to_formatted_s.

Converts to a formatted string. See DATE_FORMATS for built-in formats.

This method is aliased to to_formatted_s.

time = Time.now                    # => 2007-01-18 06:10:17 -06:00

time.to_fs(:time)                  # => "06:10"
time.to_formatted_s(:time)         # => "06:10"

time.to_fs(:db)           # => "2007-01-18 06:10:17"
time.to_fs(:number)       # => "20070118061017"
time.to_fs(:short)        # => "18 Jan 06:10"
time.to_fs(:long)         # => "January 18, 2007 06:10"
time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"

Adding your own time formats to to_fs

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}") }
Source code GitHub
# File activesupport/lib/active_support/core_ext/time/conversions.rb, line 53
def to_fs(format = :default)
  if formatter = DATE_FORMATS[format]
    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
  else
    to_s
  end
end

Definition files