tzinfo 2.0.2 → 2.0.5

data/lib/tzinfo/data_sources/zoneinfo_reader.rb

@@ -14,11 +14,20 @@ module TZInfo
 
     # Reads compiled zoneinfo TZif (\0, 2 or 3) files.
     class ZoneinfoReader #:nodoc:
+      # The year to generate transitions up to.
+      #
+      # @private
+      GENERATE_UP_TO = Time.now.utc.year + 100
+      private_constant :GENERATE_UP_TO
+
       # Initializes a new {ZoneinfoReader}.
       #
+      # @param posix_tz_parser [PosixTimeZoneParser] a {PosixTimeZoneParser}
+      #   instance to use to parse POSIX-style TZ strings.
       # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
-      #   when deduping abbreviations.
-      def initialize(string_deduper)
+      #   to dedupe abbreviations.
+      def initialize(posix_tz_parser, string_deduper)
+        @posix_tz_parser = posix_tz_parser
         @string_deduper = string_deduper
       end
 
@@ -163,6 +172,171 @@ module TZInfo
         first_offset_index
       end
 
+      # Determines if the offset from a transition matches the offset from a
+      # rule. This is a looser match than equality, not requiring that the
+      # base_utc_offset and std_offset both match (which have to be derived for
+      # transitions, but are known for rules.
+      #
+      # @param offset [TimezoneOffset] an offset from a transition.
+      # @param rule_offset [TimezoneOffset] an offset from a rule.
+      # @return [Boolean] whether the offsets match.
+      def offset_matches_rule?(offset, rule_offset)
+        offset.observed_utc_offset == rule_offset.observed_utc_offset &&
+          offset.dst? == rule_offset.dst? &&
+          offset.abbreviation == rule_offset.abbreviation
+      end
+
+      # Apply the rules from the TZ string when there were no defined
+      # transitions. Checks for a matching offset. Returns the rules-based
+      # constant offset or generates transitions from 1970 until 100 years into
+      # the future (at the time of loading zoneinfo_reader.rb).
+      #
+      # @param file [IO] the file being processed.
+      # @param first_offset [TimezoneOffset] the first offset included in the
+      #   file that would normally apply without the rules.
+      # @param rules [Object] a {TimezoneOffset} specifying a constant offset or
+      #   {AnnualRules} instance specfying transitions.
+      # @return [Object] either a {TimezoneOffset} or an `Array` of
+      #   {TimezoneTransition}s.
+      # @raise [InvalidZoneinfoFile] if the first offset does not match the
+      #   rules.
+      def apply_rules_without_transitions(file, first_offset, rules)
+        if rules.kind_of?(TimezoneOffset)
+          unless offset_matches_rule?(first_offset, rules)
+            raise InvalidZoneinfoFile, "Constant offset POSIX-style TZ string does not match constant offset in file '#{file.path}'."
+          end
+          rules
+        else
+          transitions = 1970.upto(GENERATE_UP_TO).flat_map {|y| rules.transitions(y) }
+          first_transition = transitions[0]
+
+          unless offset_matches_rule?(first_offset, first_transition.previous_offset)
+            # Not transitioning from the designated first offset.
+
+            if offset_matches_rule?(first_offset, first_transition.offset)
+              # Skip an unnecessary transition to the first offset.
+              transitions.shift
+            else
+              # The initial offset doesn't match the ongoing rules. Replace the
+              # previous offset of the first transition.
+              transitions[0] = TimezoneTransition.new(first_transition.offset, first_offset, first_transition.timestamp_value)
+            end
+          end
+
+          transitions
+        end
+      end
+
+      # Finds an offset that is equivalent to the one specified in the given
+      # `Array`. Matching is performed with {TimezoneOffset#==}.
+      #
+      # @param offsets [Array<TimezoneOffset>] an `Array` to search.
+      # @param offset [TimezoneOffset] the offset to search for.
+      # @return [TimezoneOffset] the matching offset from `offsets` or `nil`
+      #   if not found.
+      def find_existing_offset(offsets, offset)
+        offsets.find {|o| o == offset }
+      end
+
+      # Returns a new AnnualRules instance with standard and daylight savings
+      # offsets replaced with equivalents from an array. This reduces the memory
+      # requirement for loaded time zones by reusing offsets for rule-generated
+      # transitions.
+      #
+      # @param offsets [Array<TimezoneOffset>] an `Array` to search for
+      #   equivalent offsets.
+      # @param annual_rules [AnnualRules] the {AnnualRules} instance to check.
+      # @return [AnnualRules] either a new {AnnualRules} instance with either
+      #   the {AnnualRules#std_offset std_offset} or {AnnualRules#dst_offset
+      #   dst_offset} replaced, or the original instance if no equivalent for
+      #   either {AnnualRules#std_offset std_offset} or {AnnualRules#dst_offset
+      #   dst_offset} could be found.
+      def replace_with_existing_offsets(offsets, annual_rules)
+        existing_std_offset = find_existing_offset(offsets, annual_rules.std_offset)
+        existing_dst_offset = find_existing_offset(offsets, annual_rules.dst_offset)
+        if existing_std_offset || existing_dst_offset
+          AnnualRules.new(existing_std_offset || annual_rules.std_offset, existing_dst_offset || annual_rules.dst_offset,
+            annual_rules.dst_start_rule, annual_rules.dst_end_rule)
+        else
+          annual_rules
+        end
+      end
+
+      # Validates the offset indicated to be observed by the rules before the
+      # first generated transition against the offset of the last defined
+      # transition.
+      #
+      # Fix the last defined transition if it differ on just base/std offsets
+      # (which are derived). Raise an error if the observed UTC offset or
+      # abbreviations differ.
+      #
+      # @param file [IO] the file being processed.
+      # @param last_defined [TimezoneTransition] the last defined transition in
+      #   the file.
+      # @param first_rule_offset [TimezoneOffset] the offset the rules indicate
+      #   is observed prior to the first rules generated transition.
+      # @return [TimezoneTransition] the last defined transition (either the
+      #   original instance or a replacement).
+      # @raise [InvalidZoneinfoFile] if the offset of {last_defined} and
+      #   {first_rule_offset} do not match.
+      def validate_and_fix_last_defined_transition_offset(file, last_defined, first_rule_offset)
+        offset_of_last_defined = last_defined.offset
+
+        if offset_of_last_defined == first_rule_offset
+          last_defined
+        else
+          if offset_matches_rule?(offset_of_last_defined, first_rule_offset)
+            # The same overall offset, but differing in the base or std
+            # offset (which are derived). Correct by using the rule.
+            TimezoneTransition.new(first_rule_offset, last_defined.previous_offset, last_defined.timestamp_value)
+          else
+            raise InvalidZoneinfoFile, "The first offset indicated by the POSIX-style TZ string did not match the final defined offset in file '#{file.path}'."
+          end
+        end
+      end
+
+      # Apply the rules from the TZ string when there were defined
+      # transitions. Checks for a matching offset with the last transition.
+      # Redefines the last transition if required and if the rules don't
+      # specific a constant offset, generates transitions until 100 years into
+      # the future (at the time of loading zoneinfo_reader.rb).
+      #
+      # @param file [IO] the file being processed.
+      # @param transitions [Array<TimezoneTransition>] the defined transitions.
+      # @param offsets [Array<TimezoneOffset>] the offsets used by the defined
+      #   transitions.
+      # @param rules [Object] a {TimezoneOffset} specifying a constant offset or
+      #   {AnnualRules} instance specfying transitions.
+      # @raise [InvalidZoneinfoFile] if the first offset does not match the
+      #   rules.
+      # @raise [InvalidZoneinfoFile] if the previous offset of the first
+      #   generated transition does not match the offset of the last defined
+      #   transition.
+      def apply_rules_with_transitions(file, transitions, offsets, rules)
+        last_defined = transitions[-1]
+
+        if rules.kind_of?(TimezoneOffset)
+          transitions[-1] = validate_and_fix_last_defined_transition_offset(file, last_defined, rules)
+        else
+          last_year = last_defined.local_end_at.to_time.year
+
+          if last_year <= GENERATE_UP_TO
+            rules = replace_with_existing_offsets(offsets, rules)
+
+            generated = rules.transitions(last_year).find_all do |t|
+              t.timestamp_value > last_defined.timestamp_value && !offset_matches_rule?(last_defined.offset, t.offset)
+            end
+
+            generated += (last_year + 1).upto(GENERATE_UP_TO).flat_map {|y| rules.transitions(y) }
+
+            unless generated.empty?
+              transitions[-1] = validate_and_fix_last_defined_transition_offset(file, last_defined, generated[0].previous_offset)
+              transitions.concat(generated)
+            end
+          end
+        end
+      end
+
       # Parses a zoneinfo file and returns either a {TimezoneOffset} that is
       # constantly observed or an `Array` of {TimezoneTransition}s.
       #
