tzinfo 1.2.10 → 2.0.6

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

data/lib/tzinfo/linked_timezone.rb

@@ -1,63 +1,44 @@
+# encoding: UTF-8
+
 module TZInfo
+  # Represents time zones that are defined as a link to or alias for another
+  # time zone.
+  class LinkedTimezone < InfoTimezone
+    # Initializes a new {LinkedTimezone}.
+    #
+    # {LinkedTimezone} instances should not normally be created directly. Use
+    # the {Timezone.get} method to obtain {Timezone} instances.
+    #
+    # @param info [DataSources::LinkedTimezoneInfo] a
+    #   {DataSources::LinkedTimezoneInfo} instance supplied by a {DataSource}
+    #   that will be used as the source of data for this {LinkedTimezone}.
+    def initialize(info)
+      super
+      @linked_timezone = Timezone.get(info.link_to_identifier)
+    end
 
-  # A Timezone based on a LinkedTimezoneInfo.
-  #
-  # @private
-  class LinkedTimezone < 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)
-      @linked_timezone.period_for_utc(utc)
+    # (see Timezone#period_for)
+    def period_for(time)
+      @linked_timezone.period_for(time)
     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)
-      @linked_timezone.periods_for_local(local)
+
+    # (see Timezone#periods_for_local)
+    def periods_for_local(local_time)
+      @linked_timezone.periods_for_local(local_time)
     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).
-    #
-    # 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)
-      @linked_timezone.transitions_up_to(utc_to, utc_from)
+
+    # (see Timezone#transitions_up_to)
+    def transitions_up_to(to, from = nil)
+      @linked_timezone.transitions_up_to(to, from)
     end
-    
-    # Returns the canonical zone for this Timezone.
+
+    # Returns the canonical {Timezone} instance for this {LinkedTimezone}.
+    #
+    # For a {LinkedTimezone}, this is the canonical zone of the link target.
     #
-    # For a LinkedTimezone, this is the canonical zone of the link target.
+    # @return [Timezone] the canonical {Timezone} instance for this {Timezone}.
     def canonical_zone
       @linked_timezone.canonical_zone
     end
-    
-    protected
-      def setup(info)
-        super(info)
-        @linked_timezone = Timezone.get(info.link_to_identifier)
-      end
   end
 end

data/lib/tzinfo/offset_timezone_period.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module TZInfo
+  # Represents the infinite period of time in a time zone that constantly
+  # observes the same offset from UTC (has an unbounded start and end).
+  class OffsetTimezonePeriod < TimezonePeriod
+    # Initializes an {OffsetTimezonePeriod}.
+    #
+    # @param offset [TimezoneOffset] the offset that is constantly observed.
+    # @raise [ArgumentError] if `offset` is `nil`.
+    def initialize(offset)
+      super
+    end
+
+    # @return [TimezoneTransition] the transition that defines the start of this
+    #   {TimezonePeriod}, always `nil` for {OffsetTimezonePeriod}.
+    def start_transition
+      nil
+    end
+
+    # @return [TimezoneTransition] the transition that defines the end of this
+    #   {TimezonePeriod}, always `nil` for {OffsetTimezonePeriod}.
+    def end_transition
+      nil
+    end
+
+    # Determines if this {OffsetTimezonePeriod} is equal to another instance.
+    #
+    # @param p [Object] the instance to test for equality.
+    # @return [Boolean] `true` if `p` is a {OffsetTimezonePeriod} with the same
+    #   {offset}, otherwise `false`.
+    def ==(p)
+      p.kind_of?(OffsetTimezonePeriod) && offset == p.offset
+    end
+    alias eql? ==
+
+    # @return [Integer] a hash based on {offset}.
+    def hash
+      offset.hash
+    end
+  end
+end

data/lib/tzinfo/ruby_core_support.rb

@@ -1,169 +1,38 @@
-require 'date'
-require 'rational' unless defined?(Rational)
-
 module TZInfo
-  
+
   # Methods to support different versions of Ruby.
   #
   # @private
   module RubyCoreSupport #:nodoc:
-  
-    # Use Rational.new! for performance reasons in Ruby 1.8.
-    # This has been removed from 1.9, but Rational performs better.        
-    if Rational.respond_to? :new!
-      def self.rational_new!(numerator, denominator = 1)
-        Rational.new!(numerator, denominator)
-      end
-    else
-      def self.rational_new!(numerator, denominator = 1)
-        Rational(numerator, denominator)
-      end
-    end
-    
-    # Ruby 1.8.6 introduced new! and deprecated new0.
-    # Ruby 1.9.0 removed new0.
-    # Ruby trunk revision 31668 removed the new! method.
-    # Still support new0 for better performance on older versions of Ruby (new0 indicates
-    # that the rational has already been reduced to its lowest terms).
-    # Fallback to jd with conversion from ajd if new! and new0 are unavailable.
-    if DateTime.respond_to? :new!
-      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
-        DateTime.new!(ajd, of, sg)
-      end
-    elsif DateTime.respond_to? :new0
-      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
-        DateTime.new0(ajd, of, sg)
-      end
-    else
-      HALF_DAYS_IN_DAY = rational_new!(1, 2)
+    class << self
+      # Object#untaint is deprecated and becomes a no-op in Ruby >= 2.7. It has
+      # been removed from Ruby 3.2.
+      if !Object.new.respond_to?(:untaint) || RUBY_VERSION =~ /\A(\d+)\.(\d+)(?:\.|\z)/ && ($1 == '2' && $2.to_i >= 7 || $1.to_i >= 3)
+        # :nocov_functional_untaint:
 
