tzinfo 1.2.7 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b964ab83943597cb8ce6f141378398fe1bc4fe4b767dd9434f04030332b008
-  data.tar.gz: bcdda83a2bfc8e90d0f62a8ddab56f6de246c2c44b64cc00347838f64fc28a87
+  metadata.gz: 9569ae7387d4f2847ba35f6a1268fbbc9019f9bbef1cc72e70569757320db079
+  data.tar.gz: bb66169c01610b980c35be5c7102d780d07167b785acd6ea5887b89d15eb107d
 SHA512:
-  metadata.gz: 7921a1c86b6307ee7b554edc6de33d2ed07ca8660c804f3ca78099485a72e26bcd23af498a955dfd7dfa5efb0c2f95e6adbdadbd0d60ef492732f1fdfd79f0d9
-  data.tar.gz: a0b59904238b08bbebc38a359db873dfadc0a98ef7a2fb6241f91219c642432dc8ae643ff0cf844d16bae0ef61173bac16c5f69863cde60fe504105d4240f48f
+  metadata.gz: d9847f779c051d96c2457d364b18bdc9bc74e9b17ffd8e84106ce9c6562b2634e60f08b81af9fff6ba7c0af3b898ba4483fe8e9fa31b3e004251b203c1bee933
+  data.tar.gz: 8737907d69e81c06650a1f01b1ba45afc83f38a66b44fca093431cfea65208a92f56ada755e9f87724a6b866ecbfed11d1ef09552bbf983ce47c15c90269a322

data/CHANGES.md

@@ -1,3 +1,14 @@
+Version 1.2.8 - 8-Nov-2020
+--------------------------
+
+* Added support for handling "slim" format zoneinfo files that are produced by
+  default by zic version 2020b and later. The POSIX-style TZ string is now used
+  calculate DST transition times after the final defined transition in the file.
+  The 64-bit section is now always used regardless of whether Time has support
+  for 64-bit times.
+* Rubinius is no longer supported.
+
+
 Version 1.2.7 - 2-Apr-2020
 --------------------------
 

data/README.md

@@ -1,7 +1,7 @@
 TZInfo - Ruby Timezone Library
 ==============================
 
