tzinfo 1.2.11 → 2.0.0

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

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/format2/country_definer.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module TZInfo
+  module Format2
+    # Instances of {Format2::CountryDefiner} are yielded to the format 2 version
+    # of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefiner} to allow
+    # the zones of a country to be specified.
+    #
+    # @private
+    class CountryDefiner #:nodoc:
+      # @return [Array<CountryTimezone>] the time zones observed in the country.
+      attr_reader :timezones
+
+      # Initializes a new {CountryDefiner}.
+      #
+      # @param shared_timezones [Hash<Symbol, CountryTimezone>] a `Hash`
+      #   containing time zones shared by more than one country, keyed by a
+      #   unique reference.
+      # @param identifier_deduper [StringDeduper] a {StringDeduper} instance to
+      #   use when deduping time zone identifiers.
+      # @param description_deduper [StringDeduper] a {StringDeduper} instance to
+      #   use when deduping time zone descriptions.
+      def initialize(shared_timezones, identifier_deduper, description_deduper)
+        @shared_timezones = shared_timezones
+        @identifier_deduper = identifier_deduper
+        @description_deduper = description_deduper
+        @timezones = []
+      end
+
+      # @overload timezone(reference)
+      #   Defines a time zone of a country as a reference to a pre-defined
+      #   shared time zone.
+      #   @param reference [Symbol] a reference for a pre-defined shared time
+      #     zone.
+      # @overload timezone(identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description)
+      #   Defines a (non-shared) time zone of a country. The latitude and
+      #   longitude are given as the numerator and denominator of a `Rational`.
+      #   @param identifier [String] the time zone identifier.
+      #   @param latitude_numerator [Integer] the numerator of the latitude.
+      #   @param latitude_denominator [Integer] the denominator of the latitude.
+      #   @param longitude_numerator [Integer] the numerator of the longitude.
+      #   @param longitude_denominator [Integer] the denominator of the
+      #     longitude.
+      #   @param description [String] an optional description for the time zone.
+      def timezone(identifier_or_reference, latitude_numerator = nil,
+                  latitude_denominator = nil, longitude_numerator = nil,
+                  longitude_denominator = nil, description = nil)
+        if latitude_numerator
+          unless latitude_denominator && longitude_numerator && longitude_denominator
+            raise ArgumentError, 'Either just a reference should be supplied, or the identifier, latitude and longitude must all be specified'
+          end
+
+          # Dedupe non-frozen literals from format 1 on all Ruby versions and
+          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+
+          @timezones << CountryTimezone.new(@identifier_deduper.dedupe(identifier_or_reference),
+            Rational(latitude_numerator, latitude_denominator),
+            Rational(longitude_numerator, longitude_denominator), description && @description_deduper.dedupe(description))
+        else
+          shared_timezone = @shared_timezones[identifier_or_reference]
+          raise ArgumentError, "Unknown shared timezone: #{identifier_or_reference}" unless shared_timezone
+          @timezones << shared_timezone
+        end
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/country_index_definer.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format2
+    # Instances of {Format2::CountryIndexDefiner} are yielded to the format 2
+    # version of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefinition}
+    # to allow countries and their time zones to be specified.
+    #
+    # @private
+    class CountryIndexDefiner #:nodoc:
+      # @return [Hash<String, CountryInfo>] a `Hash` of all the countries that
+      #     have been defined in the index keyed by their codes.
+      attr_reader :countries
+
+      # Initializes a new {CountryIndexDefiner}.
+      #
+      # @param identifier_deduper [StringDeduper] a {StringDeduper} instance to
+      #   use when deduping time zone identifiers.
+      # @param description_deduper [StringDeduper] a {StringDeduper} instance to
+      #   use when deduping time zone descriptions.
+      def initialize(identifier_deduper, description_deduper)
+        @identifier_deduper = identifier_deduper
+        @description_deduper = description_deduper
+        @shared_timezones = {}
+        @countries = {}
+      end
+
+      # Defines a time zone shared by many countries with an reference for
+      # subsequent use in country definitions. The latitude and longitude are
+      # given as the numerator and denominator of a `Rational`.
+      #
+      # @param reference [Symbol] a unique reference for the time zone.
+      # @param identifier [String] the time zone identifier.
+      # @param latitude_numerator [Integer] the numerator of the latitude.
+      # @param latitude_denominator [Integer] the denominator of the latitude.
+      # @param longitude_numerator [Integer] the numerator of the longitude.
+      # @param longitude_denominator [Integer] the denominator of the longitude.
+      # @param description [String] an optional description for the time zone.
+      def timezone(reference, identifier, latitude_numerator, latitude_denominator,
+                    longitude_numerator, longitude_denominator, description = nil)
+        # Dedupe non-frozen literals from format 1 on all Ruby versions and
+        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+        @shared_timezones[reference] = CountryTimezone.new(@identifier_deduper.dedupe(identifier),
+          Rational(latitude_numerator, latitude_denominator),
+          Rational(longitude_numerator, longitude_denominator), description && @description_deduper.dedupe(description))
+      end
+
+      # Defines a country.
+      #
+      # @param code [String] The ISO 3166-1 alpha-2 code of the country.
+      # @param name [String] Then name of the country.
+      # @yield [definer] yields (optional) to obtain the time zones for the
+      #   country.
+      # @yieldparam definer [CountryDefiner] a {CountryDefiner}
+      #   instance that should be used to specify the time zones of the country.
+      def country(code, name)
+        timezones = if block_given?
+          definer = CountryDefiner.new(@shared_timezones, @identifier_deduper, @description_deduper)
+          yield definer
+          definer.timezones
+        else
+          []
+        end
+        @countries[code.freeze] = DataSources::CountryInfo.new(code, name, timezones)
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/country_index_definition.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format2
+    # The format 2 country index file includes
+    # {Format2::CountryIndexDefinition}, which provides a
+    # {CountryIndexDefinition::ClassMethods#country_index country_index} method
+    # used to define the country 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 = {}.freeze }
+      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.
+        attr_reader :countries
+
+        private
+
+        # Defines the index.
+        #
+        # @yield [definer] yields to allow the index to be defined.
+        # @yieldparam definer [CountryIndexDefiner] a {CountryIndexDefiner}
+        #   instance that should be used to define the index.
+        def country_index
+          definer = CountryIndexDefiner.new(StringDeduper.global, StringDeduper.new)
+          yield definer
+          @countries = definer.countries.freeze
+        end
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/timezone_definer.rb

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module TZInfo
+  module Format2
+    # Instances of {TimezoneDefiner} are yielded to TZInfo::Data modules by
+    # {TimezoneDefinition} to allow the offsets and transitions of the time zone
+    # to be specified.
+    #
+    # @private
+    class TimezoneDefiner #:nodoc:
+      # @return [Array<TimezoneTransition>] the defined transitions of the time
+      #   zone.
+      attr_reader :transitions
+
+      # Initializes a new TimezoneDefiner.
+      #
+      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
+      #   when deduping abbreviations.
+      def initialize(string_deduper)
+        @string_deduper = string_deduper
+        @offsets = {}
+        @transitions = []
+      end
+
+      # Returns the first offset to be defined or `nil` if no offsets have been
+      #  defined. The first offset is observed before the time of the first
+      #  transition.
+      #
+      # @return [TimezoneOffset] the first offset to be defined or `nil` if no
+      #   offsets have been defined.
+      def first_offset
+        first = @offsets.first
+        first && first.last
+      end
+
+      # Defines an offset.
+      #
+      # @param id [Symbol] an arbitrary value used identify the offset in
+      #   subsequent calls to transition. It must be unique.
+      # @param base_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 [String] 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, base_utc_offset, std_offset, abbreviation)
+        raise ArgumentError, 'An offset has already been defined with the given id' if @offsets.has_key?(id)
+
+        # Dedupe non-frozen literals from format 1 on all Ruby versions and
+        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+        abbreviation = @string_deduper.dedupe(abbreviation)
+
+        offset = TimezoneOffset.new(base_utc_offset, std_offset, abbreviation)
+        @offsets[id] = offset
+        @previous_offset ||= offset
+      end
+
+      # Defines a transition to a given offset.
+      #
+      # Transitions must be defined in increasing time order.
+      #
+      # @param offset_id [Symbol] references the id of a previously defined
+      #   offset.
+      # @param timestamp_value [Integer] the time the transition occurs as a
+      #   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).
+      # @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.
+      def transition(offset_id, timestamp_value)
+        offset = @offsets[offset_id]
+        raise ArgumentError, 'offset_id has not been defined' unless offset
+        raise ArgumentError, 'timestamp is not greater than the timestamp of the previously defined transition' if !@transitions.empty? && @transitions.last.timestamp_value >= timestamp_value
+        @transitions << TimezoneTransition.new(offset, @previous_offset, timestamp_value)
+        @previous_offset = offset
+      end
+
+      # Defines the rules that will be used for handling instants after the last
+      # transition.
+      #
+      # This method is currently just a placeholder for forward compatibility
+      # that accepts and ignores any arguments passed.
+      #
+      # Support for subsequent rules will be added in a future version of TZInfo
+      # and the rules will be included in format 2 releases of TZInfo::Data.
+      def subsequent_rules(*args)
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/timezone_definition.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format2
+    # {Format2::TimezoneDefinition} is included into format 2 time zone
+    # definition modules and provides 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(ClassMethods)
+      end
+
+      # Class methods for inclusion.
+      #
+      # @private
+      module ClassMethods #:nodoc:
+        # @return [TimezoneInfo] the last time zone to be defined.
+        def get
+          @timezone
+        end
+
+        private
+
+        # @return [Class] the class to be instantiated and yielded by
+        #   {#timezone}.
+        def timezone_definer_class
+          TimezoneDefiner
+        end
+
+        # Defines a data time zone.
+        #
+        # @param identifier [String] the identifier of the time zone.
+        # @yield [definer] yields to the caller to define the time zone.
+        # @yieldparam definer [Object] an instance of the class returned by
+        #   {#timezone_definer_class}, typically {TimezoneDefiner}.
+        def timezone(identifier)
+          # Dedupe non-frozen literals from format 1 on all Ruby versions and
+          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+          string_deduper = StringDeduper.global
+          identifier = string_deduper.dedupe(identifier)
+
+          definer = timezone_definer_class.new(string_deduper)
+          yield definer
+          transitions = definer.transitions
+
+          @timezone = if transitions.empty?
+            DataSources::ConstantOffsetDataTimezoneInfo.new(identifier, definer.first_offset)
+          else
+            DataSources::TransitionsDataTimezoneInfo.new(identifier, transitions)
+          end
+        end
+
+        # Defines a linked time zone.
+        #
+        # @param identifier [String] the identifier of the time zone being
+        #   defined.
+        # @param link_to_identifier [String] the identifier the new time zone
+        #   links to (is an alias for).
+        def linked_timezone(identifier, link_to_identifier)
+          # Dedupe non-frozen literals from format 1 on all Ruby versions and
+          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+          string_deduper = StringDeduper.global
+          @timezone = DataSources::LinkedTimezoneInfo.new(string_deduper.dedupe(identifier), string_deduper.dedupe(link_to_identifier))
+        end
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/timezone_index_definer.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format2
+    # Instances of {TimezoneIndexDefiner} are yielded by
+    # {TimezoneIndexDefinition} to allow the time zone index to be defined.
+    #
+    # @private
+    class TimezoneIndexDefiner #:nodoc:
+      # @return [Array<String>] the identifiers of all data time zones.
+      attr_reader :data_timezones
+
+      # @return [Array<String>] the identifiers of all linked time zones.
+      attr_reader :linked_timezones
+
+      # Initializes a new TimezoneDefiner.
+      #
+      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
+      #   when deduping identifiers.
+      def initialize(string_deduper)
+        @string_deduper = string_deduper
+        @data_timezones = []
+        @linked_timezones = []
+      end
+
+      # Adds a data time zone to the index.
+      #
+      # @param identifier [String] the time zone identifier.
+      def data_timezone(identifier)
+        # Dedupe non-frozen literals from format 1 on all Ruby versions and
+        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+        @data_timezones << @string_deduper.dedupe(identifier)
+      end
+
+      # Adds a linked time zone to the index.
+      #
+      # @param identifier [String] the time zone identifier.
+      def linked_timezone(identifier)
+        # Dedupe non-frozen literals from format 1 on all Ruby versions and
+        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
+        @linked_timezones << @string_deduper.dedupe(identifier)
+      end
+    end
+  end
+end

