tzinfo 1.0.1 → 1.1.0

data/lib/tzinfo/zoneinfo_country_info.rb

@@ -22,6 +22,8 @@
 
 module TZInfo  
   # Represents information about a country returned by ZoneinfoDataSource.
+  #
+  # @private
   class ZoneinfoCountryInfo < CountryInfo #:nodoc:
     # Constructs a new CountryInfo with an ISO 3166 country code, name and 
     # an array of CountryTimezones.
@@ -34,6 +36,11 @@ module TZInfo
     # Returns a frozen array of all the zone identifiers for the country ordered
     # geographically, most populous first.
     def zone_identifiers
+      # Thread-safey: It is possible that the value of @zone_identifiers may be 
+      # calculated multiple times in concurrently executing threads. It is not 
+      # worth the overhead of locking to ensure that @zone_identifiers is only 
+      # calculated once.
+    
       unless @zone_identifiers
         @zone_identifiers = zones.collect {|zone| zone.identifier}.freeze
       end

data/lib/tzinfo/zoneinfo_data_source.rb

@@ -48,7 +48,52 @@ module TZInfo
   # To load zoneinfo files from a particular directory, pass the directory to 
   # TZInfo::DataSource.set:
   #
-  #   TZInfo::DataSource.set(:zoneinfo, directory)  
+  #   TZInfo::DataSource.set(:zoneinfo, directory)
+  #
+  # Note that the platform used at runtime may limit the range of available
+  # transition data that can be loaded from zoneinfo files. There are two
+  # factors to consider:
+  #
+  # First of all, the zoneinfo support in TZInfo makes use of Ruby's Time class. 
+  # On 32-bit builds of Ruby 1.8, the Time class only supports 32-bit 
+  # timestamps. This means that only Times between 1901-12-13 20:45:52 and
+  # 2038-01-19 03:14:07 can be represented. Furthermore, certain platforms only
+  # allow for positive 32-bit timestamps (notably Windows), making the earliest
+  # representable time 1970-01-01 00:00:00.
+  #
+  # 64-bit builds of Ruby 1.8 and all builds of Ruby 1.9 support 64-bit 
+  # timestamps. This means that there is no practical restriction on the range
+  # of the Time class on these platforms.
+  #
+  # TZInfo will only load transitions that fall within the supported range of
+  # the Time class. Any queries performed on times outside of this range may
+  # give inaccurate results.
+  #
+  # The second factor concerns the zoneinfo files. Versions of the 'zic' tool
+  # (used to build zoneinfo files) that were released prior to February 2006
+  # created zoneinfo files that used 32-bit integers for transition timestamps.
+  # Later versions of zic produce zoneinfo files that use 64-bit integers. If
+  # you have 32-bit zoneinfo files on your system, then any queries falling
+  # outside of the range 1901-12-13 20:45:52 to 2038-01-19 03:14:07 may be
+  # inaccurate.
+  #
+  # Most modern platforms include 64-bit zoneinfo files. However, Mac OS X (up
+  # to at least 10.8.4) still uses 32-bit zoneinfo files.
+  #
+  # To check whether your zoneinfo files contain 32-bit or 64-bit transition
+  # data, you can run the following code (substituting the identifier of the 
+  # zone you want to test for zone_identifier):
+  #
+  #   TZInfo::DataSource.set(:zoneinfo)
+  #   dir = TZInfo::DataSource.get.zoneinfo_dir
+  #   File.open(File.join(dir, zone_identifier), 'r') {|f| f.read(5) }
+  #
+  # If the last line returns "TZif\\x00", then you have a 32-bit zoneinfo file.
+  # If it returns "TZif2" or "TZif3" then you have a 64-bit zoneinfo file.
+  #
+  # If you require support for 64-bit transitions, but are restricted to 32-bit
+  # zoneinfo support, then you may want to consider using TZInfo::RubyDataSource 
+  # instead.
   class ZoneinfoDataSource < DataSource
     # The default value of ZoneInfoDataSource.search_path.
     DEFAULT_SEARCH_PATH = ['/usr/share/zoneinfo', '/usr/share/lib/zoneinfo', '/etc/zoneinfo'].freeze