@@ -171,7 +345,7 @@ module TZInfo
       #   {TimezoneTransition}s.
       # @raise [InvalidZoneinfoFile] if the file is not a valid zoneinfo file.
       def parse(file)
-        magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
+        magic, version, ttisutccnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
           check_read(file, 44).unpack('a4 a x15 NNNNNN')
 
         if magic != 'TZif'
@@ -180,11 +354,11 @@ module TZInfo
 
         if version == '2' || version == '3'
           # Skip the first 32-bit section and read the header of the second 64-bit section
-          file.seek(timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + ttisgmtcnt + ttisstdcnt, IO::SEEK_CUR)
+          file.seek(timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + ttisstdcnt + ttisutccnt, IO::SEEK_CUR)
 
           prev_version = version
 
-          magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
+          magic, version, ttisutccnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
             check_read(file, 44).unpack('a4 a x15 NNNNNN')
 
           unless magic == 'TZif' && (version == prev_version)
@@ -229,6 +403,23 @@ module TZInfo
 
         abbrev = check_read(file, charcnt)
 
+        if using_64bit
+          # Skip to the POSIX-style TZ string.
+          file.seek(ttisstdcnt + ttisutccnt, IO::SEEK_CUR) # + leapcnt * 8, but leapcnt is checked above and guaranteed to be 0.
+          tz_string_start = check_read(file, 1)
+          raise InvalidZoneinfoFile, "Expected newline starting POSIX-style TZ string in file '#{file.path}'." unless tz_string_start == "\n"
+          tz_string = file.readline("\n").force_encoding(Encoding::UTF_8)
+          raise InvalidZoneinfoFile, "Expected newline ending POSIX-style TZ string in file '#{file.path}'." unless tz_string.chomp!("\n")
+
+          begin
+            rules = @posix_tz_parser.parse(tz_string)
+          rescue InvalidPosixTimeZone => e
+            raise InvalidZoneinfoFile, "Failed to parse POSIX-style TZ string in file '#{file.path}': #{e}"
+          end
+        else
+          rules = nil
+        end
+
         # Derive the offsets from standard time (std_offset).
         first_offset_index = derive_offsets(transitions, offsets)
 
