tzinfo 1.2.5

data/lib/tzinfo/data_timezone_info.rb

@@ -0,0 +1,55 @@
+module TZInfo
+  # Represents a defined timezone containing transition data.
+  class DataTimezoneInfo < TimezoneInfo  
+  
+    # Returns the TimezonePeriod for the given UTC time.
+    def period_for_utc(utc)
+      raise_not_implemented('period_for_utc')
+    end
+    
+    # Returns the set of TimezonePeriods for the given local time as an array.    
+    # Results returned are ordered by increasing UTC start date.
+    # Returns an empty array if no periods are found for the given time.
+    def periods_for_local(local)
+      raise_not_implemented('periods_for_local')
+    end
+    
+    # Returns an Array of TimezoneTransition instances representing the times
+    # where the UTC offset of the timezone changes.
+    #
+    # Transitions are returned up to a given date and time up to a given date 
+    # and time, specified in UTC (utc_to).
+    #
+    # A from date and time may also be supplied using the utc_from parameter
+    # (also specified in UTC). If utc_from is not nil, only transitions from 
+    # that date and time onwards will be returned.
+    #
+    # Comparisons with utc_to are exclusive. Comparisons with utc_from are
+    # inclusive. If a transition falls precisely on utc_to, it will be excluded.
+    # If a transition falls on utc_from, it will be included.
+    #
+    # Transitions returned are ordered by when they occur, from earliest to 
+    # latest.
+    #
+    # utc_to and utc_from can be specified using either DateTime, Time or 
+    # integer timestamps (Time.to_i).
+    #
+    # If utc_from is specified and utc_to is not greater than utc_from, then
+    # transitions_up_to raises an ArgumentError exception.
+    def transitions_up_to(utc_to, utc_from = nil)
+      raise_not_implemented('transitions_up_to')
+    end
+    
+    # Constructs a Timezone instance for the timezone represented by this
+    # DataTimezoneInfo.
+    def create_timezone
+      DataTimezone.new(self)
+    end
+
+    private
+
+    def raise_not_implemented(method_name)
+      raise NotImplementedError, "Subclasses must override #{method_name}"
+    end
+  end
+end

data/lib/tzinfo/info_timezone.rb

@@ -0,0 +1,30 @@
+module TZInfo
+
+  # A Timezone based on a TimezoneInfo.
+  #
+  # @private
+  class InfoTimezone < Timezone #:nodoc:
+    
+    # Constructs a new InfoTimezone with a TimezoneInfo instance.
+    def self.new(info)      
+      tz = super()
+      tz.send(:setup, info)
+      tz
+    end
+    
+    # The identifier of the timezone, e.g. "Europe/Paris".
+    def identifier
+      @info.identifier
+    end
+    
+    protected
+      # The TimezoneInfo for this Timezone.
+      def info
+        @info
+      end
+          
+      def setup(info)
+        @info = info
+      end
+  end    
+end

data/lib/tzinfo/linked_timezone.rb

@@ -0,0 +1,63 @@
+module TZInfo
+
+  # A Timezone based on a LinkedTimezoneInfo.
+  #
+  # @private
+  class LinkedTimezone < InfoTimezone #:nodoc:
+    # Returns the TimezonePeriod for the given UTC time. utc can either be
+    # a DateTime, Time or integer timestamp (Time.to_i). Any timezone 
+    # information in utc is ignored (it is treated as a UTC time).        
+    #
+    # If no TimezonePeriod could be found, PeriodNotFound is raised.
+    def period_for_utc(utc)
+      @linked_timezone.period_for_utc(utc)
+    end
+    
+    # Returns the set of TimezonePeriod instances that are valid for the given
+    # local time as an array. If you just want a single period, use 
+    # period_for_local instead and specify how abiguities should be resolved.
+    # Raises PeriodNotFound if no periods are found for the given time.
+    def periods_for_local(local)
+      @linked_timezone.periods_for_local(local)
+    end
+    
+    # Returns an Array of TimezoneTransition instances representing the times
+    # where the UTC offset of the timezone changes.
+    #
+    # Transitions are returned up to a given date and time up to a given date 
+    # and time, specified in UTC (utc_to).
+    #
+    # A from date and time may also be supplied using the utc_from parameter
+    # (also specified in UTC). If utc_from is not nil, only transitions from 
+    # that date and time onwards will be returned.
+    #
+    # Comparisons with utc_to are exclusive. Comparisons with utc_from are
+    # inclusive. If a transition falls precisely on utc_to, it will be excluded.
+    # If a transition falls on utc_from, it will be included.
+    #
+    # Transitions returned are ordered by when they occur, from earliest to 
+    # latest.
+    #
+    # utc_to and utc_from can be specified using either DateTime, Time or 
+    # integer timestamps (Time.to_i).
+    #
+    # If utc_from is specified and utc_to is not greater than utc_from, then
+    # transitions_up_to raises an ArgumentError exception.
+    def transitions_up_to(utc_to, utc_from = nil)
+      @linked_timezone.transitions_up_to(utc_to, utc_from)
+    end
+    
+    # Returns the canonical zone for this Timezone.
+    #
+    # For a LinkedTimezone, this is the canonical zone of the link target.
+    def canonical_zone
+      @linked_timezone.canonical_zone
+    end
+    
+    protected
+      def setup(info)
+        super(info)
+        @linked_timezone = Timezone.get(info.link_to_identifier)
+      end
+  end
+end