-[![RubyGems](https://img.shields.io/gem/v/tzinfo)](https://rubygems.org/gems/tzinfo) [![Travis CI Build](https://img.shields.io/travis/tzinfo/tzinfo/1.2?logo=travis)](https://travis-ci.org/tzinfo/tzinfo) [![AppVeyor Build](https://img.shields.io/appveyor/build/philr/tzinfo/1.2?logo=appveyor)](https://ci.appveyor.com/project/philr/tzinfo/branch/1.2)
+[![RubyGems](https://img.shields.io/gem/v/tzinfo)](https://rubygems.org/gems/tzinfo) [![Travis CI Build](https://img.shields.io/travis/com/tzinfo/tzinfo/1.2?logo=travis)](https://travis-ci.com/tzinfo/tzinfo) [![AppVeyor Build](https://img.shields.io/appveyor/build/philr/tzinfo/1.2?logo=appveyor)](https://ci.appveyor.com/project/philr/tzinfo/branch/1.2)
 
 [TZInfo](https://tzinfo.github.io) provides daylight savings aware
 transformations between times in different timezones.

data/lib/tzinfo.rb

@@ -10,6 +10,8 @@ require 'tzinfo/timezone_definition'
 
 require 'tzinfo/timezone_offset'
 require 'tzinfo/timezone_transition'
+require 'tzinfo/transition_rule'
+require 'tzinfo/annual_rules'
 require 'tzinfo/timezone_transition_definition'
 
 require 'tzinfo/timezone_index_definition'
@@ -22,6 +24,7 @@ require 'tzinfo/zoneinfo_timezone_info'
 
 require 'tzinfo/data_source'
 require 'tzinfo/ruby_data_source'
+require 'tzinfo/posix_time_zone_parser'
 require 'tzinfo/zoneinfo_data_source'
 
 require 'tzinfo/timezone_period'

data/lib/tzinfo/annual_rules.rb

@@ -0,0 +1,51 @@
+module TZInfo
+  # A set of rules that define when transitions occur in time zones with
+  # annually occurring daylight savings time.
+  #
+  # @private
+  class AnnualRules #:nodoc:
+    # Returned by #transitions. #offset is the TimezoneOffset that applies
+    # from the UTC TimeOrDateTime #at. #previous_offset is the prior
+    # TimezoneOffset.
+    Transition = Struct.new(:offset, :previous_offset, :at)
+
+    # The standard offset that applies when daylight savings time is not in
+    # force.
+    attr_reader :std_offset
+
+    # The offset that applies when daylight savings time is in force.
+    attr_reader :dst_offset
+
+    # The rule that determines when daylight savings time starts.
+    attr_reader :dst_start_rule
+
+    # The rule that determines when daylight savings time ends.
+    attr_reader :dst_end_rule
+
+    # Initializes a new {AnnualRules} instance.
+    def initialize(std_offset, dst_offset, dst_start_rule, dst_end_rule)
+      @std_offset = std_offset
+      @dst_offset = dst_offset
+      @dst_start_rule = dst_start_rule
+      @dst_end_rule = dst_end_rule
+    end
+
+    # Returns the transitions between standard and daylight savings time for a
+    # given year. The results are ordered by time of occurrence (earliest to
+    # latest).
+    def transitions(year)
+      start_dst = apply_rule(@dst_start_rule, @std_offset, @dst_offset, year)
+      end_dst = apply_rule(@dst_end_rule, @dst_offset, @std_offset, year)
+
+      end_dst.at < start_dst.at ? [end_dst, start_dst] : [start_dst, end_dst]
+    end
+
+    private
+
+    # Applies a given rule between offsets on a year.
+    def apply_rule(rule, from_offset, to_offset, year)
+      at = rule.at(from_offset, year)
+      Transition.new(to_offset, from_offset, at)
+    end
+  end
+end

data/lib/tzinfo/posix_time_zone_parser.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'strscan'
+
+module TZInfo
+  # An {InvalidPosixTimeZone} exception is raised if an invalid POSIX-style
+  # time zone string is encountered.
+  #
+  # @private
+  class InvalidPosixTimeZone < StandardError #:nodoc:
+  end
+
+  # A parser for POSIX-style TZ strings used in zoneinfo files and specified
+  # by tzfile.5 and tzset.3.
+  #
+  # @private
+  class PosixTimeZoneParser #:nodoc:
+    # Parses a POSIX-style TZ string, returning either a TimezoneOffset or
+    # an AnnualRules instance.
+    def parse(tz_string)
+      raise InvalidPosixTimeZone unless tz_string.kind_of?(String)
+      return nil if tz_string.empty?
+
+      s = StringScanner.new(tz_string)
+      check_scan(s, /([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
+      std_abbrev = s[1] || s[2]
+      check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+      std_offset = get_offset_from_hms(s[1], s[2], s[3])
+
+      if s.scan(/([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
+        dst_abbrev = s[1] || s[2]
+
+        if s.scan(/([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+          dst_offset = get_offset_from_hms(s[1], s[2], s[3])
+        else
+          # POSIX is negative for ahead of UTC.
+          dst_offset = std_offset - 3600
+        end
+
+        dst_difference = std_offset - dst_offset
+
+        start_rule = parse_rule(s, 'start')
+        end_rule = parse_rule(s, 'end')
+
+        raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'." if s.rest?
+
+        if start_rule.is_always_first_day_of_year? && start_rule.transition_at == 0 &&
+              end_rule.is_always_last_day_of_year? && end_rule.transition_at == 86400 + dst_difference
+          # Constant daylight savings time.
+          # POSIX is negative for ahead of UTC.
+          TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev.to_sym)
+        else
+          AnnualRules.new(
+            TimezoneOffset.new(-std_offset, 0, std_abbrev.to_sym),
+            TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev.to_sym),
+            start_rule,
+            end_rule)
+        end
+      elsif !s.rest?
+        # Constant standard time.
+        # POSIX is negative for ahead of UTC.
+        TimezoneOffset.new(-std_offset, 0, std_abbrev.to_sym)
+      else
+        raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'."
+      end
+    end
+
+    private
+
+    # Parses the rule from the TZ string, returning a TransitionRule.
+    def parse_rule(s, type)
+      check_scan(s, /,(?: (?: J(\d+) ) | (\d+) | (?: M(\d+)\.(\d)\.(\d) ) )/x)
+      julian_day_of_year = s[1]
+      absolute_day_of_year = s[2]
+      month = s[3]
+      week = s[4]
+      day_of_week = s[5]
+
+      if s.scan(/\//)
+        check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+        transition_at = get_seconds_after_midnight_from_hms(s[1], s[2], s[3])
+      else
+        transition_at = 7200
+      end
+
+      begin
+        if julian_day_of_year
+          JulianDayOfYearTransitionRule.new(julian_day_of_year.to_i, transition_at)
+        elsif absolute_day_of_year
+          AbsoluteDayOfYearTransitionRule.new(absolute_day_of_year.to_i, transition_at)
+        elsif week == '5'
+          LastDayOfMonthTransitionRule.new(month.to_i, day_of_week.to_i, transition_at)
+        else
+          DayOfMonthTransitionRule.new(month.to_i, week.to_i, day_of_week.to_i, transition_at)
+        end
+      rescue ArgumentError => e
+        raise InvalidPosixTimeZone, "Invalid #{type} rule in POSIX-style time zone string: #{e}"
+      end
+    end
+
+    # Returns an offset in seconds from hh:mm:ss values. The value can be
+    # negative. -02:33:12 would represent 2 hours, 33 minutes and 12 seconds
+    # ahead of UTC.
+    def get_offset_from_hms(h, m, s)
+      h = h.to_i
+      m = m.to_i
+      s = s.to_i
+      raise InvalidPosixTimeZone, "Invalid minute #{m} in offset for POSIX-style time zone string." if m > 59
+      raise InvalidPosixTimeZone, "Invalid second #{s} in offset for POSIX-style time zone string." if s > 59
+      magnitude = (h.abs * 60 + m) * 60 + s
+      h < 0 ? -magnitude : magnitude
+    end
+
+    # Returns the seconds from midnight from hh:mm:ss values. Hours can exceed
+    # 24 for a time on the following day. Hours can be negative to subtract
+    # hours from midnight on the given day. -02:33:12 represents 22:33:12 on
+    # the prior day.
+    def get_seconds_after_midnight_from_hms(h, m, s)
+      h = h.to_i
+      m = m.to_i
+      s = s.to_i
+      raise InvalidPosixTimeZone, "Invalid minute #{m} in time for POSIX-style time zone string." if m > 59
+      raise InvalidPosixTimeZone, "Invalid second #{s} in time for POSIX-style time zone string." if s > 59
+      (h * 3600) + m * 60 + s
+    end
+
+    # Scans for a pattern and raises an exception if the pattern does not
+    # match the input.
+    def check_scan(s, pattern)
+      result = s.scan(pattern)
+      raise InvalidPosixTimeZone, "Expected '#{s.rest}' to match #{pattern} in POSIX-style time zone string." unless result
+      result
+    end
+  end
+end

data/lib/tzinfo/time_or_datetime.rb

@@ -160,6 +160,17 @@ module TZInfo
       end
     end
     alias :day :mday
+
+    # Returns the day of the week (0..6 for Sunday to Saturday).
+    def wday
+      if @time
+        @time.wday
+      elsif @datetime
+        @datetime.wday
+      else
+        to_time.wday
+      end
+    end
     
     # Returns the hour of the day (0..23).
     def hour

data/lib/tzinfo/transition_rule.rb

@@ -0,0 +1,325 @@
+require 'date'
+
+module TZInfo
+  # Base class for rules definining the transition between standard and daylight
+  # savings time.
+  class TransitionRule #:nodoc:
+    # Returns the number of seconds after midnight local time on the day
+    # identified by the rule at which the transition occurs. Can be negative to
+    # denote a time on the prior day. Can be greater than or equal to 86,400 to
+    # denote a time of the following day.
+    attr_reader :transition_at
+
+    # Initializes a new TransitionRule.
+    def initialize(transition_at)
+      raise ArgumentError, 'Invalid transition_at' unless transition_at.kind_of?(Integer)
+      @transition_at = transition_at
+    end
+
+    # Calculates the UTC time of the transition from a given offset on a given
+    # year.
+    def at(offset, year)
+      day = get_day(year)
+      day.add_with_convert(@transition_at - offset.utc_total_offset)
+    end
+
+    # Determines if this TransitionRule is equal to another instance.
+    def ==(r)
+      r.kind_of?(TransitionRule) && @transition_at == r.transition_at
+    end
+    alias eql? ==
+
+    # Returns a hash based on hash_args (defaulting to transition_at).
+    def hash
+      hash_args.hash
+    end
+
+    protected
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@transition_at]
+    end
+
+    def new_time_or_datetime(year, month = 1, day = 1)
+      result = if ((year >= 2039 || (year == 2038 && (month >= 2 || (month == 1 && day >= 20)))) && !RubyCoreSupport.time_supports_64bit) ||
+        (year < 1970 && !RubyCoreSupport.time_supports_negative)
+
+        # Time handles 29 February on a non-leap year as 1 March.
+        # DateTime rejects. Advance manually.
+        if month == 2 && day == 29 && !Date.gregorian_leap?(year)
+          month = 3
+          day = 1
+        end
+
+        RubyCoreSupport.datetime_new(year, month, day)
+      else
+        Time.utc(year, month, day)
+      end
+
+      TimeOrDateTime.wrap(result)
+    end
+  end
+
+  # A base class for transition rules that activate based on an integer day of
+  # the year.
+  #
+  # @private
+  class DayOfYearTransitionRule < TransitionRule #:nodoc:
+    # Initializes a new DayOfYearTransitionRule.
+    def initialize(day, transition_at)
+      super(transition_at)
+      raise ArgumentError, 'Invalid day' unless day.kind_of?(Integer)
+      @seconds = day * 86400
+    end
+
+    # Determines if this DayOfYearTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfYearTransitionRule) && @seconds == r.seconds
+    end
+    alias eql? ==
+
+    protected
+
+    # @return [Integer] the day multipled by the number of seconds in a day.
+    attr_reader :seconds
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@seconds] + super
+    end
+  end
+
+  # Defines transitions that occur on the zero-based nth day of the year.
+  #
+  # Day 0 is 1 January.
+  #
+  # Leap days are counted. Day 59 will be 29 February on a leap year and 1 March
+  # on a non-leap year. Day 365 will be 31 December on a leap year and 1 January
+  # the following year on a non-leap year.
+  #
+  # @private
+  class AbsoluteDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
+    # Initializes a new AbsoluteDayOfYearTransitionRule.
+    def initialize(day, transition_at = 0)
+      super(day, transition_at)
+      raise ArgumentError, 'Invalid day' unless day >= 0 && day <= 365
+    end
+
+    # Returns true if the day specified by this transition is the first in the
+    # year (a day number of 0), otherwise false.
+    def is_always_first_day_of_year?
+      seconds == 0
+    end
+
+    # @returns false.
+    def is_always_last_day_of_year?
+      false
+    end
+
+    # Determines if this AbsoluteDayOfYearTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(AbsoluteDayOfYearTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      new_time_or_datetime(year).add_with_convert(seconds)
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [AbsoluteDayOfYearTransitionRule] + super
+    end
+  end
+
+  # Defines transitions that occur on the one-based nth Julian day of the year.
+  #
+  # Leap days are not counted. Day 1 is 1 January. Day 60 is always 1 March.
+  # Day 365 is always 31 December.
+  #
+  # @private
+  class JulianDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
+    # The 60 days in seconds.
+    LEAP = 60 * 86400
+
+    # The length of a non-leap year in seconds.
+    YEAR = 365 * 86400
+
+    # Initializes a new JulianDayOfYearTransitionRule.
+    def initialize(day, transition_at = 0)
+      super(day, transition_at)
+      raise ArgumentError, 'Invalid day' unless day >= 1 && day <= 365
+    end
+
+    # Returns true if the day specified by this transition is the first in the
+    # year (a day number of 1), otherwise false.
+    def is_always_first_day_of_year?
+      seconds == 86400
+    end
+
+    # Returns true if the day specified by this transition is the last in the
+    # year (a day number of 365), otherwise false.
+    def is_always_last_day_of_year?
+      seconds == YEAR
+    end
+
+    # Determines if this JulianDayOfYearTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(JulianDayOfYearTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      # Returns 1 March on non-leap years.
+      leap = new_time_or_datetime(year, 2, 29)
+      diff = seconds - LEAP
+      diff += 86400 if diff >= 0 && leap.mday == 29
+      leap.add_with_convert(diff)
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [JulianDayOfYearTransitionRule] + super
+    end
+  end
+
+  # A base class for rules that transition on a particular day of week of a
+  # given week (subclasses specify which week of the month).
+  #
+  # @private
+  class DayOfWeekTransitionRule < TransitionRule #:nodoc:
+    # Initializes a new DayOfWeekTransitionRule.
+    def initialize(month, day_of_week, transition_at)
+      super(transition_at)
+      raise ArgumentError, 'Invalid month' unless month.kind_of?(Integer) && month >= 1 && month <= 12
+      raise ArgumentError, 'Invalid day_of_week' unless day_of_week.kind_of?(Integer) && day_of_week >= 0 && day_of_week <= 6
+      @month = month
+      @day_of_week = day_of_week
+    end
+
+    # Returns false.
+    def is_always_first_day_of_year?
+      false
+    end
+
+    # Returns false.
+    def is_always_last_day_of_year?
+      false
+    end
+
+    # Determines if this DayOfWeekTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfWeekTransitionRule) && @month == r.month && @day_of_week == r.day_of_week
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns the month of the year (1 to 12).
+    attr_reader :month
+
+    # Returns the day of the week (0 to 6 for Sunday to Monday).
+    attr_reader :day_of_week
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@month, @day_of_week] + super
+    end
+  end
+
+  # A rule that transitions on the nth occurrence of a particular day of week
+  # of a calendar month.
+  #
+  # @private
+  class DayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
+    # Initializes a new DayOfMonthTransitionRule.
+    def initialize(month, week, day_of_week, transition_at = 0)
+      super(month, day_of_week, transition_at)
+      raise ArgumentError, 'Invalid week' unless week.kind_of?(Integer) && week >= 1 && week <= 4
+      @offset_start = (week - 1) * 7 + 1
+    end
+
+    # Determines if this DayOfMonthTransitionRule is equal to another instance.
+    def ==(r)
+      super(r) && r.kind_of?(DayOfMonthTransitionRule) && @offset_start == r.offset_start
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns the day the week starts on for a month starting on a Sunday.
+    attr_reader :offset_start
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      candidate = new_time_or_datetime(year, month, @offset_start)
+      diff = day_of_week - candidate.wday
+
+      if diff < 0
+        candidate.add_with_convert((7 + diff) * 86400)
+      elsif diff > 0
+        candidate.add_with_convert(diff * 86400)
+      else
+        candidate
+      end
+    end
+
+    # Returns an Array of parameters that will influence the output of hash.
+    def hash_args
+      [@offset_start] + super
+    end
+  end
+
+  # A rule that transitions on the last occurrence of a particular day of week
+  # of a calendar month.
+  #
+  # @private
+  class LastDayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
+    # Initializes a new LastDayOfMonthTransitionRule.
+    def initialize(month, day_of_week, transition_at = 0)
+      super(month, day_of_week, transition_at)
+    end
+
+    # Determines if this LastDayOfMonthTransitionRule is equal to another
+    # instance.
+    def ==(r)
+      super(r) && r.kind_of?(LastDayOfMonthTransitionRule)
+    end
+    alias eql? ==
+
+    protected
+
+    # Returns a TimeOrDateTime representing midnight local time on the day
+    # specified by the rule for the given offset and year.
+    def get_day(year)
+      next_month = month + 1
+      if next_month == 13
+        year += 1
+        next_month = 1
+      end
+
+      candidate = new_time_or_datetime(year, next_month).add_with_convert(-86400)
+      diff = candidate.wday - day_of_week
+
+      if diff < 0
+        candidate - (diff + 7) * 86400
+      elsif diff > 0
+        candidate - diff * 86400
+      else
+        candidate
+      end
+    end
+  end
+end