@@ -266,12 +457,16 @@ module TZInfo
 
 
         if transitions.empty?
-          first_offset
+          if rules
+            apply_rules_without_transitions(file, first_offset, rules)
+          else
+            first_offset
+          end
         else
           previous_offset = first_offset
           previous_at = nil
 
-          transitions.map do |t|
+          transitions = transitions.map do |t|
             offset = offsets[t[:offset]]
             at = t[:at]
             raise InvalidZoneinfoFile, "Transition at #{at} is not later than the previous transition at #{previous_at} in file '#{file.path}'." if previous_at && previous_at >= at
@@ -280,6 +475,9 @@ module TZInfo
             previous_at = at
             tt
           end
+
+          apply_rules_with_transitions(file, transitions, offsets, rules) if rules
+          transitions
         end
       end
     end

data/lib/tzinfo/time_with_offset.rb

@@ -46,6 +46,22 @@ module TZInfo
     end
     alias isdst dst?
 
+    # An overridden version of `Time#getlocal` that clears the associated
+    # {TimezoneOffset} if the base implementation of `getlocal` returns a
+    # {TimeWithOffset}.
+    #
+    # @return [Time] a representation of the {TimeWithOffset} using either the
+    #   local time zone or the given offset.
+    def getlocal(*args)
+      # JRuby < 9.3 returns a Time in all cases.
+      # JRuby >= 9.3 returns a Time when called with no arguments and a
+      # TimeWithOffset with a timezone_offset assigned when called with an
+      # offset argument.
+      result = super
+      result.clear_timezone_offset if result.kind_of?(TimeWithOffset)
+      result
+    end
+
     # An overridden version of `Time#gmtime` that clears the associated
     # {TimezoneOffset}.
     #
@@ -124,5 +140,15 @@ module TZInfo
         result.set_timezone_offset(o)
       end
     end
