--- /dev/null
+#--
+# Copyright (c) 2005-2006 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 the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#++
+
+require 'date'
+# require 'tzinfo/country'
+require 'tzinfo/time_or_datetime'
+require 'tzinfo/timezone_period'
+
+module TZInfo
+ # Indicate a specified time in a local timezone has more than one
+ # possible time in UTC. This happens when switching from daylight savings time
+ # to normal time where the clocks are rolled back. Thrown by period_for_local
+ # and local_to_utc when using an ambiguous time and not specifying any
+ # means to resolve the ambiguity.
+ class AmbiguousTime < StandardError
+ end
+
+ # Thrown to indicate that no TimezonePeriod matching a given time could be found.
+ class PeriodNotFound < StandardError
+ end
+
+ # Thrown by Timezone#get if the identifier given is not valid.
+ class InvalidTimezoneIdentifier < StandardError
+ end
+
+ # Thrown if an attempt is made to use a timezone created with Timezone.new(nil).
+ class UnknownTimezone < StandardError
+ end
+
+ # Timezone is the base class of all timezones. It provides a factory method
+ # get to access timezones by identifier. Once a specific Timezone has been
+ # retrieved, DateTimes, Times and timestamps can be converted between the UTC
+ # and the local time for the zone. For example:
+ #
+ # tz = TZInfo::Timezone.get('America/New_York')
+ # puts tz.utc_to_local(DateTime.new(2005,8,29,15,35,0)).to_s
+ # puts tz.local_to_utc(Time.utc(2005,8,29,11,35,0)).to_s
+ # puts tz.utc_to_local(1125315300).to_s
+ #
+ # Each time conversion method returns an object of the same type it was
+ # passed.
+ #
+ # The timezone information all comes from the tz database
+ # (see http://www.twinsun.com/tz/tz-link.htm)
+ class Timezone
+ include Comparable
+
+ # Cache of loaded zones by identifier to avoid using require if a zone
+ # has already been loaded.
+ @@loaded_zones = {}
+
+ # Whether the timezones index has been loaded yet.
+ @@index_loaded = false
+
+ # Returns a timezone by its identifier (e.g. "Europe/London",
+ # "America/Chicago" or "UTC").
+ #
+ # Raises InvalidTimezoneIdentifier if the timezone couldn't be found.
+ def self.get(identifier)
+ instance = @@loaded_zones[identifier]
+ unless instance
+ raise InvalidTimezoneIdentifier, 'Invalid identifier' if identifier !~ /^[A-z0-9\+\-_]+(\/[A-z0-9\+\-_]+)*$/
+ identifier = identifier.gsub(/-/, '__m__').gsub(/\+/, '__p__')
+ begin
+ # Use a temporary variable to avoid an rdoc warning
+ file = "tzinfo/definitions/#{identifier}"
+ require file
+
+ m = Definitions
+ identifier.split(/\//).each {|part|
+ m = m.const_get(part)
+ }
+
+ info = m.get
+
+ # Could make Timezone subclasses register an interest in an info
+ # type. Since there are currently only two however, there isn't
+ # much point.
+ if info.kind_of?(DataTimezoneInfo)
+ instance = DataTimezone.new(info)
+ elsif info.kind_of?(LinkedTimezoneInfo)
+ instance = LinkedTimezone.new(info)
+ else
+ raise InvalidTimezoneIdentifier, "No handler for info type #{info.class}"
+ end
+
+ @@loaded_zones[instance.identifier] = instance
+ rescue LoadError, NameError => e
+ raise InvalidTimezoneIdentifier, e.message
+ end
+ end
+
+ instance
+ end
+
+ # Returns a proxy for the Timezone with the given identifier. The proxy
+ # will cause the real timezone to be loaded when an attempt is made to
+ # find a period or convert a time. get_proxy will not validate the
+ # identifier. If an invalid identifier is specified, no exception will be
+ # raised until the proxy is used.
+ def self.get_proxy(identifier)
+ TimezoneProxy.new(identifier)
+ end
+
+ # If identifier is nil calls super(), otherwise calls get. An identfier
+ # should always be passed in when called externally.
+ def self.new(identifier = nil)
+ if identifier
+ get(identifier)
+ else
+ super()
+ end
+ end
+
+ # Returns an array containing all the available Timezones.
+ #
+ # Returns TimezoneProxy objects to avoid the overhead of loading Timezone
+ # definitions until a conversion is actually required.
+ def self.all
+ get_proxies(all_identifiers)
+ end
+
+ # Returns an array containing the identifiers of all the available
+ # Timezones.
+ def self.all_identifiers
+ load_index
+ Indexes::Timezones.timezones
+ end
+
+ # Returns an array containing all the available Timezones that are based
+ # on data (are not links to other Timezones).
+ #
+ # Returns TimezoneProxy objects to avoid the overhead of loading Timezone
+ # definitions until a conversion is actually required.
+ def self.all_data_zones
+ get_proxies(all_data_zone_identifiers)
+ end
+
+ # Returns an array containing the identifiers of all the available
+ # Timezones that are based on data (are not links to other Timezones)..
+ def self.all_data_zone_identifiers
+ load_index
+ Indexes::Timezones.data_timezones
+ end
+
+ # Returns an array containing all the available Timezones that are links
+ # to other Timezones.
+ #
+ # Returns TimezoneProxy objects to avoid the overhead of loading Timezone
+ # definitions until a conversion is actually required.
+ def self.all_linked_zones
+ get_proxies(all_linked_zone_identifiers)
+ end
+
+ # Returns an array containing the identifiers of all the available
+ # Timezones that are links to other Timezones.
+ def self.all_linked_zone_identifiers
+ load_index
+ Indexes::Timezones.linked_timezones
+ end
+
+ # Returns all the Timezones defined for all Countries. This is not the
+ # complete set of Timezones as some are not country specific (e.g.
+ # 'Etc/GMT').
+ #
+ # Returns TimezoneProxy objects to avoid the overhead of loading Timezone
+ # definitions until a conversion is actually required.
+ def self.all_country_zones
+ Country.all_codes.inject([]) {|zones,country|
+ zones += Country.get(country).zones
+ }
+ end
+
+ # Returns all the zone identifiers defined for all Countries. This is not the
+ # complete set of zone identifiers as some are not country specific (e.g.
+ # 'Etc/GMT'). You can obtain a Timezone instance for a given identifier
+ # with the get method.
+ def self.all_country_zone_identifiers
+ Country.all_codes.inject([]) {|zones,country|
+ zones += Country.get(country).zone_identifiers
+ }
+ end
+
+ # Returns all US Timezone instances. A shortcut for
+ # TZInfo::Country.get('US').zones.
+ #
+ # Returns TimezoneProxy objects to avoid the overhead of loading Timezone
+ # definitions until a conversion is actually required.
+ def self.us_zones
+ Country.get('US').zones
+ end
+
+ # Returns all US zone identifiers. A shortcut for
+ # TZInfo::Country.get('US').zone_identifiers.
+ def self.us_zone_identifiers
+ Country.get('US').zone_identifiers
+ end
+
+ # The identifier of the timezone, e.g. "Europe/Paris".
+ def identifier
+ raise UnknownTimezone, 'TZInfo::Timezone constructed directly'
+ end
+
+ # An alias for identifier.
+ def name
+ # Don't use alias, as identifier gets overridden.
+ identifier
+ end
+
+ # Returns a friendlier version of the identifier.
+ def to_s
+ friendly_identifier
+ end
+
+ # Returns internal object state as a programmer-readable string.
+ def inspect
+ "#<#{self.class}: #{identifier}>"
+ end
+
+ # Returns a friendlier version of the identifier. Set skip_first_part to
+ # omit the first part of the identifier (typically a region name) where
+ # there is more than one part.
+ #
+ # For example:
+ #
+ # Timezone.get('Europe/Paris').friendly_identifier(false) #=> "Europe - Paris"
+ # Timezone.get('Europe/Paris').friendly_identifier(true) #=> "Paris"
+ # Timezone.get('America/Indiana/Knox').friendly_identifier(false) #=> "America - Knox, Indiana"
+ # Timezone.get('America/Indiana/Knox').friendly_identifier(true) #=> "Knox, Indiana"
+ def friendly_identifier(skip_first_part = false)
+ parts = identifier.split('/')
+ if parts.empty?
+ # shouldn't happen
+ identifier
+ elsif parts.length == 1
+ parts[0]
+ else
+ if skip_first_part
+ result = ''
+ else
+ result = parts[0] + ' - '
+ end
+
+ parts[1, parts.length - 1].reverse_each {|part|
+ part.gsub!(/_/, ' ')
+
+ if part.index(/[a-z]/)
+ # Missing a space if a lower case followed by an upper case and the
+ # name isn't McXxxx.
+ part.gsub!(/([^M][a-z])([A-Z])/, '\1 \2')
+ part.gsub!(/([M][a-bd-z])([A-Z])/, '\1 \2')
+
+ # Missing an apostrophe if two consecutive upper case characters.
+ part.gsub!(/([A-Z])([A-Z])/, '\1\'\2')
+ end
+
+ result << part
+ result << ', '
+ }
+
+ result.slice!(result.length - 2, 2)
+ result
+ end
+ end
+
+ # 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).
+ def period_for_utc(utc)
+ raise UnknownTimezone, 'TZInfo::Timezone constructed directly'
+ 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 ambiguities should be resolved.
+ # Returns an empty array if no periods are found for the given time.
+ def periods_for_local(local)
+ raise UnknownTimezone, 'TZInfo::Timezone constructed directly'
+ end
+
+ # Returns the TimezonePeriod for the given local time. local can either be
+ # a DateTime, Time or integer timestamp (Time.to_i). Any timezone
+ # information in local is ignored (it is treated as a time in the current
+ # timezone).
+ #
+ # Warning: There are local times that have no equivalent UTC times (e.g.
+ # in the transition from standard time to daylight savings time). There are
+ # also local times that have more than one UTC equivalent (e.g. in the
+ # transition from daylight savings time to standard time).
+ #
+ # In the first case (no equivalent UTC time), a PeriodNotFound exception
+ # will be raised.
+ #
+ # In the second case (more than one equivalent UTC time), an AmbiguousTime
+ # exception will be raised unless the optional dst parameter or block
+ # handles the ambiguity.
+ #
+ # If the ambiguity is due to a transition from daylight savings time to
+ # standard time, the dst parameter can be used to select whether the
+ # daylight savings time or local time is used. For example,
+ #
+ # Timezone.get('America/New_York').period_for_local(DateTime.new(2004,10,31,1,30,0))
+ #
+ # would raise an AmbiguousTime exception.
+ #
+ # Specifying dst=true would the daylight savings period from April to
+ # October 2004. Specifying dst=false would return the standard period
+ # from October 2004 to April 2005.
+ #
+ # If the dst parameter does not resolve the ambiguity, and a block is
+ # specified, it is called. The block must take a single parameter - an
+ # array of the periods that need to be resolved. The block can select and
+ # return a single period or return nil or an empty array
+ # to cause an AmbiguousTime exception to be raised.
+ def period_for_local(local, dst = nil)
+ results = periods_for_local(local)
+
+ if results.empty?
+ raise PeriodNotFound
+ elsif results.size < 2
+ results.first
+ else
+ # ambiguous result try to resolve
+
+ if !dst.nil?
+ matches = results.find_all {|period| period.dst? == dst}
+ results = matches if !matches.empty?
+ end
+
+ if results.size < 2
+ results.first
+ else
+ # still ambiguous, try the block
+
+ if block_given?
+ results = yield results
+ end
+
+ if results.is_a?(TimezonePeriod)
+ results
+ elsif results && results.size == 1
+ results.first
+ else
+ raise AmbiguousTime, "#{local} is an ambiguous local time."
+ end
+ end
+ end
+ end
+
+ # Converts a time in UTC to the local timezone. utc can either be
+ # a DateTime, Time or timestamp (Time.to_i). The returned time has the same
+ # type as utc. Any timezone information in utc is ignored (it is treated as
+ # a UTC time).
+ def utc_to_local(utc)
+ TimeOrDateTime.wrap(utc) {|wrapped|
+ period_for_utc(wrapped).to_local(wrapped)
+ }
+ end
+
+ # Converts a time in the local timezone to UTC. local can either be
+ # a DateTime, Time or timestamp (Time.to_i). The returned time has the same
+ # type as local. Any timezone information in local is ignored (it is treated
+ # as a local time).
+ #
+ # Warning: There are local times that have no equivalent UTC times (e.g.
+ # in the transition from standard time to daylight savings time). There are
+ # also local times that have more than one UTC equivalent (e.g. in the
+ # transition from daylight savings time to standard time).
+ #
+ # In the first case (no equivalent UTC time), a PeriodNotFound exception
+ # will be raised.
+ #
+ # In the second case (more than one equivalent UTC time), an AmbiguousTime
+ # exception will be raised unless the optional dst parameter or block
+ # handles the ambiguity.
+ #
+ # If the ambiguity is due to a transition from daylight savings time to
+ # standard time, the dst parameter can be used to select whether the
+ # daylight savings time or local time is used. For example,
+ #
+ # Timezone.get('America/New_York').local_to_utc(DateTime.new(2004,10,31,1,30,0))
+ #
+ # would raise an AmbiguousTime exception.
+ #
+ # Specifying dst=true would return 2004-10-31 5:30:00. Specifying dst=false
+ # would return 2004-10-31 6:30:00.
+ #
+ # If the dst parameter does not resolve the ambiguity, and a block is
+ # specified, it is called. The block must take a single parameter - an
+ # array of the periods that need to be resolved. The block can return a
+ # single period to use to convert the time or return nil or an empty array
+ # to cause an AmbiguousTime exception to be raised.
+ def local_to_utc(local, dst = nil)
+ TimeOrDateTime.wrap(local) {|wrapped|
+ if block_given?
+ period = period_for_local(wrapped, dst) {|periods| yield periods }
+ else
+ period = period_for_local(wrapped, dst)
+ end
+
+ period.to_utc(wrapped)
+ }
+ end
+
+ # Returns the current time in the timezone as a Time.
+ def now
+ utc_to_local(Time.now.utc)
+ end
+
+ # Returns the TimezonePeriod for the current time.
+ def current_period
+ period_for_utc(Time.now.utc)
+ end
+
+ # Returns the current Time and TimezonePeriod as an array. The first element
+ # is the time, the second element is the period.
+ def current_period_and_time
+ utc = Time.now.utc
+ period = period_for_utc(utc)
+ [period.to_local(utc), period]
+ end
+
+ alias :current_time_and_period :current_period_and_time
+
+ # Converts a time in UTC to local time and returns it as a string
+ # according to the given format. The formatting is identical to
+ # Time.strftime and DateTime.strftime, except %Z is replaced with the
+ # timezone abbreviation for the specified time (for example, EST or EDT).
+ def strftime(format, utc = Time.now.utc)
+ period = period_for_utc(utc)
+ local = period.to_local(utc)
+ local = Time.at(local).utc unless local.kind_of?(Time) || local.kind_of?(DateTime)
+ abbreviation = period.abbreviation.to_s.gsub(/%/, '%%')
+
+ format = format.gsub(/(.?)%Z/) do
+ if $1 == '%'
+ # return %%Z so the real strftime treats it as a literal %Z too
+ '%%Z'
+ else
+ "#$1#{abbreviation}"
+ end
+ end
+
+ local.strftime(format)
+ end
+
+ # Compares two Timezones based on their identifier. Returns -1 if tz is less
+ # than self, 0 if tz is equal to self and +1 if tz is greater than self.
+ def <=>(tz)
+ identifier <=> tz.identifier
+ end
+
+ # Returns true if and only if the identifier of tz is equal to the
+ # identifier of this Timezone.
+ def eql?(tz)
+ self == tz
+ end
+
+ # Returns a hash of this Timezone.
+ def hash
+ identifier.hash
+ end
+
+ # Dumps this Timezone for marshalling.
+ def _dump(limit)
+ identifier
+ end
+
+ # Loads a marshalled Timezone.
+ def self._load(data)
+ Timezone.get(data)
+ end
+
+ private
+ # Loads in the index of timezones if it hasn't already been loaded.
+ def self.load_index
+ unless @@index_loaded
+ require 'tzinfo/indexes/timezones'
+ @@index_loaded = true
+ end
+ end
+
+ # Returns an array of proxies corresponding to the given array of
+ # identifiers.
+ def self.get_proxies(identifiers)
+ identifiers.collect {|identifier| get_proxy(identifier)}
+ end
+ end
+end
projects / depot.git / blobdiff