tzinfo 1.2.9 → 2.0.4

data/lib/tzinfo/data_timezone.rb

@@ -1,56 +1,42 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 module TZInfo
+  # Represents time zones that are defined by rules that set out when
+  # transitions occur.
+  class DataTimezone < InfoTimezone
+    # (see Timezone#period_for)
+    def period_for(time)
+      raise ArgumentError, 'time must be specified' unless time
+      timestamp = Timestamp.for(time)
+      raise ArgumentError, 'time must have a specified utc_offset' unless timestamp.utc_offset
+      info.period_for(timestamp)
+    end
 
-  # A Timezone based on a DataTimezoneInfo.
-  #
-  # @private
-  class DataTimezone < InfoTimezone #:nodoc:
-    
-    # Returns the TimezonePeriod for the given UTC time. utc can either be
-    # a DateTime, Time or integer timestamp (Time.to_i). Any timezone 
-    # information in utc is ignored (it is treated as a UTC time).        
-    #
-    # If no TimezonePeriod could be found, PeriodNotFound is raised.
-    def period_for_utc(utc)
-      info.period_for_utc(utc)
+    # (see Timezone#periods_for_local)
+    def periods_for_local(local_time)
+      raise ArgumentError, 'local_time must be specified' unless local_time
+      info.periods_for_local(Timestamp.for(local_time, :ignore))
     end
-    
-    # Returns the set of TimezonePeriod instances that are valid for the given
-    # local time as an array. If you just want a single period, use 
-    # period_for_local instead and specify how abiguities should be resolved.
-    # Raises PeriodNotFound if no periods are found for the given time.
-    def periods_for_local(local)
-      info.periods_for_local(local)
+
+    # (see Timezone#transitions_up_to)
+    def transitions_up_to(to, from = nil)
+      raise ArgumentError, 'to must be specified' unless to
+      to_timestamp = Timestamp.for(to)
+      from_timestamp = from && Timestamp.for(from)
+
+      begin
+        info.transitions_up_to(to_timestamp, from_timestamp)
+      rescue ArgumentError => e
+        raise ArgumentError, e.message.gsub('_timestamp', '')
+      end
     end
-    
-    # Returns an Array of TimezoneTransition instances representing the times
-    # where the UTC offset of the timezone changes.
-    #
-    # Transitions are returned up to a given date and time up to a given date 
-    # and time, specified in UTC (utc_to).
-    #
-    # A from date and time may also be supplied using the utc_from parameter
-    # (also specified in UTC). If utc_from is not nil, only transitions from 
-    # that date and time onwards will be returned.
-    #
-    # Comparisons with utc_to are exclusive. Comparisons with utc_from are
-    # inclusive. If a transition falls precisely on utc_to, it will be excluded.
-    # If a transition falls on utc_from, it will be included.
-    #
-    # Transitions returned are ordered by when they occur, from earliest to 
-    # latest.
-    #
-    # utc_to and utc_from can be specified using either DateTime, Time or 
-    # integer timestamps (Time.to_i).
+
+    # Returns the canonical {Timezone} instance for this {DataTimezone}.
     #
-    # If utc_from is specified and utc_to is not greater than utc_from, then
-    # transitions_up_to raises an ArgumentError exception.
-    def transitions_up_to(utc_to, utc_from = nil)
-      info.transitions_up_to(utc_to, utc_from)
-    end
-    
-    # Returns the canonical zone for this Timezone.
+    # For a {DataTimezone}, this is always `self`.
     #
-    # For a DataTimezone, this is always self.
+    # @return [Timezone] `self`.
     def canonical_zone
       self
     end

