tzinfo 1.2.7 → 1.2.8

data/lib/tzinfo/zoneinfo_data_source.rb

@@ -192,6 +192,7 @@ module TZInfo
       @zoneinfo_dir = File.expand_path(@zoneinfo_dir).freeze
       @timezone_index = load_timezone_index.freeze
       @country_index = load_country_index(iso3166_tab_path, zone_tab_path).freeze
+      @posix_tz_parser = PosixTimeZoneParser.new
     end
     
     # Returns a TimezoneInfo instance for a given identifier. 
@@ -208,7 +209,7 @@ module TZInfo
           path.untaint
           
           begin
-            ZoneinfoTimezoneInfo.new(identifier, path)
+            ZoneinfoTimezoneInfo.new(identifier, path, @posix_tz_parser)
           rescue InvalidZoneinfoFile => e
             raise InvalidTimezoneIdentifier, e.message
           end

data/lib/tzinfo/zoneinfo_timezone_info.rb

@@ -12,7 +12,11 @@ module TZInfo
   #
   # @private
   class ZoneinfoTimezoneInfo < TransitionDataTimezoneInfo #:nodoc:
-    
+    # The year to generate transitions up to.
+    #
+    # @private
+    GENERATE_UP_TO = RubyCoreSupport.time_supports_64bit ? Time.now.utc.year + 100 : 2037
+
     # Minimum supported timestamp (inclusive).
     #
     # Time.utc(1700, 1, 1).to_i
@@ -23,13 +27,13 @@ module TZInfo
     # Time.utc(2500, 1, 1).to_i
     MAX_TIMESTAMP = 16725225600
 
-    # Constructs the new ZoneinfoTimezoneInfo with an identifier and path
-    # to the file.
-    def initialize(identifier, file_path)
+    # Constructs the new ZoneinfoTimezoneInfo with an identifier, path
+    # to the file and parser to use to parse the POSIX-like TZ string.
+    def initialize(identifier, file_path, posix_tz_parser)
       super(identifier)
       
       File.open(file_path, 'rb') do |file|
-        parse(file)
+        parse(file, posix_tz_parser)
       end
     end
     
@@ -59,7 +63,7 @@ module TZInfo
         
         result
       end
-      
+
       # Zoneinfo files don't include the offset from standard time (std_offset)
       # for DST periods. Derive the base offset (utc_offset) where DST is
       # observed from either the previous or next non-DST period.
@@ -143,6 +147,184 @@ module TZInfo
         first_offset_index
       end
 