+
+    protected
+
+    # Clears the associated {TimezoneOffset}.
+    #
+    # @return [TimeWithOffset] `self`.
+    def clear_timezone_offset
+      @timezone_offset = nil
+      self
+    end
   end
 end

data/lib/tzinfo/timestamp.rb

@@ -3,10 +3,11 @@
 
 module TZInfo
   # A time represented as an `Integer` number of seconds since 1970-01-01
-  # 00:00:00 UTC (ignoring leap seconds), the fraction through the second
-  # (sub_second as a `Rational`) and an optional UTC offset. Like Ruby's `Time`
-  # class, {Timestamp} can distinguish between a local time with a zero offset
-  # and a time specified explicitly as UTC.
+  # 00:00:00 UTC (ignoring leap seconds and using the proleptic Gregorian
+  # calendar), the fraction through the second (sub_second as a `Rational`) and
+  # an optional UTC offset. Like Ruby's `Time` class, {Timestamp} can
+  # distinguish between a local time with a zero offset and a time specified
+  # explicitly as UTC.
   class Timestamp
     include Comparable
 
@@ -16,8 +17,8 @@ module TZInfo
     private_constant :JD_EPOCH
 
     class << self
-      # Returns a new {Timestamp} representing the (Gregorian calendar) date and
-      # time specified by the supplied parameters.
+      # Returns a new {Timestamp} representing the (proleptic Gregorian
+      # calendar) date and time specified by the supplied parameters.
       #
       # If `utc_offset` is `nil`, `:utc` or 0, the date and time parameters will
       # be interpreted as representing a UTC date and time. Otherwise the date
@@ -37,7 +38,7 @@ module TZInfo
       #   specified offset, an offset from UTC specified as an `Integer` number
       #   of seconds or the `Symbol` `:utc`).
       # @return [Timestamp] a new {Timestamp} representing the specified
-      #   (Gregorian calendar) date and time.
+      #   (proleptic Gregorian calendar) date and time.
       # @raise [ArgumentError] if either of `year`, `month`, `day`, `hour`,
       #   `minute`, or `second` is not an `Integer`.
       # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
@@ -84,7 +85,8 @@ module TZInfo
       # When called with a block, the {Timestamp} representation of `value` is
       # passed to the block. The block must then return a {Timestamp}, which
       # will be converted back to the type of the initial value. If the initial
-      # value was a {Timestamp}, the block result will just be returned.
+      # value was a {Timestamp}, the block result will be returned. If the
+      # initial value was a `DateTime`, a Gregorian `DateTime` will be returned.
       #
       # The UTC offset of `value` can either be preserved (the {Timestamp}
       # representation will have the same UTC offset as `value`), ignored (the
@@ -396,11 +398,11 @@ module TZInfo
       end
     end
 
-    # Converts this {Timestamp} to a `DateTime`.
+    # Converts this {Timestamp} to a Gregorian `DateTime`.
     #
-    # @return [DateTime] a DateTime representation of this {Timestamp}. If the
-    #   UTC offset of this {Timestamp} is not specified, a UTC `DateTime` will
-    #   be returned.
+    # @return [DateTime] a Gregorian `DateTime` representation of this
+    #   {Timestamp}. If the UTC offset of this {Timestamp} is not specified, a
+    #   UTC `DateTime` will be returned.
     def to_datetime
       new_datetime
     end
@@ -408,7 +410,7 @@ module TZInfo
     # Converts this {Timestamp} to an `Integer` number of seconds since
     # 1970-01-01 00:00:00 UTC (ignoring leap seconds).
     #
-    # @return [Integer] an Integer representation of this {Timestamp} (the
+    # @return [Integer] an `Integer` representation of this {Timestamp} (the
     #   number of seconds since 1970-01-01 00:00:00 UTC ignoring leap seconds).
     def to_i
       value
@@ -492,7 +494,9 @@ module TZInfo
     #
     # @private
     def new_datetime(klass = DateTime)
-      datetime = klass.jd(JD_EPOCH + ((@value.to_r + @sub_second) / 86400))
+      # Can't specify the start parameter unless the jd parameter is an exact number of days.
+      # Use #gregorian instead.
+      datetime = klass.jd(JD_EPOCH + ((@value.to_r + @sub_second) / 86400)).gregorian
       @utc_offset && @utc_offset != 0 ? datetime.new_offset(Rational(@utc_offset, 86400)) : datetime
     end