Active Support Time With Zone¶ ↑

# File activesupport/lib/active_support/time_with_zone.rb, line 56
def initialize(utc_time, time_zone, local_time = nil, period = nil)
  @time_zone, @time = time_zone, local_time
  if utc_time
    @utc = transfer_time_values_to_utc_constructor(utc_time)
    @period = period
  else
    @utc = nil
    @period = get_period_and_ensure_valid_local_time(period)
  end
  @is_utc = nil
end

# File activesupport/lib/active_support/time_with_zone.rb, line 344
def +(other)
  if duration_of_variable_length?(other)
    method_missing(:+, other)
  else
    result = utc + other

    result.in_time_zone(time_zone)
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 385
def -(other)
  if other.acts_like?(:time)
    getutc - other.getutc
  elsif duration_of_variable_length?(other)
    method_missing(:-, other)
  else
    result = utc - other
    result.in_time_zone(time_zone)
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 273
def <=>(other)
  utc <=> other
end

# File activesupport/lib/active_support/time_with_zone.rb, line 578
def acts_like_time?
  true
end

# File activesupport/lib/active_support/time_with_zone.rb, line 482
def advance(options)
  # If we're advancing a value of variable length (i.e., years, weeks, months, days), advance from #time,
  # otherwise advance from #utc, for accuracy when moving across DST boundaries
  if options.values_at(:years, :weeks, :months, :days).any?
    method_missing(:advance, options)
  else
    utc.advance(options).in_time_zone(time_zone)
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 417
def ago(other)
  since(-other)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 200
def as_json(options = nil)
  if ActiveSupport::JSON::Encoding.use_standard_json_time_format
    xmlschema(ActiveSupport::JSON::Encoding.time_precision).force_encoding(Encoding::UTF_8)
  else
    %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 281
def between?(min, max)
  utc.between?(min, max)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 589
def blank?
  false
end

# File activesupport/lib/active_support/time_with_zone.rb, line 440
def change(options)
  if options[:zone] && options[:offset]
    raise ArgumentError, "Can't change both :offset and :zone at the same time: #{options.inspect}"
  end

  new_time = time.change(options)

  if options[:zone]
    new_zone = ::Time.find_zone(options[:zone])
  elsif options[:offset]
    new_zone = ::Time.find_zone(new_time.utc_offset)
  end

  new_zone ||= time_zone
  periods = new_zone.periods_for_local(new_time)

  self.class.new(nil, new_zone, new_time, periods.include?(period) ? period : nil)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 498
    def day = time.day

    def mday = time.mday

    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] 

# File activesupport/lib/active_support/time_with_zone.rb, line 107
def dst?
  period.dst?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 657
def duration_of_variable_length?(obj)
  ActiveSupport::Duration === obj && obj.variable?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 316
def eql?(other)
  other.eql?(utc)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 145
def formatted_offset(colon = true, alternate_utc_string = nil)
  utc? && alternate_utc_string || TimeZone.seconds_to_utc_offset(utc_offset, colon)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 597
def freeze
  # preload instance variables before freezing
  period; utc; time; utc?; to_datetime; to_time
  super
end

# File activesupport/lib/active_support/time_with_zone.rb, line 311
def future?
  utc.future?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 638
def get_period_and_ensure_valid_local_time(period)
  # we don't want a Time.local instance enforcing its own DST rules as well,
  # so transfer time values to a utc constructor if necessary
  @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
  begin
    period || @time_zone.period_for_local(@time)
  rescue ::TZInfo::PeriodNotFound
    # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
    @time += 1.hour
    retry
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 320
def hash
  utc.hash
end

# File activesupport/lib/active_support/time_with_zone.rb, line 506
    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