data/lib/tzinfo/linked_timezone_info.rb

@@ -0,0 +1,26 @@
+module TZInfo
+  # Represents a timezone that is defined as a link or alias to another zone.
+  class LinkedTimezoneInfo < TimezoneInfo
+        
+    # The zone that provides the data (that this zone is an alias for).
+    attr_reader :link_to_identifier
+    
+    # Constructs a new LinkedTimezoneInfo with an identifier and the identifier
+    # of the zone linked to.
+    def initialize(identifier, link_to_identifier)
+      super(identifier)
+      @link_to_identifier = link_to_identifier      
+    end
+    
+    # Returns internal object state as a programmer-readable string.
+    def inspect
+      "#<#{self.class}: #@identifier,#@link_to_identifier>"
+    end
+    
+    # Constructs a Timezone instance for the timezone represented by this
+    # DataTimezoneInfo.
+    def create_timezone
+      LinkedTimezone.new(self)
+    end
+  end
+end

data/lib/tzinfo/offset_rationals.rb

@@ -0,0 +1,77 @@
+require 'rational' unless defined?(Rational)
+
+module TZInfo
+  
+  # Provides a method for getting Rationals for a timezone offset in seconds.
+  # Pre-reduced rationals are returned for all the half-hour intervals between
+  # -14 and +14 hours to avoid having to call gcd at runtime.
+  #
+  # @private
+  module OffsetRationals #:nodoc:
+    @@rational_cache = {
+      -50400 => RubyCoreSupport.rational_new!(-7,12), 
+      -48600 => RubyCoreSupport.rational_new!(-9,16),
+      -46800 => RubyCoreSupport.rational_new!(-13,24),
+      -45000 => RubyCoreSupport.rational_new!(-25,48),
+      -43200 => RubyCoreSupport.rational_new!(-1,2),
+      -41400 => RubyCoreSupport.rational_new!(-23,48),
+      -39600 => RubyCoreSupport.rational_new!(-11,24),
+      -37800 => RubyCoreSupport.rational_new!(-7,16),
+      -36000 => RubyCoreSupport.rational_new!(-5,12),
+      -34200 => RubyCoreSupport.rational_new!(-19,48),
+      -32400 => RubyCoreSupport.rational_new!(-3,8),
+      -30600 => RubyCoreSupport.rational_new!(-17,48),
+      -28800 => RubyCoreSupport.rational_new!(-1,3),
+      -27000 => RubyCoreSupport.rational_new!(-5,16),
+      -25200 => RubyCoreSupport.rational_new!(-7,24),
+      -23400 => RubyCoreSupport.rational_new!(-13,48),
+      -21600 => RubyCoreSupport.rational_new!(-1,4),
+      -19800 => RubyCoreSupport.rational_new!(-11,48),
+      -18000 => RubyCoreSupport.rational_new!(-5,24),
+      -16200 => RubyCoreSupport.rational_new!(-3,16),
+      -14400 => RubyCoreSupport.rational_new!(-1,6),
+      -12600 => RubyCoreSupport.rational_new!(-7,48),
+      -10800 => RubyCoreSupport.rational_new!(-1,8),
+       -9000 => RubyCoreSupport.rational_new!(-5,48),
+       -7200 => RubyCoreSupport.rational_new!(-1,12),
+       -5400 => RubyCoreSupport.rational_new!(-1,16),
+       -3600 => RubyCoreSupport.rational_new!(-1,24),
+       -1800 => RubyCoreSupport.rational_new!(-1,48),
+           0 => RubyCoreSupport.rational_new!(0,1),
+        1800 => RubyCoreSupport.rational_new!(1,48),
+        3600 => RubyCoreSupport.rational_new!(1,24),
+        5400 => RubyCoreSupport.rational_new!(1,16),
+        7200 => RubyCoreSupport.rational_new!(1,12),
+        9000 => RubyCoreSupport.rational_new!(5,48),
+       10800 => RubyCoreSupport.rational_new!(1,8),
+       12600 => RubyCoreSupport.rational_new!(7,48),
+       14400 => RubyCoreSupport.rational_new!(1,6),
+       16200 => RubyCoreSupport.rational_new!(3,16),
+       18000 => RubyCoreSupport.rational_new!(5,24),
+       19800 => RubyCoreSupport.rational_new!(11,48),
+       21600 => RubyCoreSupport.rational_new!(1,4),
+       23400 => RubyCoreSupport.rational_new!(13,48),
+       25200 => RubyCoreSupport.rational_new!(7,24),
+       27000 => RubyCoreSupport.rational_new!(5,16),
+       28800 => RubyCoreSupport.rational_new!(1,3),
+       30600 => RubyCoreSupport.rational_new!(17,48),
+       32400 => RubyCoreSupport.rational_new!(3,8),
+       34200 => RubyCoreSupport.rational_new!(19,48),
+       36000 => RubyCoreSupport.rational_new!(5,12),
+       37800 => RubyCoreSupport.rational_new!(7,16),
+       39600 => RubyCoreSupport.rational_new!(11,24),
+       41400 => RubyCoreSupport.rational_new!(23,48),
+       43200 => RubyCoreSupport.rational_new!(1,2),
+       45000 => RubyCoreSupport.rational_new!(25,48),
+       46800 => RubyCoreSupport.rational_new!(13,24),
+       48600 => RubyCoreSupport.rational_new!(9,16),
+       50400 => RubyCoreSupport.rational_new!(7,12)}.freeze
+    
+    # Returns a Rational expressing the fraction of a day that offset in 
+    # seconds represents (i.e. equivalent to Rational(offset, 86400)). 
+    def rational_for_offset(offset)
+      @@rational_cache[offset] || Rational(offset, 86400)      
+    end
+    module_function :rational_for_offset
+  end
+end