data/lib/tzinfo/format2/timezone_index_definition.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module TZInfo
+  module Format2
+    # The format 2 time zone index file includes {TimezoneIndexDefinition},
+    # which provides the {TimezoneIndexDefinition::ClassMethods#timezone_index
+    # timezone_index} method used to define 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
+          empty = [].freeze
+          @timezones = empty
+          @data_timezones = empty
+          @linked_timezones = empty
+        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#<=>`.
+        attr_reader :data_timezones
+
+        # @return [Array<String>] a frozen `Array` containing the identifiers of
+        #   all linked time zones. Identifiers are sorted according to
+        #   `String#<=>`.
+        attr_reader :linked_timezones
+
+        # Defines the index.
+        #
+        # @yield [definer] yields to the caller to allow the index to be
+        #   defined.
+        # @yieldparam definer [TimezoneIndexDefiner] a {TimezoneIndexDefiner}
+        #   instance that should be used to define the index.
+        def timezone_index
+          definer = TimezoneIndexDefiner.new(StringDeduper.global)
+          yield definer
+          @data_timezones = definer.data_timezones.sort!.freeze
+          @linked_timezones = definer.linked_timezones.sort!.freeze
+        end
+      end
+    end
+  end
+end

data/lib/tzinfo/format2.rb

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