@@ -118,19 +163,23 @@ module TZInfo
       
       @zoneinfo_dir = File.expand_path(@zoneinfo_dir).freeze
       @zoneinfo_prefix = (@zoneinfo_dir + File::SEPARATOR).freeze
+      @timezone_index = load_timezone_index.freeze
+      @country_index = load_country_index.freeze
     end
     
     # Returns a TimezoneInfo instance for a given identifier. 
     # Raises InvalidTimezoneIdentifier if the timezone is not found or the 
     # identifier is invalid.
     def load_timezone_info(identifier)
-      load_timezone_index
-      
       begin
         if @timezone_index.include?(identifier)
-          identifier.untaint
           path = File.join(@zoneinfo_dir, identifier)
           
+          # Untaint path rather than identifier. We don't want to modify 
+          # identifier. identifier may also be frozen and therefore cannot be
+          # untainted.
+          path.untaint
+          
           begin
             ZoneinfoTimezoneInfo.new(identifier, path)
           rescue InvalidZoneinfoFile => e
@@ -148,7 +197,6 @@ module TZInfo
     
     # Returns an array of all the available timezone identifiers.
     def timezone_identifiers
-      load_timezone_index
       @timezone_index
     end
     
@@ -158,7 +206,6 @@ module TZInfo
     # For ZoneinfoDataSource, this will always be identical to 
     # timezone_identifers.
     def data_timezone_identifiers
-      load_timezone_index
       @timezone_index
     end
     
@@ -174,7 +221,6 @@ module TZInfo
     # country code. Raises InvalidCountryCode if the country could not be found
     # or the code is invalid.
     def load_country_info(code)
-      load_country_index
       info = @country_index[code]
       raise InvalidCountryCode.new, 'Invalid country code' unless info
       info
@@ -183,7 +229,6 @@ module TZInfo
     # Returns an array of all the available ISO 3166-1 alpha-2
     # country codes.
     def country_codes
-      load_country_index
       @country_index.keys.freeze
     end
     
@@ -205,18 +250,22 @@ module TZInfo
       File.directory?(path) && File.file?(File.join(path, 'zone.tab')) && File.file?(File.join(path, 'iso3166.tab'))
     end
        
-    # Unless already called, scans @zoneinfo_dir looking for the available
-    # timezone identifiers.
+    # Scans @zoneinfo_dir and returns an Array of available timezone 
+    # identifiers.
     def load_timezone_index
-      unless @timezone_index
-        index = []
-        
-        enum_timezones(nil, ['localtime', 'posix', 'posixrules', 'right', 'Factory']) do |identifier|
-          index << identifier
-        end
-        
-        @timezone_index = index.sort.freeze
+      index = []
+      
+      # Ignoring particular files:
+      # +VERSION is included in Mac OS X.
+      # localtime current local timezone (may be a link).
+      # posix, posixrules and right are directories containing other versions of the zoneinfo files.
+      # Factory is the compiled in default timezone.
+      
+      enum_timezones(nil, ['+VERSION', 'localtime', 'posix', 'posixrules', 'right', 'Factory']) do |identifier|
+        index << identifier
       end
+      
+      index.sort
     end
     
     # Recursively scans a directory of timezones, calling the passed in block
@@ -237,53 +286,51 @@ module TZInfo
       end
     end
     
-    # Unless called before, uses the iso3166.tab and zone.tab files to build
-    # an index of the available countries and their timezones.
+    # Uses the iso3166.tab and zone.tab files to build an index of the 
+    # available countries and their timezones.
     def load_country_index