+      # Remove transitions before a minimum supported value. If there is not a
+      # transition exactly on the minimum supported value move the latest from
+      # before up to the minimum supported value.
+      def remove_unsupported_negative_transitions(transitions, min_supported)
+        result = transitions.drop_while {|t| t[:at] < min_supported }
+        if result.empty? || (result[0][:at] > min_supported && result.length < transitions.length)
+          last_before = transitions[-1 - result.length]
+          last_before[:at] = min_supported
+          [last_before] + result
+        else
+          result
+        end
+      end
+
+      # Determines if the offset from a transition matches the offset from a
+      # rule. This is a looser match than TimezoneOffset#==, not requiring that
+      # the utc_offset and std_offset both match (which have to be derived for
+      # transitions, but are known for rules.
+      def offset_matches_rule?(offset, rule_offset)
+        offset[:utc_total_offset] == rule_offset.utc_total_offset &&
+          offset[:is_dst] == rule_offset.dst? &&
+          offset[:abbr] == rule_offset.abbreviation.to_s
+      end
+
+      # Determins if the offset from a transition exactly matches the offset
+      # from a rule.
+      def offset_equals_rule?(offset, rule_offset)
+        offset_matches_rule?(offset, rule_offset) &&
+          (offset[:utc_offset] || (offset[:is_dst] ? offset[:utc_total_offset] - 3600 : offset[:utc_total_offset])) == rule_offset.utc_offset
+      end
+
+      # Finds an offset hash that is an exact match to the rule offset specified.
+      def find_existing_offset_index(offsets, rule_offset)
+        offsets.find_index {|o| offset_equals_rule?(o, rule_offset) }
+      end
+
+      # Gets an existing matching offset index or adds a new offset hash for a
+      # rule offset.
+      def get_rule_offset_index(offsets, offset)
+        index = find_existing_offset_index(offsets, offset)
+        unless index
+          index = offsets.length
+          offsets << {:utc_total_offset => offset.utc_total_offset, :utc_offset => offset.utc_offset, :is_dst => offset.dst?, :abbr => offset.abbreviation}
+        end
+        index
+      end
+
+      # Gets a hash mapping rule offsets to indexes in offsets, creating new
+      # offset hashes if required.
+      def get_rule_offset_indexes(offsets, annual_rules)
+        {
+          annual_rules.std_offset => get_rule_offset_index(offsets, annual_rules.std_offset),
+          annual_rules.dst_offset => get_rule_offset_index(offsets, annual_rules.dst_offset)
+        }
+      end
+
+      # Converts an array of rule transitions to hashes.
+      def convert_transitions_to_hashes(offset_indexes, transitions)
+        transitions.map {|t| {:at => t.at.to_i, :offset => offset_indexes[t.offset]} }
+      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_timezone_info.rb) or 2037 if
+      # limited to 32-bit Times.
+      def apply_rules_without_transitions(file, offsets, first_offset_index, rules)
+        first_offset = offsets[first_offset_index]
+
+        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
+
+          first_offset[:utc_offset] = rules.utc_offset
+          []
+        else
+          transitions = 1970.upto(GENERATE_UP_TO).map {|y| rules.transitions(y) }.flatten
+          first_transition = transitions[0]
+
+          if offset_matches_rule?(first_offset, first_transition.previous_offset)
+            # Correct the first offset if it isn't an exact match.
+            first_offset[:utc_offset] = first_transition.previous_offset.utc_offset
+          else
+            # Not transitioning from the designated first offset.
+            if offset_matches_rule?(first_offset, first_transition.offset)
+              # Correct the first offset if it isn't an exact match.
+              first_offset[:utc_offset] = first_transition.offset.utc_offset
+
+              # Skip an unnecessary transition to the first offset.
+              transitions.shift
+            end
+
+            # If the first offset doesn't match either the offset or previous
+            # offset, then it will be retained.
+          end
+
+          offset_indexes = get_rule_offset_indexes(offsets, rules)
+          convert_transitions_to_hashes(offset_indexes, transitions)
+        end
+      end
+
+      # Validates the rules offset against the offset of the last defined
+      # transition. Replaces the transition with an equivalent using the rules
+      # offset if the rules give a different definition for the base offset.
+      def replace_last_transition_offset_if_valid_and_needed(file, transitions, offsets)
+        last_transition = transitions.last
+        last_offset = offsets[last_transition[:offset]]
+        rule_offset = yield last_offset
+
+        unless offset_matches_rule?(last_offset, rule_offset)
+          raise InvalidZoneinfoFile, "Offset from POSIX-style TZ string does not match final transition in file '#{file.path}'."
+        end
+
+        # The total_utc_offset and abbreviation must always be the same. The
+        # base utc_offset and std_offset might differ. In which case the rule
+        # should be used as it will be more precise.
+        last_offset[:utc_offset] = rule_offset.utc_offset
+        last_transition
+      end
+
+      # todo: port over validate_and_fix_last_defined_transition_offset
+      # when fixing the previous offset will need to define a new one
+
+      # 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.
+      def validate_and_fix_last_defined_transition_offset(file, offsets, last_defined, first_rule_offset)
+        offset_of_last_defined = offsets[last_defined[:offset]]
+
+        if offset_equals_rule?(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.
+
+            offset_index = get_rule_offset_index(offsets, first_rule_offset)
+            {:at => last_defined[:at], :offset => offset_index}
+          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_timezone_info.rb) or 2037 if limited to 32-bit
+      # Times.
+      def apply_rules_with_transitions(file, transitions, offsets, first_offset_index, rules)
+        last_defined = transitions[-1]
+
+        if rules.kind_of?(TimezoneOffset)
+          transitions[-1] = validate_and_fix_last_defined_transition_offset(file, offsets, last_defined, rules)
+        else
+          previous_offset_index = transitions.length > 1 ? transitions[-2][:offset] : first_offset_index
+          previous_offset = offsets[previous_offset_index]
+          last_year = (Time.at(last_defined[:at]).utc + previous_offset[:utc_total_offset]).year
+
+          if last_year <= GENERATE_UP_TO
+            generated = rules.transitions(last_year).find_all {|t| t.at > last_defined[:at] } +
+              (last_year + 1).upto(GENERATE_UP_TO).map {|y| rules.transitions(y) }.flatten
+
+            unless generated.empty?
+              transitions[-1] = validate_and_fix_last_defined_transition_offset(file, offsets, last_defined, generated[0].previous_offset)
+              rule_offset_indexes = get_rule_offset_indexes(offsets, rules)
+              transitions.concat(convert_transitions_to_hashes(rule_offset_indexes, generated))
+            end
+          end
+        end
+      end
+
       # Defines an offset for the timezone based on the given index and offset
       # Hash.
       def define_offset(index, offset)