data/lib/tzinfo/info_timezone.rb

@@ -1,30 +1,35 @@
+# encoding: UTF-8
+
 module TZInfo
 
-  # A Timezone based on a TimezoneInfo.
+  # A {Timezone} based on a {DataSources::TimezoneInfo}.
   #
-  # @private
-  class InfoTimezone < Timezone #:nodoc:
-    
-    # Constructs a new InfoTimezone with a TimezoneInfo instance.
-    def self.new(info)      
-      tz = super()
-      tz.send(:setup, info)
-      tz
+  # @abstract
+  class InfoTimezone < Timezone
+    # Initializes a new {InfoTimezone}.
+    #
+    # {InfoTimezone} instances should not normally be created directly. Use
+    # the {Timezone.get} method to obtain {Timezone} instances.
+    #
+    # @param info [DataSources::TimezoneInfo] a {DataSources::TimezoneInfo}
+    #   instance supplied by a {DataSource} that will be used as the source of
+    #   data for this {InfoTimezone}.
+    def initialize(info)
+      super()
+      @info = info
     end
-    
-    # The identifier of the timezone, e.g. "Europe/Paris".
+
+    # (see Timezone#identifier)
     def identifier
       @info.identifier
     end
-    
+
     protected
-      # The TimezoneInfo for this Timezone.
-      def info
-        @info
-      end
-          
-      def setup(info)
-        @info = info
-      end
-  end    
+
+    # @return [DataSources::TimezoneInfo] the {DataSources::TimezoneInfo} this
+    #   {InfoTimezone} is based on.
+    def info
+      @info
+    end
+  end
 end