-      unless @country_index
-        zones = {}
-        
-        File.open(File.join(@zoneinfo_dir, 'zone.tab')) do |file|
-          file.each_line do |line|
-            line.chomp!
+      zones = {}
+      
+      File.open(File.join(@zoneinfo_dir, 'zone.tab')) do |file|
+        file.each_line do |line|
+          line.chomp!
+          
+          if line =~ /\A([A-Z]{2})\t(?:([+\-])(\d{2})(\d{2})([+\-])(\d{3})(\d{2})|([+\-])(\d{2})(\d{2})(\d{2})([+\-])(\d{3})(\d{2})(\d{2}))\t([^\t]+)(?:\t([^\t]+))?\z/
+            code = $1
             
-            if line =~ /\A([A-Z]{2})\t(?:([+\-])(\d{2})(\d{2})([+\-])(\d{3})(\d{2})|([+\-])(\d{2})(\d{2})(\d{2})([+\-])(\d{3})(\d{2})(\d{2}))\t([^\t]+)(?:\t([^\t]+))?\z/
-              code = $1
-              
-              if $2
-                latitude = dms_to_rational($2, $3, $4)
-                longitude = dms_to_rational($5, $6, $7)
-              else
-                latitude = dms_to_rational($8, $9, $10, $11)
-                longitude = dms_to_rational($12, $13, $14, $15)
-              end
-              
-              zone_identifier = $16
-              description = $17
-              
-              (zones[code] ||= []) << 
-                CountryTimezone.new(zone_identifier, latitude.numerator, latitude.denominator, 
-                                    longitude.numerator, longitude.denominator, description)
+            if $2
+              latitude = dms_to_rational($2, $3, $4)
+              longitude = dms_to_rational($5, $6, $7)
+            else
+              latitude = dms_to_rational($8, $9, $10, $11)
+              longitude = dms_to_rational($12, $13, $14, $15)
             end
+            
+            zone_identifier = $16
+            description = $17
+            
+            (zones[code] ||= []) << 
+              CountryTimezone.new(zone_identifier, latitude.numerator, latitude.denominator, 
+                                  longitude.numerator, longitude.denominator, description)
           end
         end
-        
-        countries = {}
-        
-        File.open(File.join(@zoneinfo_dir, 'iso3166.tab')) do |file|
-          file.each_line do |line|
-            line.chomp!
-            
-            if line =~ /\A([A-Z]{2})\t(.+)\z/
-              code = $1
-              name = $2
-              countries[code] = ZoneinfoCountryInfo.new(code, name, zones[code] || [])
-            end
+      end
+      
+      countries = {}
+      
+      File.open(File.join(@zoneinfo_dir, 'iso3166.tab')) do |file|
+        file.each_line do |line|
+          line.chomp!
+          
+          if line =~ /\A([A-Z]{2})\t(.+)\z/
+            code = $1
+            name = $2
+            countries[code] = ZoneinfoCountryInfo.new(code, name, zones[code] || [])
           end
         end
-        
-        @country_index = countries
       end
+      
+      countries
     end
     
     # Converts degrees, miunutes and seconds to a Rational

data/lib/tzinfo/zoneinfo_timezone_info.rb

@@ -27,6 +27,8 @@ module TZInfo
   end
 
   # Represents a timezone defined by a compiled zoneinfo TZif (\0 or 2) file.
+  #
+  # @private
   class ZoneinfoTimezoneInfo < TransitionDataTimezoneInfo #:nodoc:
     
     # Constructs the new ZoneinfoTimezoneInfo with an identifier and path
@@ -103,23 +105,29 @@ module TZInfo
       
       # Parses a zoneinfo file and intializes the DataTimezoneInfo structures.
       def parse(file)
-        magic, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-          check_read(file, 44).unpack('a5 x15 NNNNNN')
+        magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
+          check_read(file, 44).unpack('a4 a x15 NNNNNN')
 
-        if magic == 'TZif2' && RubyCoreSupport.time_supports_64bit
+        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
           check_read(file, timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + ttisgmtcnt + ttisstdcnt)
           
-          magic, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-            check_read(file, 44).unpack('a5 x15 NNNNNN')
+          prev_version = version
+          
+          magic, version, ttisgmtcnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
+            check_read(file, 44).unpack('a4 a x15 NNNNNN')
             
