tzinfo 1.2.11 → 2.0.0

data/lib/tzinfo/transition_data_timezone_info.rb

@@ -1,274 +0,0 @@
-module TZInfo
-  # Raised if no offsets have been defined when calling period_for_utc or
-  # periods_for_local. Indicates an error in the timezone data.
-  class NoOffsetsDefined < StandardError
-  end
-    
-  # Represents a data timezone defined by a set of offsets and a set 
-  # of transitions.
-  #
-  # @private
-  class TransitionDataTimezoneInfo < DataTimezoneInfo #:nodoc:
-            
-    # Constructs a new TransitionDataTimezoneInfo with its identifier.
-    def initialize(identifier)   
-      super(identifier)
-      @offsets = {}
-      @transitions = []
-      @previous_offset = nil
-      @transitions_index = nil
-    end
- 
-    # Defines a offset. The id uniquely identifies this offset within the
-    # timezone. utc_offset and std_offset define the offset in seconds of 
-    # standard time from UTC and daylight savings from standard time 
-    # respectively. abbreviation describes the timezone offset (e.g. GMT, BST,
-    # EST or EDT).
-    #
-    # The first offset to be defined is treated as the offset that applies
-    # until the first transition. This will usually be in Local Mean Time (LMT).
-    #
-    # ArgumentError will be raised if the id is already defined.
-    def offset(id, utc_offset, std_offset, abbreviation)
-      raise ArgumentError, 'Offset already defined' if @offsets.has_key?(id)
-      
-      offset = TimezoneOffset.new(utc_offset, std_offset, abbreviation)
-      @offsets[id] = offset
-      @previous_offset = offset unless @previous_offset
-    end
-    
-    # Defines a transition. Transitions must be defined in chronological order.
-    # ArgumentError will be raised if a transition is added out of order.
-    # offset_id refers to an id defined with offset. ArgumentError will be 
-    # raised if the offset_id cannot be found. numerator_or_time and
-    # denomiator specify the time the transition occurs as. See 
-    # TimezoneTransition for more detail about specifying times.
-    def transition(year, month, offset_id, numerator_or_timestamp, denominator_or_numerator = nil, denominator = nil)
-      offset = @offsets[offset_id]      
-      raise ArgumentError, 'Offset not found' unless offset
-            
-      if @transitions_index
-        if year < @last_year || (year == @last_year && month < @last_month)
-          raise ArgumentError, 'Transitions must be increasing date order'
-        end
-        
-        # Record the position of the first transition with this index.
-        index = transition_index(year, month)
-        @transitions_index[index] ||= @transitions.length
-                
-        # Fill in any gaps       
-        (index - 1).downto(0) do |i|
-          break if @transitions_index[i]
-          @transitions_index[i] = @transitions.length
-        end
-      else
-        @transitions_index = [@transitions.length]
-        @start_year = year
-        @start_month = month        
-      end
-      
-      @transitions << TimezoneTransitionDefinition.new(offset, @previous_offset,
-        numerator_or_timestamp, denominator_or_numerator, denominator)
-      @last_year = year
-      @last_month = month             
-      @previous_offset = offset
-    end           
-    
-    # Returns the TimezonePeriod for the given UTC time.
-    # Raises NoOffsetsDefined if no offsets have been defined.
-    def period_for_utc(utc)
-      unless @transitions.empty?
-        utc = TimeOrDateTime.wrap(utc)               
-        index = transition_index(utc.year, utc.mon)
-        
-        start_transition = nil
-        start = transition_before_end(index)
-        if start
-          start.downto(0) do |i|
-            if @transitions[i].at <= utc
-              start_transition = @transitions[i]
-              break
-            end
-          end
-        end
-        
-        end_transition = nil
-        start = transition_after_start(index)      
-        if start
-          start.upto(@transitions.length - 1) do |i|
-            if @transitions[i].at > utc
-              end_transition = @transitions[i]
-              break
-            end
-          end
-        end
-               
-        if start_transition || end_transition
-          TimezonePeriod.new(start_transition, end_transition)
-        else
-          # Won't happen since there are transitions. Must always find one
-          # transition that is either >= or < the specified time.
-          raise 'No transitions found in search'
-        end        
-      else
-        raise NoOffsetsDefined, 'No offsets have been defined' unless @previous_offset        
-        TimezonePeriod.new(nil, nil, @previous_offset)
-      end
-    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.
-    # Raises NoOffsetsDefined if no offsets have been defined.    
-    def periods_for_local(local)
-      unless @transitions.empty?
-        local = TimeOrDateTime.wrap(local)
-        index = transition_index(local.year, local.mon)
-        
-        result = []
-       
-        start_index = transition_after_start(index - 1)       
-        if start_index && @transitions[start_index].local_end_at > local
-          if start_index > 0
-            if @transitions[start_index - 1].local_start_at <= local
-              result << TimezonePeriod.new(@transitions[start_index - 1], @transitions[start_index])
-            end
-          else
-            result << TimezonePeriod.new(nil, @transitions[start_index])
-          end
-        end
-        
-        end_index = transition_before_end(index + 1)
-        
-        if end_index        
-          start_index = end_index unless start_index
-          
-          start_index.upto(transition_before_end(index + 1)) do |i|
-            if @transitions[i].local_start_at <= local
-              if i + 1 < @transitions.length
-                if @transitions[i + 1].local_end_at > local
-                  result << TimezonePeriod.new(@transitions[i], @transitions[i + 1])
-                end
-              else
-                result << TimezonePeriod.new(@transitions[i], nil)
-              end
-            end
-          end
-        end
-        
-        result
-      else
-        raise NoOffsetsDefined, 'No offsets have been defined' unless @previous_offset
-        [TimezonePeriod.new(nil, nil, @previous_offset)]
-      end
-    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)
-      utc_to = TimeOrDateTime.wrap(utc_to)
-      utc_from = utc_from ? TimeOrDateTime.wrap(utc_from) : nil
-      
-      if utc_from && utc_to <= utc_from
-        raise ArgumentError, 'utc_to must be greater than utc_from'
-      end
-      
-      unless @transitions.empty?
-        if utc_from
-          from = transition_after_start(transition_index(utc_from.year, utc_from.mon))
-          
-          if from
-            while from < @transitions.length && @transitions[from].at < utc_from
-              from += 1
-            end
-            
-            if from >= @transitions.length
-              return []
-            end
-          else
-            # utc_from is later than last transition.
-            return []
-          end
-        else
-          from = 0
-        end
-        
-        to = transition_before_end(transition_index(utc_to.year, utc_to.mon))
-        
-        if to
-          while to >= 0 && @transitions[to].at >= utc_to
-            to -= 1
-          end
-          
-          if to < 0
-            return []
-          end
-        else
-          # utc_to is earlier than first transition.
-          return []
-        end
-
-        @transitions[from..to]
-      else
-        []
-      end
-    end
-    
-    private
-      # Returns the index into the @transitions_index array for a given year 
-      # and month.
-      def transition_index(year, month)
-        index = (year - @start_year) * 2
-        index += 1 if month > 6
-        index -= 1 if @start_month > 6
-        index
-      end
-      
-      # Returns the index into @transitions of the first transition that occurs
-      # on or after the start of the given index into @transitions_index.
-      # Returns nil if there are no such transitions.
-      def transition_after_start(index)
-        if index >= @transitions_index.length
-          nil
-        else
-          index = 0 if index < 0
-          @transitions_index[index]
-        end
-      end
-      
-      # Returns the index into @transitions of the first transition that occurs
-      # before the end of the given index into @transitions_index.
-      # Returns nil if there are no such transitions.
-      def transition_before_end(index)
-        index = index + 1
-        
-        if index <= 0
-          nil
-        elsif index >= @transitions_index.length          
-          @transitions.length - 1
-        else      
-          @transitions_index[index] - 1          
-        end
-      end            
-  end
-end

data/lib/tzinfo/transition_rule.rb

@@ -1,325 +0,0 @@
-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_country_info.rb

@@ -1,37 +0,0 @@
-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.
-    def initialize(code, name, zones)
-      super(code, name)
-      @zones = zones.dup.freeze
-      @zone_identifiers = nil
-    end
-    
-    # Returns a frozen array of all the zone identifiers for the country ordered
-    # geographically, most populous first.
-    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 
-    # ordered geographically, most populous first.
-    def zones
-      @zones
-    end
-  end
-end