tzinfo 1.2.5 → 1.2.9

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

data/lib/tzinfo/zoneinfo_data_source.rb

@@ -1,4 +1,12 @@
 module TZInfo
+  # Use send as a workaround for an issue on JRuby 9.2.9.0 where using the
+  # refinement causes calls to RubyCoreSupport.file_open to fail to pass the
+  # block parameter.
+  #
+  # https://travis-ci.org/tzinfo/tzinfo/jobs/628812051#L1931
+  # https://github.com/jruby/jruby/issues/6009
+  send(:using, TZInfo::RubyCoreSupport::UntaintExt) if TZInfo::RubyCoreSupport.const_defined?(:UntaintExt)
+
   # An InvalidZoneinfoDirectory exception is raised if the DataSource is
   # set to a specific zoneinfo path, which is not a valid zoneinfo directory
   # (i.e. a directory containing index files named iso3166.tab and zone.tab
@@ -184,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. 
@@ -200,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

@@ -1,4 +1,8 @@
 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, RubyCoreSupport::UntaintExt) if RubyCoreSupport.const_defined?(:UntaintExt)
+
   # An InvalidZoneinfoFile exception is raised if an attempt is made to load an
   # invalid zoneinfo file.
   class InvalidZoneinfoFile < StandardError
@@ -8,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
@@ -19,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
     
@@ -55,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.
@@ -139,6 +147,189 @@ 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
+            last_defined_offset = offsets[last_defined[:offset]]
+
+            generated = rules.transitions(last_year).find_all do |t|
+              t.at > last_defined[:at] && !offset_matches_rule?(last_defined_offset, t.offset)
+            end
+
+            generated += (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)
@@ -164,21 +355,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)
@@ -226,7 +420,6 @@ module TZInfo
           
           unless isdst
             offset[:utc_offset] = gmtoff
-            offset[:std_offset] = 0
           end
           
           offsets << offset
@@ -234,6 +427,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
@@ -252,44 +462,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