tzinfo 2.0.2 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28818edc06842caea3c6a7ee9fc63174498a3fd9f5d065324b3923ba20702ff6
-  data.tar.gz: 1691bcf9786a63c21777f22326f79d27fd2cd6a19dd6cfa269e00bcc58ca394c
+  metadata.gz: 8f5b3120678f9251533f0c044814f666142eb5538412c92c06aa66719251f474
+  data.tar.gz: a837074505ff48d553506e1eeb4eac8e3148cc6aa48e996e552d4d9bde1ef614
 SHA512:
-  metadata.gz: f070f1ae1e08386d00a0825a035d7b7b598b2c9d47cf822be81c5778bcaca47c5541d602cf676aea6d476b49500b13a667a013b80f6bcd69a5acd9691dbba38a
-  data.tar.gz: 2e263e61fa7178427178b6109a31e627b899b17d69c41ecfbb9978e98be7a520ba68b148cf903107ff244947b8b8e43b782daef70e103d2e1b81a416663771a7
+  metadata.gz: f9f43bcf636bc1c3311cc3d417a951dfeb7cc697ad37add1b6b4bbbb0caa0a7226da508ca5c5521d1cf122254ded7ecd4b1da7f6240121dc311b1706c15119d1
+  data.tar.gz: 48314ac805148665c326cc450e2dc96582bb26a2ecc58d97234252c866a162f4f60d2495b6ddaaf3f7b3bd27190d9db452159d58ae57505463a836ce097b5acc

data/CHANGES.md

@@ -1,5 +1,37 @@
 # Changes
 
+## Version 2.0.5 - 19-Jul-2022
+
+* Changed `DateTime` results to always use the proleptic Gregorian calendar.
+  This affects `DateTime` results prior to 1582-10-15 and any arithmetic
+  performed on the results that would produce a secondary result prior to
+  1582-10-15.
+* Added support for eager loading all the time zone and country data by calling
+  either `TZInfo::DataSource#eager_load!` or `TZInfo.eager_load!`. Compatible
+  with Ruby On Rails' `eager_load_namespaces`. #129.
+* Ignore the SECURITY file from Arch Linux's tzdata package. #134.
+
+
+## Version 2.0.4 - 16-Dec-2020
+
+* Fixed an incorrect `InvalidTimezoneIdentifier` exception raised when loading a
+  zoneinfo file that includes rules specifying an additional transition to the
+  final defined offset (for example, Africa/Casablanca in version 2018e of the
+  Time Zone Database). #123.
+
+
+## Version 2.0.3 - 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.
+  #120.
+* Fixed `TimeWithOffset#getlocal` returning a `TimeWithOffset` with the
+  `timezone_offset` still assigned when called with an offset argument on JRuby
+  9.3.
+* Rubinius is no longer supported.
+
+
 ## Version 2.0.2 - 2-Apr-2020
 
 * Fixed 'wrong number of arguments' errors when running on JRuby 9.0. #114.
@@ -162,6 +194,33 @@
   `TZInfo::Country.get('US').zone_identifiers` should be used instead.
 
 
+## Version 1.2.10 - 19-Jul-2022
+
+* Fixed a relative path traversal bug that could cause arbitrary files to be
+  loaded with `require` when used with `RubyDataSource`. Please refer to
+  <https://github.com/tzinfo/tzinfo/security/advisories/GHSA-5cm2-9h8c-rvfx> for
+  details. CVE-2022-31163.
+* Ignore the SECURITY file from Arch Linux's tzdata package. #134.
+
+
+## Version 1.2.9 - 16-Dec-2020
+
+* Fixed an incorrect `InvalidTimezoneIdentifier` exception raised when loading a
+  zoneinfo file that includes rules specifying an additional transition to the
+  final defined offset (for example, Africa/Casablanca in version 2018e of the
+  Time Zone Database). #123.
+
+
+## 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. #120.
+* Rubinius is no longer supported.
+
+
 ## Version 1.2.7 - 2-Apr-2020
 
 * Fixed 'wrong number of arguments' errors when running on JRuby 9.0. #114.