@@ -168,21 +350,24 @@ module TZInfo
       end
       
       # Parses a zoneinfo file and intializes the DataTimezoneInfo structures.
-      def parse(file)
-        magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
+      def parse(file, posix_tz_parser)
+        magic, version, ttisutccnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
           check_read(file, 44).unpack('a4 a x15 NNNNNN')
 
         if magic != 'TZif'
           raise InvalidZoneinfoFile, "The file '#{file.path}' does not start with the expected header."
         end
 
-        if (version == '2' || version == '3') && RubyCoreSupport.time_supports_64bit
-          # 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)
+        if version == '2' || version == '3'
+          # Skip the first 32-bit section and read the header of the second
+          # 64-bit section. The 64-bit section is always used even if the
+          # runtime platform doesn't support 64-bit timestamps. In "slim" format
+          # zoneinfo files the 32-bit section will be empty.
+          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)
@@ -230,7 +415,6 @@ module TZInfo
           
           unless isdst
             offset[:utc_offset] = gmtoff
-            offset[:std_offset] = 0
           end
           
           offsets << offset
@@ -238,6 +422,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 = RubyCoreSupport.force_encoding(file.readline("\n"), '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
+
         offsets.each do |o|
           abbrev_start = o[:abbr_index]         
           raise InvalidZoneinfoFile, "Abbreviation index is out of range in file '#{file.path}'" unless abbrev_start < abbrev.length
@@ -256,44 +457,58 @@ module TZInfo
         
         # Derive the offsets from standard time (std_offset).
         first_offset_index = derive_offsets(transitions, offsets)
-        
-        define_offset(first_offset_index, offsets[first_offset_index])
-        
-        offsets.each_with_index do |o, i|
-          define_offset(i, o) unless i == first_offset_index
-        end
-
-        if !using_64bit && !RubyCoreSupport.time_supports_negative
-          # Filter out transitions that are not supported by Time on this
-          # platform.
 
-          # Move the last transition before the epoch up to the epoch. This
-          # allows for accurate conversions for all supported timestamps on the
-          # platform.
+        # Filter out transitions that are not supported by Time on this
+        # platform.
+        unless transitions.empty?
+          if !RubyCoreSupport.time_supports_negative
+            transitions = remove_unsupported_negative_transitions(transitions, 0)
+          elsif !RubyCoreSupport.time_supports_64bit
+            transitions = remove_unsupported_negative_transitions(transitions, -2**31)
+          else
+            # Ignore transitions that occur outside of a defined window. The
+            # transition index cannot handle a large range of transition times.
+            #
+            # This is primarily intended to ignore the far in the past
+            # transition added in zic 2014c (at timestamp -2**63 in zic 2014c
+            # and at the approximate time of the big bang from zic 2014d).
+            #
+            # Assumes MIN_TIMESTAMP is less than -2**31.
+            transitions = remove_unsupported_negative_transitions(transitions, MIN_TIMESTAMP)
+          end
 
-          before_epoch, after_epoch = transitions.partition {|t| t[:at] < 0}
+          if !RubyCoreSupport.time_supports_64bit
+            i = transitions.find_index {|t| t[:at] >= 2**31 }
+            had_later_transition = !!i
+            transitions = transitions.first(i) if i
+          else
+            had_later_transition = false
+          end
+        end
 
-          if before_epoch.length > 0 && after_epoch.length > 0 && after_epoch.first[:at] != 0
-            last_before = before_epoch.last
-            last_before[:at] = 0
-            transitions = [last_before] + after_epoch
+        if rules && !had_later_transition
+          if transitions.empty?
+            transitions = apply_rules_without_transitions(file, offsets, first_offset_index, rules)
           else
-            transitions = after_epoch
+            apply_rules_with_transitions(file, transitions, offsets, first_offset_index, rules)
           end
         end
+
+        define_offset(first_offset_index, offsets[first_offset_index])
+
+        used_offset_indexes = transitions.map {|t| t[:offset] }.to_set
+
+        offsets.each_with_index do |o, i|
+          define_offset(i, o) if i != first_offset_index && used_offset_indexes.include?(i)
+        end
         
         # Ignore transitions that occur outside of a defined window. The
         # transition index cannot handle a large range of transition times.
-        #
-        # This is primarily intended to ignore the far in the past transition
-        # added in zic 2014c (at timestamp -2**63 in zic 2014c and at the
-        # approximate time of the big bang from zic 2014d).
         transitions.each do |t|
           at = t[:at]
-          if at >= MIN_TIMESTAMP && at < MAX_TIMESTAMP
-            time = Time.at(at).utc
-            transition time.year, time.mon, t[:offset], at
-          end
+          break if at >= MAX_TIMESTAMP
+          time = Time.at(at).utc
+          transition time.year, time.mon, t[:offset], at
         end
       end
   end

data/test/tc_annual_rules.rb

@@ -0,0 +1,95 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'test_utils')
+
+include TZInfo
+
+class TCAnnualRules < Minitest::Test
+
+  def test_initialize
+    std_offset = TimezoneOffset.new(0, 0, 'GMT')
+    dst_offset = TimezoneOffset.new(0, 3600, 'BST')
+    dst_start_rule = FakeAlwaysDateAdjustmentRule.new(3, 1)
+    dst_end_rule = FakeAlwaysDateAdjustmentRule.new(10, 1)
+
+    rules = AnnualRules.new(std_offset, dst_offset, dst_start_rule, dst_end_rule)
+    assert_same(std_offset, rules.std_offset)
+    assert_same(dst_offset, rules.dst_offset)
+    assert_same(dst_start_rule, rules.dst_start_rule)
+    assert_same(dst_end_rule, rules.dst_end_rule)
+  end
+
+  [2020, 2021].each do |year|
+    define_method "test_transitions_for_dst_mid_year_#{year}" do
+      std_offset = TimezoneOffset.new(3600, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(3600, 3600, 'TESTS')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(3, 21),
+        FakeAlwaysDateAdjustmentRule.new(10, 22)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 3600)),
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 7200))
+      ]
+
+      assert_equal(expected, result)
+    end
+
+    define_method "test_transitions_for_dst_start_and_end_of_year_#{year}" do
+      std_offset = TimezoneOffset.new(3600, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(3600, 3600, 'TESTS')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(10, 22),
+        FakeAlwaysDateAdjustmentRule.new(3, 21)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 7200)),
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 3600))
+      ]
+
+      assert_equal(expected, result)
+    end
+
+    define_method "test_transitions_for_negative_dst_start_and_end_of_year_#{year}" do
+      std_offset = TimezoneOffset.new(7200, 0, 'TEST')
+      dst_offset = TimezoneOffset.new(7200, -3600, 'TESTW')
+
+      rules = AnnualRules.new(
+        std_offset,
+        dst_offset,
+        FakeAlwaysDateAdjustmentRule.new(10, 22),
+        FakeAlwaysDateAdjustmentRule.new(3, 21)
+      )
+
+      result = rules.transitions(year)
+
+      expected = [
+        AnnualRules::Transition.new(std_offset, dst_offset, TimeOrDateTime.wrap(Time.utc(year,  3, 21, 0, 0, 0) - 3600)),
+        AnnualRules::Transition.new(dst_offset, std_offset, TimeOrDateTime.wrap(Time.utc(year, 10, 22, 0, 0, 0) - 7200))
+      ]
+
+      assert_equal(expected, result)
+    end
+  end
+
+  class FakeAlwaysDateAdjustmentRule
+    def initialize(month, day)
+      @month = month
+      @day = day
+    end
+
+    def at(offset, year)
+      TimeOrDateTime.wrap(Time.utc(year, @month, @day, 0, 0, 0) - offset.utc_total_offset)
+    end
+  end
+end