data/lib/tzinfo/datetime_with_offset.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'date'
+
+module TZInfo
+  # A subclass of `DateTime` used to represent local times. {DateTimeWithOffset}
+  # holds a reference to the related {TimezoneOffset} and overrides various
+  # methods to return results appropriate for the {TimezoneOffset}. Certain
+  # operations will clear the associated {TimezoneOffset} (if the
+  # {TimezoneOffset} would not necessarily be valid for the result). Once the
+  # {TimezoneOffset} has been cleared, {DateTimeWithOffset} behaves identically
+  # to `DateTime`.
+  #
+  # Arithmetic performed on {DateTimeWithOffset} instances is _not_ time
+  # zone-aware. Regardless of whether transitions in the time zone are crossed,
+  # results of arithmetic operations will always maintain the same offset from
+  # UTC (`offset`). The associated {TimezoneOffset} will aways be cleared.
+  class DateTimeWithOffset < DateTime
+    include WithOffset
+
+    # @return [TimezoneOffset] the {TimezoneOffset} associated with this
+    #   instance.
+    attr_reader :timezone_offset
+
+    # Sets the associated {TimezoneOffset}.
+    #
+    # @param timezone_offset [TimezoneOffset] a {TimezoneOffset} valid at the
+    #   time and for the offset of this {DateTimeWithOffset}.
+    # @return [DateTimeWithOffset] `self`.
+    # @raise [ArgumentError] if `timezone_offset` is `nil`.
+    # @raise [ArgumentError] if `timezone_offset.observed_utc_offset` does not
+    #   equal `self.offset * 86400`.
+    def set_timezone_offset(timezone_offset)
+      raise ArgumentError, 'timezone_offset must be specified' unless timezone_offset
+      raise ArgumentError, 'timezone_offset.observed_utc_offset does not match self.utc_offset' if offset * 86400 != timezone_offset.observed_utc_offset
+      @timezone_offset = timezone_offset
+      self
+    end
+
+    # An overridden version of `DateTime#to_time` that, if there is an
+    # associated {TimezoneOffset}, returns a {DateTimeWithOffset} with that
+    # offset.
+    #
+    # @return [Time] if there is an associated {TimezoneOffset}, a
+    #   {TimeWithOffset} representation of this {DateTimeWithOffset}, otherwise
+    #   a `Time` representation.
+    def to_time
+      if_timezone_offset(super) do |o,t|
+        # Ruby 2.4.0 changed the behaviour of to_time so that it preserves the
+        # offset instead of converting to the system local timezone.
+        #
+        # When self has an associated TimezonePeriod, this implementation will
+        # preserve the offset on all versions of Ruby.
+        TimeWithOffset.at(t.to_i, t.subsec * 1_000_000).set_timezone_offset(o)
+      end
+    end
+
+    # An overridden version of `DateTime#downto` that clears the associated
+    # {TimezoneOffset} of the returned or yielded instances.
+    def downto(min)
+      if block_given?
+        super {|dt| yield dt.clear_timezone_offset }
+      else
+        enum = super
+        enum.each {|dt| dt.clear_timezone_offset }
+        enum
+      end
+    end
+
+    # An overridden version of `DateTime#england` that preserves the associated
+    # {TimezoneOffset}.
+    #
+    # @return [DateTime]
+    def england
+      # super doesn't call #new_start on MRI, so each method has to be
+      # individually overridden.
+      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
+    end
+
+    # An overridden version of `DateTime#gregorian` that preserves the
+    # associated {TimezoneOffset}.
+    #
+    # @return [DateTime]
+    def gregorian
+      # super doesn't call #new_start on MRI, so each method has to be
+      # individually overridden.
+      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
+    end
+
+    # An overridden version of `DateTime#italy` that preserves the associated
+    # {TimezoneOffset}.
+    #
+    # @return [DateTime]
+    def italy
+      # super doesn't call #new_start on MRI, so each method has to be
+      # individually overridden.
+      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
+    end
+
+    # An overridden version of `DateTime#julian` that preserves the associated
+    # {TimezoneOffset}.
+    #
+    # @return [DateTime]
+    def julian
+      # super doesn't call #new_start on MRI, so each method has to be
+      # individually overridden.
+      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
+    end
+
+    # An overridden version of `DateTime#new_start` that preserves the
+    # associated {TimezoneOffset}.
+    #
+    # @return [DateTime]
+    def new_start(start = Date::ITALY)
+      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
+    end
+
+    # An overridden version of `DateTime#step` that clears the associated
+    # {TimezoneOffset} of the returned or yielded instances.
+    def step(limit, step = 1)
+      if block_given?
+        super {|dt| yield dt.clear_timezone_offset }
+      else
+        enum = super
+        enum.each {|dt| dt.clear_timezone_offset }
+        enum
+      end
+    end
+
+    # An overridden version of `DateTime#upto` that clears the associated
+    # {TimezoneOffset} of the returned or yielded instances.
+    def upto(max)
+      if block_given?
+        super {|dt| yield dt.clear_timezone_offset }
+      else
+        enum = super
+        enum.each {|dt| dt.clear_timezone_offset }
+        enum
+      end
+    end
+
+    protected
+
+    # Clears the associated {TimezoneOffset}.
+    #
+    # @return [DateTimeWithOffset] `self`.
+    def clear_timezone_offset
+      @timezone_offset = nil
+      self
+    end
+  end
+end

