Class | ActiveSupport::TimeWithZone
In: | lib/active_support/time_with_zone.rb
Parent: | Object

A Time-like class that can represent a time in any time zone. Necessary because standard Ruby Time instances are limited to UTC and the system‘s `ENV[‘TZ’]` zone.

You shouldn‘t ever need to create a TimeWithZone instance directly via `new` — instead, Rails provides the methods `local`, `parse`, `at` and `now` on TimeZone instances, and `in_time_zone` on Time and DateTime instances, for a more user-friendly syntax. Examples:

      Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
      Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
      Time.zone.parse('2007-02-01 15:30:45')          # => Sat, 10 Feb 2007 15:30:45 EST -05:00
      Time.zone.at(1170361845)                        # => Sat, 10 Feb 2007 15:30:45 EST -05:00
      Time.zone.now                                   # => Sun, 18 May 2008 13:07:55 EDT -04:00
      Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45 EST -05:00

See TimeZone and ActiveSupport::CoreExtensions::Time::Zones for further documentation for these methods.

TimeWithZone instances implement the same API as Ruby Time instances, so that Time and TimeWithZone instances are interchangable. Examples:

      t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25 EDT -04:00
      t.hour                                # => 13
      t.dst?                                # => true
      t.utc_offset                          # => -14400
      t.zone                                # => "EDT"
      t.to_s(:rfc822)                       # => "Sun, 18 May 2008 13:27:25 -0400"
      t + 1.day                             # => Mon, 19 May 2008 13:27:25 EDT -04:00
      t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00 EST -05:00
      t > Time.utc(1999)                    # => true
      t.is_a?(Time)                         # => true
      t.is_a?(ActiveSupport::TimeWithZone)  # => true

### Methods

+ - <=> acts_like_time? advance ago between? comparable_time dst? eql? formatted_offset freeze getgm getlocal getutc gmt? gmt_offset gmtime gmtoff hash httpdate in_time_zone inspect is_a? isdst iso8601 kind_of? localtime marshal_dump marshal_load method_missing new period respond_to? rfc2822 rfc822 since strftime time to_a to_datetime to_f to_i to_json to_s to_time to_yaml tv_sec usec utc utc? utc_offset xmlschema zone

### Included Modules

Comparable

### Attributes

time_zone | [R] |

### Public Class methods

new(utc_time, time_zone, local_time = nil, period = nil)

### Public Instance methods

+(other)

If wrapped `time` is a DateTime, use DateTime#since instead of `+`. Otherwise, just pass on to `method_missing`.

-(other)

If a time-like object is passed in, compare it with `utc`. Else if wrapped `time` is a DateTime, use DateTime#ago instead of DateTime#-. Otherwise, just pass on to `method_missing`.

<=>(other)

Use the time in UTC for comparisons.

acts_like_time?()

So that `self` `acts_like?(:time)`.

advance(options)
ago(other)
between?(min, max)
comparable_time()

Alias for utc

dst?()
eql?(other)
formatted_offset(colon = true, alternate_utc_string = nil)
freeze()

Neuter freeze because freezing can cause problems with lazy loading of attributes.

getgm()

Alias for utc

getlocal()

Alias for localtime

getutc()

Alias for utc

gmt?()

Alias for utc?

gmt_offset()

Alias for utc_offset

gmtime()

Alias for utc

gmtoff()

Alias for utc_offset

hash()

Alias for to_i

httpdate()
in_time_zone(new_zone = ::Time.zone)

Returns the simultaneous time in `Time.zone`, or the specified zone.

inspect()
is_a?(klass)

Say we‘re a Time to thwart type checking.

isdst()

Alias for dst?

iso8601()

Alias for xmlschema

kind_of?(klass)

Alias for is_a?

localtime()

Returns a `Time.local()` instance of the simultaneous time in your system‘s `ENV[‘TZ’]` zone

marshal_dump()
marshal_load(variables)
method_missing(sym, *args, &block)

Send the missing method to `time` instance, and wrap result in a new TimeWithZone with the existing `time_zone`.

period()

Returns the underlying TZInfo::TimezonePeriod.

respond_to?(sym, include_priv = false)

Ensure proxy class responds to all methods that underlying time instance responds to.

rfc2822()
rfc822()

Alias for rfc2822

since(other)
strftime(format)

Replaces `%Z` and `%z` directives with `zone` and `formatted_offset`, respectively, before passing to Time#strftime, so that zone information is correct

time()

Returns a Time or DateTime instance that represents the time in `time_zone`.

to_a()
to_datetime()
to_f()
to_i()
to_json(options = nil)
to_s(format = :default)

`:db` format outputs time in UTC; all others output time in local. Uses TimeWithZone‘s `strftime`, so `%Z` and `%z` work correctly.

to_time()

A TimeWithZone acts like a Time, so just return `self`.

to_yaml(options = {})
tv_sec()

Alias for to_i

usec()
utc()

Returns a Time or DateTime instance that represents the time in UTC.

utc?()
utc_offset()
xmlschema()
zone()

Time uses `zone` to display the time zone abbreviation, so we‘re duck-typing it.

[Validate]