YAML.dump_tags[

# File activesupport/lib/active_support/time_with_zone.rb, line 222
def httpdate
  utc.httpdate
end

# File activesupport/lib/active_support/time_with_zone.rb, line 88
def in_time_zone(new_zone = ::Time.zone)
  return self if time_zone == new_zone
  utc.in_time_zone(new_zone)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 628
def incorporate_utc_offset(time, offset)
  if offset.zero?
    time
  elsif time.kind_of?(Date)
    time + Rational(offset, SECONDS_PER_DAY)
  else
    time + offset
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 164
def inspect
  "#{time.strftime('%F %H:%M:%S.%9N')} #{zone} #{formatted_offset}"
end

# File activesupport/lib/active_support/time_with_zone.rb, line 583
def is_a?(klass)
  klass == ::Time || super
end

# File activesupport/lib/active_support/time_with_zone.rb, line 94
def localtime(utc_offset = nil)
  utc.getlocal(utc_offset)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 603
def marshal_dump
  [utc, time_zone.name, time]
end

# File activesupport/lib/active_support/time_with_zone.rb, line 607
def marshal_load(variables)
  initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 500
    def mday = time.mday

    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = 

# File activesupport/lib/active_support/time_with_zone.rb, line 619
def method_missing(...)
  wrap_with_time_zone time.__send__(...)
rescue NoMethodError => e
  raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
end

# File activesupport/lib/active_support/time_with_zone.rb, line 508
    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
YAML.dump_tags[ActiveSupport::

# File activesupport/lib/active_support/time_with_zone.rb, line 494
    def mon = time.mon

    def month = time.month

    def day = time.day

    def mday = time.mday

    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags

# File activesupport/lib/active_support/time_with_zone.rb, line 496
    def month = time.month

    def day = time.day

    def mday = time.mday

    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"

# File activesupport/lib/active_support/time_with_zone.rb, line 514
    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 286
def past?
  utc.past?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 83
def period
  @period ||= time_zone.period_for_utc(@utc)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 613
def respond_to_missing?(sym, include_priv)
  time.respond_to?(sym, include_priv)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 232
def rfc2822
  to_fs(:rfc822)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 510
    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
YAML.dump_tags[ActiveSupport::TimeWithZone]

# File activesupport/lib/active_support/time_with_zone.rb, line 267
def strftime(format)
  format = format.gsub(/((?:\A|[^%])(?:%%)*)%Z/, "\\1#{zone}") if format.include?("%Z")
  getlocal(utc_offset).strftime(format)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 69
def time
  @time ||= incorporate_utc_offset(@utc, utc_offset)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 525
def to_a
  [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
end

# File activesupport/lib/active_support/time_with_zone.rb, line 516
  def to_date = time.to_date

  # Returns Array of parts of Time in sequence of
  # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
  #
  # ```
  # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
  # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
  # ```
  def to_a
    [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
  end

  # Returns the object's date and time as a floating-point number of seconds
  # since the Epoch (January 1, 1970 00:00 UTC).
  #
  # ```
  # Time.zone.now.to_f # => 1417709320.285418
  # ```
  def to_f
    utc.to_f
  end

  # Returns the object's date and time as an integer number of seconds
  # since the Epoch (January 1, 1970 00:00 UTC).
  #
  # ```
  # Time.zone.now.to_i # => 1417709320
  # ```
  def to_i
    utc.to_i
  end
  alias_method :tv_sec, :to_i

  # Returns the object's date and time as a rational number of seconds
  # since the Epoch (January 1, 1970 00:00 UTC).
  #
  # ```
  # Time.zone.now.to_r # => (708854548642709/500000)
  # ```
  def to_r
    utc.to_r
  end

  # Returns an instance of DateTime with the timezone's UTC offset
  #
  # ```
  # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
  # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
  # ```
  def to_datetime
    @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
  end

  # Returns an instance of `Time`, either with the same timezone as `self`,
  # with the same UTC offset as `self` or in the local system timezone
  # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
  def to_time
    @to_time_with_timezone ||= getlocal(time_zone)
  end

  # So that `self` `acts_like?(:time)`.
  def acts_like_time?
    true
  end

  # Say we're a Time to thwart type checking.
  def is_a?(klass)
    klass == ::Time || super
  end
  alias_method :kind_of?, :is_a?

  # An instance of ActiveSupport::TimeWithZone is never blank
  def blank?
    false
  end

  def present? # :nodoc:
    true
  end

  def freeze
    # preload instance variables before freezing
    period; utc; time; utc?; to_datetime; to_time
    super
  end

  def marshal_dump
    [utc, time_zone.name, time]
  end

  def marshal_load(variables)
    initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
  end

  # Ensure proxy class responds to all methods that underlying time instance
  # responds to.
  def respond_to_missing?(sym, include_priv)
    time.respond_to?(sym, include_priv)
  end

  # Send the missing method to `time` instance, and wrap result in a new
  # TimeWithZone with the existing `time_zone`.
  def method_missing(...)
    wrap_with_time_zone time.__send__(...)
  rescue NoMethodError => e
    raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
  end

  private
    SECONDS_PER_DAY = 86400

    def incorporate_utc_offset(time, offset)
      if offset.zero?
        time
      elsif time.kind_of?(Date)
        time + Rational(offset, SECONDS_PER_DAY)
      else
        time + offset
      end
    end

    def get_period_and_ensure_valid_local_time(period)
      # we don't want a Time.local instance enforcing its own DST rules as well,
      # so transfer time values to a utc constructor if necessary
      @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
      begin
        period || @time_zone.period_for_local(@time)
      rescue ::TZInfo::PeriodNotFound
        # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
        @time += 1.hour
        retry
      end
    end

    def transfer_time_values_to_utc_constructor(time)
      # avoid creating another Time object if possible
      return time if time.instance_of?(::Time) && time.utc?
      ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
    end

    def duration_of_variable_length?(obj)
      ActiveSupport::Duration === obj && obj.variable?
    end

    def wrap_with_time_zone(time)
      if time.acts_like?(:time)
        periods = time_zone.periods_for_local(time)
        self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
      elsif time.is_a?(Range)
        wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
      else
        time
      end
    end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 566
def to_datetime
  @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
end

# File activesupport/lib/active_support/time_with_zone.rb, line 535
def to_f
  utc.to_f
end

# File activesupport/lib/active_support/time_with_zone.rb, line 254
def to_fs(format = :default)
  if format == :db
    utc.to_fs(format)
  elsif formatter = ::ActiveSupport::TimeFormats.lookup(format)
    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
  else
    to_s
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 545
def to_i
  utc.to_i
end

# File activesupport/lib/active_support/time_with_zone.rb, line 556
def to_r
  utc.to_r
end

# File activesupport/lib/active_support/time_with_zone.rb, line 238
def to_s
  if utc?
    transfer_time_values_to_utc_constructor(utc).to_s
  else
    transfer_time_values_to_utc_constructor(utc).getlocal(utc_offset).to_s
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 573
def to_time
  @to_time_with_timezone ||= getlocal(time_zone)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 292
def today?
  time.today?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 298
def tomorrow?
  time.tomorrow?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 651
def transfer_time_values_to_utc_constructor(time)
  # avoid creating another Time object if possible
  return time if time.instance_of?(::Time) && time.utc?
  ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 512
    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
YAML.dump_tags[ActiveSupport::TimeWithZone] =

# File activesupport/lib/active_support/time_with_zone.rb, line 74
def utc
  @utc ||= incorporate_utc_offset(@time, -utc_offset)
end

# File activesupport/lib/active_support/time_with_zone.rb, line 120
def utc?
  if @is_utc.nil?
    @is_utc = time_zone.utc? || zone == "UTC" || zone == "UCT"
  end
  @is_utc
end

# File activesupport/lib/active_support/time_with_zone.rb, line 129
def utc_offset
  period.observed_utc_offset
end

# File activesupport/lib/active_support/time_with_zone.rb, line 502
    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"

# File activesupport/lib/active_support/time_with_zone.rb, line 661
def wrap_with_time_zone(time)
  if time.acts_like?(:time)
    periods = time_zone.periods_for_local(time)
    self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
  elsif time.is_a?(Range)
    wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
  else
    time
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 174
def xmlschema(fraction_digits = 0)
  precision = fraction_digits || 0

  if utc?
    utc.iso8601(precision)
  else
    transfer_time_values_to_utc_constructor(utc).getlocal(utc_offset).iso8601(precision)
  end
end

# File activesupport/lib/active_support/time_with_zone.rb, line 504
    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML.load_tags["!ruby/object:ActiveSupport::TimeWithZone"] = "ActiveSupport::TimeWithZone"
YAML.

# File activesupport/lib/active_support/time_with_zone.rb, line 492
    def year = time.year

    def mon = time.mon

    def month = time.month

    def day = time.day

    def mday = time.mday

    def wday = time.wday

    def yday = time.yday

    def hour = time.hour

    def min = time.min

    def sec = time.sec

    def usec = time.usec

    def nsec = time.nsec

    def to_date = time.to_date

    # Returns Array of parts of Time in sequence of
    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
    #
    # ```
    # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
    # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
    # ```
    def to_a
      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
    end

    # Returns the object's date and time as a floating-point number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_f # => 1417709320.285418
    # ```
    def to_f
      utc.to_f
    end

    # Returns the object's date and time as an integer number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_i # => 1417709320
    # ```
    def to_i
      utc.to_i
    end
    alias_method :tv_sec, :to_i

    # Returns the object's date and time as a rational number of seconds
    # since the Epoch (January 1, 1970 00:00 UTC).
    #
    # ```
    # Time.zone.now.to_r # => (708854548642709/500000)
    # ```
    def to_r
      utc.to_r
    end

    # Returns an instance of DateTime with the timezone's UTC offset
    #
    # ```
    # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
    # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
    # ```
    def to_datetime
      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
    end

    # Returns an instance of `Time`, either with the same timezone as `self`,
    # with the same UTC offset as `self` or in the local system timezone
    # depending on the setting of `ActiveSupport.to_time_preserves_timezone`.
    def to_time
      @to_time_with_timezone ||= getlocal(time_zone)
    end

    # So that `self` `acts_like?(:time)`.
    def acts_like_time?
      true
    end

    # Say we're a Time to thwart type checking.
    def is_a?(klass)
      klass == ::Time || super
    end
    alias_method :kind_of?, :is_a?

    # An instance of ActiveSupport::TimeWithZone is never blank
    def blank?
      false
    end

    def present? # :nodoc:
      true
    end

    def freeze
      # preload instance variables before freezing
      period; utc; time; utc?; to_datetime; to_time
      super
    end

    def marshal_dump
      [utc, time_zone.name, time]
    end

    def marshal_load(variables)
      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
    end

    # Ensure proxy class responds to all methods that underlying time instance
    # responds to.
    def respond_to_missing?(sym, include_priv)
      time.respond_to?(sym, include_priv)
    end

    # Send the missing method to `time` instance, and wrap result in a new
    # TimeWithZone with the existing `time_zone`.
    def method_missing(...)
      wrap_with_time_zone time.__send__(...)
    rescue NoMethodError => e
      raise e, e.message.sub(time.inspect, inspect).sub("Time", "ActiveSupport::TimeWithZone"), e.backtrace
    end

    private
      SECONDS_PER_DAY = 86400

      def incorporate_utc_offset(time, offset)
        if offset.zero?
          time
        elsif time.kind_of?(Date)
          time + Rational(offset, SECONDS_PER_DAY)
        else
          time + offset
        end
      end

      def get_period_and_ensure_valid_local_time(period)
        # we don't want a Time.local instance enforcing its own DST rules as well,
        # so transfer time values to a utc constructor if necessary
        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
        begin
          period || @time_zone.period_for_local(@time)
        rescue ::TZInfo::PeriodNotFound
          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
          @time += 1.hour
          retry
        end
      end

      def transfer_time_values_to_utc_constructor(time)
        # avoid creating another Time object if possible
        return time if time.instance_of?(::Time) && time.utc?
        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
      end

      def duration_of_variable_length?(obj)
        ActiveSupport::Duration === obj && obj.variable?
      end

      def wrap_with_time_zone(time)
        if time.acts_like?(:time)
          periods = time_zone.periods_for_local(time)
          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
        elsif time.is_a?(Range)
          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
        else
          time
        end
      end
  end
end

# These prevent Psych from calling `ActiveSupport::TimeWithZone.name`
# and triggering the deprecation warning about the change in Rails 7.1.
YAML

# File activesupport/lib/active_support/time_with_zone.rb, line 305
def yesterday?
  time.yesterday?
end

# File activesupport/lib/active_support/time_with_zone.rb, line 155
def zone
  period.abbreviation
end