data/lib/tzinfo/format1.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+module TZInfo
+  # Modules and classes used by the format 1 version of TZInfo::Data.
+  #
+  # @private
+  module Format1 #:nodoc:
+  end
+  private_constant :Format1
+end

data/lib/tzinfo/format1/country_definer.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format1
+    # Instances of {Format1::CountryDefiner} are yielded to the format 1 version
+    # of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefinition} to allow
+    # the zones of a country to be specified.
+    #
+    # @private
+    class CountryDefiner < Format2::CountryDefiner #:nodoc:
+      # Initializes a new {CountryDefiner}.
+      def initialize(identifier_deduper, description_deduper)
+        super(nil, identifier_deduper, description_deduper)
+      end
+    end
+  end
+end

data/lib/tzinfo/format1/country_index_definition.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format1
+    # The format 1 TZInfo::Data country index file includes
+    # {Format1::CountryIndexDefinition}, which provides a
+    # {CountryIndexDefinition::ClassMethods#country country} method used to
+    # define each country in the index.
+    #
+    # @private
+    module CountryIndexDefinition #:nodoc:
+      # Adds class methods to the includee and initializes class instance
+      # variables.
+      #
+      # @param base [Module] the includee.
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        base.instance_eval { @countries = {} }
+      end
+
+      # Class methods for inclusion.
+      #
+      # @private
+      module ClassMethods #:nodoc:
+        # @return [Hash<String, DataSources::CountryInfo>] a frozen `Hash`
+        #   of all the countries that have been defined in the index keyed by
+        #   their codes.
+        def countries
+          @description_deduper = nil
+          @countries.freeze
+        end
+
+        private
+
+        # Defines a country with an ISO 3166-1 alpha-2 country code and name.
+        #
+        # @param code [String] the ISO 3166-1 alpha-2 country code.
+        # @param name [String] the name of the country.
+        # @yield [definer] (optional) to obtain the time zones for the country.
+        # @yieldparam definer [CountryDefiner] a {CountryDefiner} instance.
+        def country(code, name)
+          @description_deduper ||= StringDeduper.new
+
+          zones = if block_given?
+            definer = CountryDefiner.new(StringDeduper.global, @description_deduper)
+            yield definer
+            definer.timezones
+          else
+            []
+          end
+
+          @countries[code.freeze] = DataSources::CountryInfo.new(code, name, zones)
+        end
+      end
+    end
+  end
+
+  # Alias used by TZInfo::Data format1 releases.
+  #
+  # @private
+  CountryIndexDefinition = Format1::CountryIndexDefinition #:nodoc:
+  private_constant :CountryIndexDefinition
+end

data/lib/tzinfo/format1/timezone_definer.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module TZInfo
+  module Format1
+    # Instances of {Format1::TimezoneDefiner} are yielded to TZInfo::Data
+    # format 1 modules by {TimezoneDefinition} to allow the offsets and
+    # transitions of the time zone to be specified.
+    #
+    # @private
+    class TimezoneDefiner < Format2::TimezoneDefiner #:nodoc:
+      undef_method :subsequent_rules
+
+      # Defines an offset.
+      #
+      # @param id [Symbol] an arbitrary value used identify the offset in
+      #   subsequent calls to transition. It must be unique.
+      # @param utc_offset [Integer] the base offset from UTC of the zone in
+      #   seconds. This does not include daylight savings time.
+      # @param std_offset [Integer] the daylight savings offset from the base
+      #   offset in seconds. Typically either 0 or 3600.
+      # @param abbreviation [Symbol] an abbreviation for the offset, for
+      #   example, `:EST` or `:EDT`.
+      # @raise [ArgumentError] if another offset has already been defined with
+      #   the given id.
+      def offset(id, utc_offset, std_offset, abbreviation)
+        super(id, utc_offset, std_offset, abbreviation.to_s)
+      end
+
+      # Defines a transition to a given offset.
+      #
+      # Transitions must be defined in increasing time order.
+      #
+      # @param year [Integer] the UTC year in which the transition occurs. Used
+      #   in earlier versions of TZInfo, but now ignored.
+      # @param month [Integer] the UTC month in which the transition occurs.
+      #   Used in earlier versions of TZInfo, but now ignored.
+      # @param offset_id [Symbol] references the id of a previously defined
+      #   offset (see #offset).
+      # @param timestamp_value [Integer] the time the transition occurs as an
+      #   Integer number of seconds since 1970-01-01 00:00:00 UTC ignoring leap
+      #   seconds (i.e. each day is treated as if it were 86,400 seconds long).
+      # @param datetime_numerator [Integer] the time of the transition as the
+      #   numerator of the `Rational` returned by `DateTime#ajd`. Used in
+      #   earlier versions of TZInfo, but now ignored.
+      # @param datetime_denominator [Integer] the time of the transition as the
+      #   denominator of the `Rational` returned by `DateTime#ajd`. Used in
+      #   earlier versions of TZInfo, but now ignored.
+      # @raise [ArgumentError] if `offset_id` does not reference a defined
+      #   offset.
+      # @raise [ArgumentError] if `timestamp_value` is not greater than the
+      #   `timestamp_value` of the previously defined transition.
+      # @raise [ArgumentError] if `datetime_numerator` is specified, but
+      #   `datetime_denominator` is not. In older versions of TZInfo, it was
+      #   possible to define a transition with the `DateTime` numerator as the
+      #   4th parameter and the denominator as the 5th parameter. This style of
+      #   definition is not used in released versions of TZInfo::Data.
+      def transition(year, month, offset_id, timestamp_value, datetime_numerator = nil, datetime_denominator = nil)
+        raise ArgumentError, 'DateTime-only transitions are not supported' if datetime_numerator && !datetime_denominator
+        super(offset_id, timestamp_value)
+      end
+    end
+  end
+end