-          unless magic == 'TZif2'
-            raise InvalidZoneinfoFile, "Invalid magic in second section of file '#{file.path}'"
+          unless magic == 'TZif' && (version == prev_version)
+            raise InvalidZoneinfoFile, "The file '#{file.path}' contains an invalid 64-bit section header."
           end
           
-          using_64bit = true          
-        elsif magic != 'TZif2' && magic != "TZif\0"
-          raise InvalidZoneinfoFile, "Invalid magic in file '#{file.path}'"
+          using_64bit = true
+        elsif version != '3' && version != '2' && version != "\0"
+          raise InvalidZoneinfoFile, "The file '#{file.path}' contains a version of the zoneinfo format that is not currently supported."
         else
           using_64bit = false
         end

data/test/tc_country.rb

@@ -27,7 +27,7 @@ include TZInfo
 class TCCountry < Test::Unit::TestCase
   def setup
     @orig_data_source = DataSource.get
-    Country.send :class_variable_set, :@@countries, {}
+    Country.send :init_countries
   end
   
   def teardown
@@ -64,6 +64,44 @@ class TCCountry < Test::Unit::TestCase
       Country.get('gb')
     }
   end
+  
+  def test_get_tainted_loaded
+    Country.get('GB')
+  
+    safe_test do
+      code = 'GB'.taint
+      assert(code.tainted?)
+      country = Country.get(code)
+      assert_equal('GB', country.code)
+      assert(code.tainted?)
+    end
+  end
+  
+  def test_get_tainted_and_frozen_loaded
+    Country.get('GB')
+  
+    safe_test do
+      country = Country.get('GB'.taint.freeze)
+      assert_equal('GB', country.code)
+    end
+  end
+  
+  def test_get_tainted_not_previously_loaded
+    safe_test do
+      code = 'GB'.taint
+      assert(code.tainted?)
+      country = Country.get(code)
+      assert_equal('GB', country.code)
+      assert(code.tainted?)
+    end
+  end
+  
+  def test_get_tainted_and_frozen_not_previously_loaded
+    safe_test do
+      country = Country.get('GB'.taint.freeze)
+      assert_equal('GB', country.code)
+    end
+  end
     
   def test_new_nil
     assert_raises(InvalidCountryCode) {

data/test/tc_data_timezone.rb

@@ -29,11 +29,14 @@ class TCDataTimezone < Test::Unit::TestCase
   class TestTimezoneInfo < TimezoneInfo
     attr_reader :utc
     attr_reader :local
+    attr_reader :utc_to
+    attr_reader :utc_from
     
-    def initialize(identifier, utc_period, local_periods)
+    def initialize(identifier, utc_period, local_periods, transitions_up_to)
       super(identifier)
       @utc_period = utc_period
       @local_periods = local_periods || []
+      @transitions_up_to = transitions_up_to
     end
     
     def period_for_utc(utc)
@@ -45,10 +48,16 @@ class TCDataTimezone < Test::Unit::TestCase
       @local = local      
       @local_periods
     end
+    
+    def transitions_up_to(utc_to, utc_from = nil)
+      @utc_to = utc_to
+      @utc_from = utc_from
+      @transitions_up_to
+    end
   end    
 
   def test_identifier
-    tz = DataTimezone.new(TestTimezoneInfo.new('Test/Zone', nil, []))
+    tz = DataTimezone.new(TestTimezoneInfo.new('Test/Zone', nil, [], []))
     assert_equal('Test/Zone', tz.identifier)
   end
   
@@ -56,7 +65,7 @@ class TCDataTimezone < Test::Unit::TestCase
     # Don't need actual TimezonePeriods. DataTimezone isn't supposed to do
     # anything with them apart from return them.
     period = Object.new 
-    tti = TestTimezoneInfo.new('Test/Zone', period, [])
+    tti = TestTimezoneInfo.new('Test/Zone', period, [], [])
     tz = DataTimezone.new(tti)
     
     t = Time.utc(2006, 6, 27, 22, 50, 12)
@@ -68,7 +77,7 @@ class TCDataTimezone < Test::Unit::TestCase
     # Don't need actual TimezonePeriods. DataTimezone isn't supposed to do
     # anything with them apart from return them.
     periods = [Object.new, Object.new] 
-    tti = TestTimezoneInfo.new('Test/Zone', nil, periods)
+    tti = TestTimezoneInfo.new('Test/Zone', nil, periods, [])
     tz = DataTimezone.new(tti)
     
     t = Time.utc(2006, 6, 27, 22, 50, 12)
@@ -78,11 +87,25 @@ class TCDataTimezone < Test::Unit::TestCase
   
   def test_periods_for_local_not_found
     periods = []
-    tti = TestTimezoneInfo.new('Test/Zone', nil, periods)
+    tti = TestTimezoneInfo.new('Test/Zone', nil, periods, [])
     tz = DataTimezone.new(tti)
     
     t = Time.utc(2006, 6, 27, 22, 50, 12)
     assert_same(periods, tz.periods_for_local(t))
     assert_same(t, tti.local)
+  end
+  
+  def test_transitions_up_to
+    # Don't need actual TimezoneTransition instances. DataTimezone isn't
+    # supposed to do anything with them apart from return them.
+    transitions = [Object.new, Object.new]
+    tti = TestTimezoneInfo.new('Test/Zone', nil, nil, transitions)
+    tz = DataTimezone.new(tti)
+    
+    utc_to = Time.utc(2013, 1, 1, 0, 0, 0)
+    utc_from = Time.utc(2012, 1, 1, 0, 0, 0)
+    assert_same(transitions, tz.transitions_up_to(utc_to, utc_from))
+    assert_same(utc_to, tti.utc_to)
+    assert_same(utc_from, tti.utc_from)
   end    
 end

data/test/tc_linked_timezone.rb

@@ -29,8 +29,11 @@ class TCLinkedTimezone < Test::Unit::TestCase
   class TestTimezone < Timezone
     attr_reader :utc_period
     attr_reader :local_periods
+    attr_reader :up_to_transitions
     attr_reader :utc
-    attr_reader :local    
+    attr_reader :local
+    attr_reader :utc_to
+    attr_reader :utc_from
     
     def self.new(identifier, no_local_periods = false)
       tz = super()
@@ -53,14 +56,22 @@ class TCLinkedTimezone < Test::Unit::TestCase
       @local_periods
     end
     
+    def transitions_up_to(utc_to, utc_from = nil)
+      @utc_to = utc_to
+      @utc_from = utc_from
+      @up_to_transitions
+    end
+    
     private
       def setup(identifier, no_local_periods)
         @identifier = identifier
         @no_local_periods = no_local_periods
         
-        # Doesn't have to be a real TimezonePeriod (nothing attempts to use it).
+        # Don't have to be real TimezonePeriod or TimezoneTransition objects
+        # (nothing will use them).
         @utc_period = Object.new
         @local_periods = [Object.new, Object.new]
+        @up_to_transitions = [Object.new, Object.new]
       end
   end
   
@@ -117,5 +128,15 @@ class TCLinkedTimezone < Test::Unit::TestCase
     t = Time.utc(2006, 6, 27, 23, 12, 28)
     assert_raises(PeriodNotFound) { tz.periods_for_local(t) }
     assert_same(t, linked_tz.local)
-  end  
+  end
+  
+  def test_transitions_up_to
+    tz = LinkedTimezone.new(LinkedTimezoneInfo.new('Test/Zone', 'Test/Linked'))
+    linked_tz = Timezone.get('Test/Linked')
+    utc_to = Time.utc(2013, 1, 1, 0, 0, 0)
+    utc_from = Time.utc(2012, 1, 1, 0, 0, 0)
+    assert_same(linked_tz.up_to_transitions, tz.transitions_up_to(utc_to, utc_from))
+    assert_same(utc_to, linked_tz.utc_to)
+    assert_same(utc_from, linked_tz.utc_from)
+  end
 end