-      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
-        # Convert from an Astronomical Julian Day number to a civil Julian Day number.
-        jd = ajd + of + HALF_DAYS_IN_DAY
-        
-        # Ruby trunk revision 31862 changed the behaviour of DateTime.jd so that it will no
-        # longer accept a fractional civil Julian Day number if further arguments are specified.
-        # Calculate the hours, minutes and seconds to pass to jd.
-        
-        jd_i = jd.to_i
-        jd_i -= 1 if jd < 0
-        hours = (jd - jd_i) * 24
-        hours_i = hours.to_i
-        minutes = (hours - hours_i) * 60
-        minutes_i = minutes.to_i
-        seconds = (minutes - minutes_i) * 60
-        
-        DateTime.jd(jd_i, hours_i, minutes_i, seconds, of, sg)
-      end
-    end
-    
-    # DateTime in Ruby 1.8.6 doesn't consider times within the 60th second to be
-    # valid. When attempting to specify such a DateTime, subtract the fractional
-    # part and then add it back later
-    if Date.respond_to?(:valid_time?) && !Date.valid_time?(0, 0, rational_new!(59001, 1000)) # 0:0:59.001
-      def self.datetime_new(y=-4712, m=1, d=1, h=0, min=0, s=0, of=0, sg=Date::ITALY)
-        if !s.kind_of?(Integer) && s > 59
-          dt = DateTime.new(y, m, d, h, min, 59, of, sg)
-          dt + (s - 59) / 86400
-        else
-          DateTime.new(y, m, d, h, min, s, of, sg)
+        # Returns the supplied `Object`
+        #
+        # @param o [Object] the `Object` to untaint.
+        # @return [Object] `o`.
+        def untaint(o)
+          o
         end
-      end
-    else
-      def self.datetime_new(y=-4712, m=1, d=1, h=0, min=0, s=0, of=0, sg=Date::ITALY)
-        DateTime.new(y, m, d, h, min, s, of, sg)
-      end    
-    end    
-    
-    # Returns true if Time on the runtime platform supports Times defined
-    # by negative 32-bit timestamps, otherwise false.
-    begin
-      Time.at(-1)
-      Time.at(-2147483648)
-      
-      def self.time_supports_negative
-        true
-      end
-    rescue ArgumentError
-      def self.time_supports_negative
-        false
-      end
-    end
-    
-    # Returns true if Time on the runtime platform supports Times defined by
-    # 64-bit timestamps, otherwise false.
-    begin
-      Time.at(-2147483649)
-      Time.at(2147483648)
-      
-      def self.time_supports_64bit
-        true
-      end
-    rescue RangeError
-      def self.time_supports_64bit
-        false
-      end
-    end
-    
-    # Return the result of Time#nsec if it exists, otherwise return the
-    # result of Time#usec * 1000.
-    if Time.method_defined?(:nsec)
-      def self.time_nsec(time)
-        time.nsec
-      end
-    else
-      def self.time_nsec(time)
-        time.usec * 1000
-      end
-    end
-    
-    # Call String#force_encoding if this version of Ruby has encoding support
-    # otherwise treat as a no-op.
-    if String.method_defined?(:force_encoding)
-      def self.force_encoding(str, encoding)
-        str.force_encoding(encoding)
-      end
-    else
-      def self.force_encoding(str, encoding)
-        str
-      end
-    end
-    
-    
-    # Wrapper for File.open that supports passing hash options for specifying
-    # encodings on Ruby 1.9+. The options are ignored on earlier versions of
-    # Ruby.
-    if RUBY_VERSION =~ /\A1\.[0-8]\./
-      def self.open_file(file_name, mode, opts, &block)
-        File.open(file_name, mode, &block)
-      end
-    elsif RUBY_VERSION =~ /\A1\.9\./
-      def self.open_file(file_name, mode, opts, &block)
-        File.open(file_name, mode, opts, &block)
-      end
-    else
-      # Evaluate method as a string because **opts isn't valid syntax prior to
-      # Ruby 2.0.
-      eval(<<-EOF
-        def self.open_file(file_name, mode, opts, &block)
-          File.open(file_name, mode, **opts, &block)
-        end
-      EOF
-      )
-    end
 
+        # :nocov_functional_untaint:
+      else
+        # :nocov_no_functional_untaint:
 
-    # Object#untaint is a deprecated no-op in Ruby >= 2.7 and will be removed in
-    # 3.2. Add a refinement to either silence the warning, or supply the method
-    # if needed.
-    if !Object.new.respond_to?(:untaint) || RUBY_VERSION =~ /\A(\d+)\.(\d+)(?:\.|\z)/ && ($1 == '2' && $2.to_i >= 7 || $1.to_i >= 3)
-      module UntaintExt
-        refine Object do
-          def untaint
-            self
-          end
+        # Untaints and returns the supplied `Object`.
+        #
+        # @param o [Object] the `Object` to untaint.
+        # @return [Object] `o`.
+        def untaint(o)
+          o.untaint
         end
+
+        # :nocov_no_functional_untaint:
       end
     end
   end
+  private_constant :RubyCoreSupport
 end