data/lib/tzinfo/format1/timezone_definition.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format1
+    # {Format1::TimezoneDefinition} is included into format 1 time zone
+    # definition modules and provides the methods for defining time zones.
+    #
+    # @private
+    module TimezoneDefinition #:nodoc:
+      # Adds class methods to the includee.
+      #
+      # @param base [Module] the includee.
+      def self.append_features(base)
+        super
+        base.extend(Format2::TimezoneDefinition::ClassMethods)
+        base.extend(ClassMethods)
+      end
+
+      # Class methods for inclusion.
+      #
+      # @private
+      module ClassMethods #:nodoc:
+        private
+
+        # @return the class to be instantiated and yielded by
+        # {Format2::TimezoneDefinition::ClassMethods#timezone}.
+        def timezone_definer_class
+          TimezoneDefiner
+        end
+      end
+    end
+  end
+
+  # Alias used by TZInfo::Data format1 releases.
+  #
+  # @private
+  TimezoneDefinition = Format1::TimezoneDefinition #:nodoc:
+  private_constant :TimezoneDefinition
+end

data/lib/tzinfo/format1/timezone_index_definition.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format1
+    # The format 1 TZInfo::Data time zone index file includes
+    # {Format1::TimezoneIndexDefinition}, which provides methods used to define
+    # time zones in the index.
+    #
+    # @private
+    module TimezoneIndexDefinition #:nodoc:
+      # Adds class methods to the includee and initializes class instance
+      # variables.
+      #
+      # @param base [Module] the includee.
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        base.instance_eval do
+          @timezones = []
+          @data_timezones = []
+          @linked_timezones = []
+        end
+      end
+
+      # Class methods for inclusion.
+      #
+      # @private
+      module ClassMethods #:nodoc:
+        # @return [Array<String>] a frozen `Array` containing the identifiers of
+        #   all data time zones. Identifiers are sorted according to
+        #   `String#<=>`.
+        def data_timezones
+          unless @data_timezones.frozen?
+            @data_timezones = @data_timezones.sort.freeze
+          end
+          @data_timezones
+        end
+
+        # @return [Array<String>] a frozen `Array` containing the identifiers of
+        #   all linked time zones. Identifiers are sorted according to
+        #   `String#<=>`.
+        def linked_timezones
+          unless @linked_timezones.frozen?
+            @linked_timezones = @linked_timezones.sort.freeze
+          end
+          @linked_timezones
+        end
+
+        private
+
+        # Adds a data time zone to the index.
+        #
+        # @param identifier [String] the time zone identifier.
+        def timezone(identifier)
+          identifier = StringDeduper.global.dedupe(identifier)
+          @timezones << identifier
+          @data_timezones << identifier
+        end
+
+        # Adds a linked time zone to the index.
+        #
+        # @param identifier [String] the time zone identifier.
+        def linked_timezone(identifier)
+          identifier = StringDeduper.global.dedupe(identifier)
+          @timezones << identifier
+          @linked_timezones << identifier
+        end
+      end
+    end
+  end
+
+  # Alias used by TZInfo::Data format 1 releases.
+  #
+  # @private
+  TimezoneIndexDefinition = Format1::TimezoneIndexDefinition #:nodoc:
+  private_constant :TimezoneIndexDefinition
+end