data/lib/tzinfo/ruby_core_support.rb

@@ -0,0 +1,146 @@
+require 'date'
+require 'rational' unless defined?(Rational)
+
+module TZInfo
+  
+  # Methods to support different versions of Ruby.
+  #
+  # @private
+  module RubyCoreSupport #:nodoc:
+  
+    # Use Rational.new! for performance reasons in Ruby 1.8.
+    # This has been removed from 1.9, but Rational performs better.        
+    if Rational.respond_to? :new!
+      def self.rational_new!(numerator, denominator = 1)
+        Rational.new!(numerator, denominator)
+      end
+    else
+      def self.rational_new!(numerator, denominator = 1)
+        Rational(numerator, denominator)
+      end
+    end
+    
+    # Ruby 1.8.6 introduced new! and deprecated new0.
+    # Ruby 1.9.0 removed new0.
+    # Ruby trunk revision 31668 removed the new! method.
+    # Still support new0 for better performance on older versions of Ruby (new0 indicates
+    # that the rational has already been reduced to its lowest terms).
+    # Fallback to jd with conversion from ajd if new! and new0 are unavailable.
+    if DateTime.respond_to? :new!
+      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
+        DateTime.new!(ajd, of, sg)
+      end
+    elsif DateTime.respond_to? :new0
+      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
+        DateTime.new0(ajd, of, sg)
+      end
+    else
+      HALF_DAYS_IN_DAY = rational_new!(1, 2)
+
+      def self.datetime_new!(ajd = 0, of = 0, sg = Date::ITALY)
+        # Convert from an Astronomical Julian Day number to a civil Julian Day number.
+        jd = ajd + of + HALF_DAYS_IN_DAY
+        
+        # Ruby trunk revision 31862 changed the behaviour of DateTime.jd so that it will no
+        # longer accept a fractional civil Julian Day number if further arguments are specified.
+        # Calculate the hours, minutes and seconds to pass to jd.
+        
+        jd_i = jd.to_i
+        jd_i -= 1 if jd < 0
+        hours = (jd - jd_i) * 24
+        hours_i = hours.to_i
+        minutes = (hours - hours_i) * 60
+        minutes_i = minutes.to_i
+        seconds = (minutes - minutes_i) * 60
+        
+        DateTime.jd(jd_i, hours_i, minutes_i, seconds, of, sg)
+      end
+    end
+    
+    # DateTime in Ruby 1.8.6 doesn't consider times within the 60th second to be
+    # valid. When attempting to specify such a DateTime, subtract the fractional
+    # part and then add it back later
+    if Date.respond_to?(:valid_time?) && !Date.valid_time?(0, 0, rational_new!(59001, 1000)) # 0:0:59.001
+      def self.datetime_new(y=-4712, m=1, d=1, h=0, min=0, s=0, of=0, sg=Date::ITALY)
+        if !s.kind_of?(Integer) && s > 59
+          dt = DateTime.new(y, m, d, h, min, 59, of, sg)
+          dt + (s - 59) / 86400
+        else
+          DateTime.new(y, m, d, h, min, s, of, sg)
+        end
+      end
+    else
+      def self.datetime_new(y=-4712, m=1, d=1, h=0, min=0, s=0, of=0, sg=Date::ITALY)
+        DateTime.new(y, m, d, h, min, s, of, sg)
+      end    
+    end    
+    
+    # Returns true if Time on the runtime platform supports Times defined
+    # by negative 32-bit timestamps, otherwise false.
+    begin
+      Time.at(-1)
+      Time.at(-2147483648)
+      
+      def self.time_supports_negative
+        true
+      end
+    rescue ArgumentError
+      def self.time_supports_negative
+        false
+      end
+    end
+    
+    # Returns true if Time on the runtime platform supports Times defined by
+    # 64-bit timestamps, otherwise false.
+    begin
+      Time.at(-2147483649)
+      Time.at(2147483648)
+      
+      def self.time_supports_64bit
+        true
+      end
+    rescue RangeError
+      def self.time_supports_64bit
+        false
+      end
+    end
+    
+    # Return the result of Time#nsec if it exists, otherwise return the
+    # result of Time#usec * 1000.
+    if Time.method_defined?(:nsec)
+      def self.time_nsec(time)
+        time.nsec
+      end
+    else
+      def self.time_nsec(time)
+        time.usec * 1000
+      end
+    end
+    
+    # Call String#force_encoding if this version of Ruby has encoding support
+    # otherwise treat as a no-op.
+    if String.method_defined?(:force_encoding)
+      def self.force_encoding(str, encoding)
+        str.force_encoding(encoding)
+      end
+    else
+      def self.force_encoding(str, encoding)
+        str
+      end
+    end
+    
+    
+    # Wrapper for File.open that supports passing hash options for specifying
+    # encodings on Ruby 1.9+. The options are ignored on earlier versions of
+    # Ruby.
+    if RUBY_VERSION =~ /\A1\.[0-8]\./
+      def self.open_file(file_name, mode, opts, &block)
+        File.open(file_name, mode, &block)
+      end
+    else
+      def self.open_file(file_name, mode, opts, &block)
+        File.open(file_name, mode, opts, &block)
+      end
+    end
+  end
+end