@@ -302,6 +361,52 @@
   use other `TimezonePeriod` instance methods instead (issue #7655).
 
 
+## Version 0.3.61 (tzdata v2022a) - 19-Jul-2022
+
+* Fixed a relative path traversal bug that could cause arbitrary files to be
+  loaded with `require` from the Ruby load path. Please refer to
+  <https://github.com/tzinfo/tzinfo/security/advisories/GHSA-5cm2-9h8c-rvfx> for
+  details. CVE-2022-31163.
+* Updated to tzdata version 2022a
+  (<https://mm.icann.org/pipermail/tz-announce/2022-March/000070.html>).
+
+
+## Version 0.3.60 (tzdata v2021a) - 6-Feb-2021
+
+* Updated to tzdata version 2021a
+  (<https://mm.icann.org/pipermail/tz-announce/2021-January/000065.html>).
+
+
+## Version 0.3.59 (tzdata v2020e) - 24-Dec-2020
+
+* Updated to tzdata version 2020e
+  (<https://mm.icann.org/pipermail/tz-announce/2020-December/000063.html>).
+
+
+## Version 0.3.58 (tzdata v2020d) - 8-Nov-2020
+
+* Updated to tzdata version 2020d
+  (<https://mm.icann.org/pipermail/tz-announce/2020-October/000062.html>).
+
+
+## Version 0.3.57 (tzdata v2020a) - 17-May-2020
+
+* Updated to tzdata version 2020a
+  (<https://mm.icann.org/pipermail/tz-announce/2020-April/000058.html>).
+
+
+## Version 0.3.56 (tzdata v2019c) - 1-Nov-2019
+
+* Updated to tzdata version 2019c
+  (<https://mm.icann.org/pipermail/tz-announce/2019-September/000057.html>).
+
+
+## Version 0.3.55 (tzdata v2018g) - 27-Oct-2018
+
+* Updated to tzdata version 2018g
+  (<https://mm.icann.org/pipermail/tz-announce/2018-October/000052.html>).
+
+
 ## Version 0.3.54 (tzdata v2018d) - 25-Mar-2018
 
 * Updated to tzdata version 2018d

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2020 Philip Ross
+Copyright (c) 2005-2022 Philip Ross
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,6 +1,6 @@
 # TZInfo - Ruby Time Zone Library
 
-[![RubyGems](https://img.shields.io/gem/v/tzinfo)](https://rubygems.org/gems/tzinfo) [![Travis CI Build](https://img.shields.io/travis/tzinfo/tzinfo?logo=travis)](https://travis-ci.org/tzinfo/tzinfo) [![AppVeyor Build](https://img.shields.io/appveyor/build/philr/tzinfo?logo=appveyor)](https://ci.appveyor.com/project/philr/tzinfo)
+[![RubyGems](https://img.shields.io/gem/v/tzinfo?logo=rubygems&label=Gem)](https://rubygems.org/gems/tzinfo) [![Tests](https://github.com/tzinfo/tzinfo/workflows/Tests/badge.svg?branch=master&event=push)](https://github.com/tzinfo/tzinfo/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
 
 [TZInfo](https://tzinfo.github.io) is a Ruby library that provides access to
 time zone data and allows times to be converted using time zone rules.
@@ -36,7 +36,7 @@ documentation for further details.
 ## Installation
 
 The TZInfo gem can be installed by running `gem install tzinfo` or by adding
-to `gem 'tzinfo'` to your `Gemfile` and running `bundle install`.
+`gem 'tzinfo'` to your `Gemfile` and running `bundle install`.
 
 To use the Ruby modules as the data source, TZInfo::Data will also need to be
 installed by running `gem install tzinfo-data` or by adding `gem 'tzinfo-data'`
@@ -368,8 +368,8 @@ claims.
 
 ## Compatibility
 
-TZInfo v2.0.0 requires a minimum of Ruby MRI 1.9.3, JRuby 1.7 (in 1.9 mode or
-later) or Rubinius 3.
+TZInfo v2.0.0 requires a minimum of Ruby MRI 1.9.3 or JRuby 1.7 (in 1.9 mode or
+later).
 
 
 ## Thread-Safety

data/lib/tzinfo/annual_rules.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module TZInfo
+  # A set of rules that define when transitions occur in time zones with
+  # annually occurring daylight savings time.
+  #
+  # @private
+  class AnnualRules #:nodoc:
+    # @return [TimezoneOffset] the standard offset that applies when daylight
+    #   savings time is not in force.
+    attr_reader :std_offset
+
+    # @return [TimezoneOffset] the offset that applies when daylight savings
+    #   time is in force.
+    attr_reader :dst_offset
+
+    # @return [TransitionRule] the rule that determines when daylight savings
+    #   time starts.
+    attr_reader :dst_start_rule
+
+    # @return [TransitionRule] the rule that determines when daylight savings
+    #   time ends.
+    attr_reader :dst_end_rule
+
+    # Initializes a new {AnnualRules} instance.
+    #
+    # @param std_offset [TimezoneOffset] the standard offset that applies when
+    #   daylight savings time is not in force.
+    # @param dst_offset [TimezoneOffset] the offset that applies when daylight
+    #   savings time is in force.
+    # @param dst_start_rule [TransitionRule] the rule that determines when
+    #   daylight savings time starts.
+    # @param dst_end_rule [TransitionRule] the rule that determines when daylight
+    #   savings time ends.
+    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).
+    #
+    # @param year [Integer] the year to calculate transitions for.
+    # @return [Array<TimezoneTransition>] the transitions for the year.
+    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.timestamp_value < start_dst.timestamp_value ? [end_dst, start_dst] : [start_dst, end_dst]
+    end
+
+    private
+
+    # Applies a given rule between offsets on a year.
+    #
+    # @param rule [TransitionRule] the rule to apply.
+    # @param from_offset [TimezoneOffset] the offset the rule transitions from.
+    # @param to_offset [TimezoneOffset] the offset the rule transitions to.
+    # @param year [Integer] the year when the transition occurs.
+    # @return [TimezoneTransition] the transition determined by the rule.
+    def apply_rule(rule, from_offset, to_offset, year)
+      at = rule.at(from_offset, year)
+      TimezoneTransition.new(to_offset, from_offset, at.value)
+    end
+  end
+  private_constant :AnnualRules
+end

data/lib/tzinfo/data_source.rb

@@ -247,6 +247,17 @@ module TZInfo
       raise_invalid_data_source('country_codes')
     end
 
+    # Loads all timezone and country data into memory.
+    #
+    # This may be desirable in production environments to improve copy-on-write
+    # performance and to avoid flushing the constant cache every time a new
+    # timezone or country is loaded from {DataSources::RubyDataSource}.
+    def eager_load!
+      timezone_identifiers.each {|identifier| load_timezone_info(identifier) }
+      country_codes.each {|code| load_country_info(code) }
+      nil
+    end
+
     # @return [String] a description of the {DataSource}.
     def to_s
       "Default DataSource"

data/lib/tzinfo/data_sources/posix_time_zone_parser.rb

@@ -0,0 +1,181 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'strscan'
+
+module TZInfo
+  # Use send as a workaround for erroneous 'wrong number of arguments' errors
+  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
+  send(:using, UntaintExt) if TZInfo.const_defined?(:UntaintExt)
+
+  module DataSources
+    # An {InvalidPosixTimeZone} exception is raised if an invalid POSIX-style
+    # time zone string is encountered.
+    #
+    # @private
+    class InvalidPosixTimeZone < StandardError #:nodoc:
+    end
+    private_constant :InvalidPosixTimeZone
+
+    # A parser for POSIX-style TZ strings used in zoneinfo files and specified
+    # by tzfile.5 and tzset.3.
+    #
+    # @private
+    class PosixTimeZoneParser #:nodoc:
+      # Initializes a new {PosixTimeZoneParser}.
+      #
+      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
+      #   to dedupe abbreviations.
+      def initialize(string_deduper)
+        @string_deduper = string_deduper
+      end
+
+      # Parses a POSIX-style TZ string.
+      #
+      # @param tz_string [String] the string to parse.
+      # @return [Object] either a {TimezoneOffset} for a constantly applied
+      #   offset or an {AnnualRules} instance representing the rules.
+      # @raise [InvalidPosixTimeZone] if `tz_string` is not a `String`.
+      # @raise [InvalidPosixTimeZone] if `tz_string` is is not valid.
+      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 = @string_deduper.dedupe((s[1] || s[2]).untaint)
+        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 = @string_deduper.dedupe((s[1] || s[2]).untaint)
+
+          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)
+          else
+            AnnualRules.new(
+              TimezoneOffset.new(-std_offset, 0, std_abbrev),
+              TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev),
+              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)
+        else
+          raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'."
+        end
+      end
+
+      private
+
+      # Parses a rule.
+      #
+      # @param s [StringScanner] the `StringScanner` to read the rule from.
+      # @param type [String] the type of rule (either `'start'` or `'end'`).
+      # @raise [InvalidPosixTimeZone] if the rule is not valid.
+      # @return [TransitionRule] the parsed rule.
+      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.
+      #
+      # @param h [String] the hours.
+      # @param m [String] the minutes.
+      # @param s [String] the seconds.
+      # @return [Integer] the offset.
+      # @raise [InvalidPosixTimeZone] if the mm and ss values are greater than
+      #   59.
+      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.
+      #
+      # @param h [String] the hour.
+      # @param m [String] the minutes past the hour.
+      # @param s [String] the seconds past the minute.
+      # @return [Integer] the number of seconds after midnight.
+      # @raise [InvalidPosixTimeZone] if the mm and ss values are greater than
+      #   59.
+      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.
+      #
+      # @param s [StringScanner] the `StringScanner` to scan.
+      # @param pattern [Regexp] the pattern to match.
+      # @return [String] the result of the scan.
+      # @raise [InvalidPosixTimeZone] 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
+    private_constant :PosixTimeZoneParser
+  end
+end

data/lib/tzinfo/data_sources/ruby_data_source.rb

@@ -116,14 +116,14 @@ module TZInfo
       # @param identifier [Array<string>] the component parts of a time zone
       #   identifier (split on /). This must have already been validated.
       def require_definition(identifier)
-        require_data(*(['definitions'] + identifier))
+        require_data('definitions', *identifier)
       end
 
       # Requires an index by its name.
       #
       # @param name [String] an index name.
       def require_index(name)
-        require_data(*['indexes', name])
+        require_data('indexes', name)
       end
 
       # Requires a file from tzinfo/data.

data/lib/tzinfo/data_sources/zoneinfo_data_source.rb

@@ -78,6 +78,30 @@ module TZInfo
       DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = ['/usr/share/misc/iso3166.tab', '/usr/share/misc/iso3166'].freeze
       private_constant :DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH
 
+      # Files and directories in the top level zoneinfo directory that will be
+      # excluded from the list of available time zones:
+      #
+      #   - +VERSION is included on Mac OS X.
+      #   - leapseconds is a list of leap seconds.
+      #   - localtime is the current local timezone (may be a link).
+      #   - posix, posixrules and right are directories containing other
+      #     versions of the zoneinfo files.
+      #   - SECURITY is included in the Arch Linux tzdata package.
+      #   - src is a directory containing the tzdata source included on Solaris.
+      #   - timeconfig is a symlink included on Slackware.
+      EXCLUDED_FILENAMES = [
+        '+VERSION',
+        'leapseconds',
+        'localtime',
+        'posix',
+        'posixrules',
+        'right',
+        'SECURITY',
+        'src',
+        'timeconfig'
+      ].freeze
+      private_constant :EXCLUDED_FILENAMES
+
       # Paths to be checked to find the system zoneinfo directory.
       #
       # @private
@@ -237,7 +261,10 @@ module TZInfo
         @timezone_identifiers = load_timezone_identifiers.freeze
         @countries = load_countries(iso3166_tab_path, zone_tab_path).freeze
         @country_codes = @countries.keys.sort!.freeze
-        @zoneinfo_reader = ZoneinfoReader.new(ConcurrentStringDeduper.new)
+
+        string_deduper = ConcurrentStringDeduper.new
+        posix_tz_parser = PosixTimeZoneParser.new(string_deduper)
+        @zoneinfo_reader = ZoneinfoReader.new(posix_tz_parser, string_deduper)
       end
 
       # Returns a frozen `Array` of all the available time zone identifiers. The
@@ -391,15 +418,7 @@ module TZInfo
       def load_timezone_identifiers
         index = []
 
-        # Ignoring particular files:
-        # +VERSION is included on Mac OS X.
-        # leapseconds is a list of leap seconds.
-        # localtime is the current local timezone (may be a link).
-        # posix, posixrules and right are directories containing other versions of the zoneinfo files.
-        # src is a directory containing the tzdata source included on Solaris.
-        # timeconfig is a symlink included on Slackware.
-
-        enum_timezones([], ['+VERSION', 'leapseconds', 'localtime', 'posix', 'posixrules', 'right', 'src', 'timeconfig']) do |identifier|
+        enum_timezones([], EXCLUDED_FILENAMES) do |identifier|
           index << identifier.join('/').freeze
         end