tzinfo 1.2.7 → 1.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5b964ab83943597cb8ce6f141378398fe1bc4fe4b767dd9434f04030332b008
-  data.tar.gz: bcdda83a2bfc8e90d0f62a8ddab56f6de246c2c44b64cc00347838f64fc28a87
+  metadata.gz: e6364432a0aef34ccf3b6b1ecad65dd6f7f13843ac503cbcea1f693b74c96b46
+  data.tar.gz: 825fd6905101f51fa700dfa682490851952de8a692c03954d12f38944f8814c8
 SHA512:
-  metadata.gz: 7921a1c86b6307ee7b554edc6de33d2ed07ca8660c804f3ca78099485a72e26bcd23af498a955dfd7dfa5efb0c2f95e6adbdadbd0d60ef492732f1fdfd79f0d9
-  data.tar.gz: a0b59904238b08bbebc38a359db873dfadc0a98ef7a2fb6241f91219c642432dc8ae643ff0cf844d16bae0ef61173bac16c5f69863cde60fe504105d4240f48f
+  metadata.gz: ef4b1b6a189bbf011294210d2e0651f41bc82e1db8fe342c9f8dbcefd473e8b49b9affa67bc9a395a5831b376db8d37b5942cfade1dacf5485f23ce3d6f78a46
+  data.tar.gz: 2871fbd7aded391c88a74724138073675690710dfca6adbbbe610ec4395e8d6631fad93b22d684650d04d9affeed0ab64a1d7489f766eb9ab1996556329c6ddc

checksums.yaml.gz.sig

@@ -1,3 +1,2 @@
-\*��81l.��V��O�8rx�H�'��D9[4��D�r�K4jO
��HO��p_Q
K���_�)��w&	C���(����O�F&Q�b
-	��pL5!��l��ψè���2r4iq&�8�6��MX����Ƭ��K_W�#�!����]\�@,ބ3��,H�?���'̙V�6����̰������"͗�¡�#C��|f:��*�X(���a�Í�
-ѿs!�BS��
�H��3�yD
��q�X�g�׌
+Y�1]Q�ti�t���mPo���ڊ -O��D�cu���[<��oͽc5�}�x`��[^�J?7��s����+��ȶ��M�v��ǐ��9�e���l9J��ۑ�3?e�V~�E����6E����Eb�)��xdTk�^�BdAC?�����=Jcr�%�����l�~��)�aPʃ\�=[ݪ��{l��fFBݦ��]�_����<v�S��0��7�z|�-�$���ؑ����^ڐ��(�ReaK�s�|�c��d
+�K�W��

data/CHANGES.md

@@ -1,3 +1,33 @@
+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
 --------------------------
 

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,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?logo=rubygems&label=Gem)](https://rubygems.org/gems/tzinfo) [![Tests](https://github.com/tzinfo/tzinfo/workflows/Tests/badge.svg?branch=1.2&event=push)](https://github.com/tzinfo/tzinfo/actions?query=workflow%3ATests+branch%3A1.2+event%3Apush)
 
 [TZInfo](https://tzinfo.github.io) provides daylight savings aware
 transformations between times in different timezones.

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/ruby_data_source.rb

@@ -38,7 +38,7 @@ module TZInfo
     # Raises InvalidTimezoneIdentifier if the timezone is not found or the 
     # identifier is invalid.
     def load_timezone_info(identifier)
-      raise InvalidTimezoneIdentifier, 'Invalid identifier' if identifier !~ /^[A-Za-z0-9\+\-_]+(\/[A-Za-z0-9\+\-_]+)*$/
+      raise InvalidTimezoneIdentifier, 'Invalid identifier' if identifier !~ /\A[A-Za-z0-9+\-_]+(\/[A-Za-z0-9+\-_]+)*\z/
       
       identifier = identifier.gsub(/-/, '__m__').gsub(/\+/, '__p__')
       

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

data/lib/tzinfo/zoneinfo_data_source.rb

@@ -87,6 +87,29 @@ module TZInfo
     # The default value of ZoneinfoDataSource.alternate_iso3166_tab_search_path.
     DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = ['/usr/share/misc/iso3166.tab', '/usr/share/misc/iso3166'].freeze
     
+    # File 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
+
     # Paths to be checked to find the system zoneinfo directory.
     @@search_path = DEFAULT_SEARCH_PATH.dup
     
@@ -192,6 +215,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 +232,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
@@ -351,16 +375,8 @@ module TZInfo
     # identifiers.
     def load_timezone_index
       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(nil, ['+VERSION', 'leapseconds', 'localtime', 'posix', 'posixrules', 'right', 'src', 'timeconfig']) do |identifier|
+
+      enum_timezones(nil, EXCLUDED_FILENAMES) do |identifier|
         index << identifier
       end