data/lib/tzinfo/ruby_country_info.rb

@@ -0,0 +1,74 @@
+module TZInfo  
+  # Represents information about a country returned by RubyDataSource.
+  #
+  # @private
+  class RubyCountryInfo < CountryInfo #:nodoc:
+    # Constructs a new CountryInfo with an ISO 3166 country code, name and 
+    # block. The block will be evaluated to obtain the timezones for the 
+    # country when the zones are first needed.
+    def initialize(code, name, &block)
+      super(code, name)
+      @block = block
+      @zones = nil
+      @zone_identifiers = nil
+    end
+    
+    # Returns a frozen array of all the zone identifiers for the country. These
+    # are in the order they were added using the timezone method.
+    def zone_identifiers
+      # Thread-safety: 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
+        result = zones.collect {|zone| zone.identifier}.freeze
+        return result if frozen?
+        @zone_identifiers = result
+      end
+      
+      @zone_identifiers
+    end
+    
+    # Returns a frozen array of all the timezones for the for the country as
+    # CountryTimezone instances. These are in the order they were added using 
+    # the timezone method.
+    def zones
+      # Thread-safety: It is possible that the value of @zones may be 
+      # calculated multiple times in concurrently executing threads. It is not 
+      # worth the overhead of locking to ensure that @zones is only 
+      # calculated once.
+    
+      unless @zones
+        zones = Zones.new
+        @block.call(zones) if @block
+        result = zones.list.freeze
+        return result if frozen?
+        @block = nil
+        @zones = result
+      end
+      
+      @zones
+    end
+    
+    # An instance of the Zones class is passed to the block used to define
+    # timezones.
+    #
+    # @private
+    class Zones #:nodoc:
+      attr_reader :list
+    
+      def initialize
+        @list = []
+      end
+    
+      # Called by the index data to define a timezone for the country.
+      def timezone(identifier, latitude_numerator, latitude_denominator, 
+                   longitude_numerator, longitude_denominator, description = nil)          
+        @list << CountryTimezone.new!(identifier, latitude_numerator, 
+          latitude_denominator, longitude_numerator, longitude_denominator,
+          description)     
+      end
+    end
+  end
+end