tzinfo 1.2.5

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2005-2018 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.

data/README.md

@@ -0,0 +1,151 @@
+TZInfo - Ruby Timezone Library
+==============================
+
+[![Gem Version](https://badge.fury.io/rb/tzinfo.svg)](http://badge.fury.io/rb/tzinfo) [![Build Status](https://travis-ci.org/tzinfo/tzinfo.svg?branch=master)](https://travis-ci.org/tzinfo/tzinfo)
+
+[TZInfo](http://tzinfo.github.io) provides daylight savings aware 
+transformations between times in different timezones.
+
+
+Data Sources
+------------
+
+TZInfo requires a source of timezone data. There are two built-in options:
+
+1. The TZInfo::Data library (the tzinfo-data gem). TZInfo::Data contains a set 
+   of Ruby modules that are generated from the [IANA Time Zone Database](http://www.iana.org/time-zones).
+2. A zoneinfo directory. Most Unix-like systems include a zoneinfo directory 
+   containing timezone definitions. These are also generated from the 
+   [IANA Time Zone Database](http://www.iana.org/time-zones).
+
+By default, TZInfo::Data will be used. If TZInfo::Data is not available (i.e. 
+if `require 'tzinfo/data'` fails), then TZInfo will search for a zoneinfo
+directory instead (using the search path specified by 
+`TZInfo::ZoneinfoDataSource::DEFAULT_SEARCH_PATH`).
+
+If no data source can be found, a `TZInfo::DataSourceNotFound` exception will be
+raised when TZInfo is used. Further information is available 
+[in the wiki](http://tzinfo.github.io/datasourcenotfound) to help with 
+resolving `TZInfo::DataSourceNotFound` errors.
+
+The default data source selection can be overridden using 
+`TZInfo::DataSource.set`.
+
+Custom data sources can also be used. See `TZInfo::DataSource.set` for
+further details.
+
+
+Installation
+------------
+
+The TZInfo gem can be installed by running:
+
+    gem install tzinfo
+
+To use the Ruby modules as the data source, TZInfo::Data will also need to be
+installed:
+
+    gem install tzinfo-data
+  
+
+Example Usage
+-------------
+
+The following code will obtain the America/New_York timezone (as an instance
+of `TZInfo::Timezone`) and convert a time in UTC to local New York time:
+
+    require 'tzinfo'
+    
+    tz = TZInfo::Timezone.get('America/New_York')
+    local = tz.utc_to_local(Time.utc(2005,8,29,15,35,0))
+
+Note that the local Time returned will have a UTC timezone (`local.zone` will 
+return `"UTC"`). This is because the Ruby Time class only supports two timezones: 
+UTC and the current system local timezone.
+  
+To convert from a local time to UTC, the `local_to_utc` method can be used as
+follows:
+
+    utc = tz.local_to_utc(local)
+
+Note that the timezone information of the local Time object is ignored (TZInfo
+will just read the date and time and treat them as if there were in the `tz`
+timezone). The following two lines will return the same result regardless of 
+the system's local timezone:
+
+    tz.local_to_utc(Time.local(2006,6,26,1,0,0))
+    tz.local_to_utc(Time.utc(2006,6,26,1,0,0))
+  
+To obtain information about the rules in force at a particular UTC or local 
+time, the `TZInfo::Timezone.period_for_utc` and 
+`TZInfo::Timezone.period_for_local` methods can be used. Both of these methods 
+return `TZInfo::TimezonePeriod` objects. The following gets the identifier for 
+the period (in this case EDT).
+
+    period = tz.period_for_utc(Time.utc(2005,8,29,15,35,0))
+    id = period.zone_identifier
+  
+The current local time in a `Timezone` can be obtained with the 
+`TZInfo::Timezone#now` method:
+
+    now = tz.now
+
+All methods in TZInfo that operate on a time can be used with either `Time` or 
+`DateTime` instances or with Integer timestamps (i.e. as returned by 
+`Time#to_i`). The type of the values returned will match the type passed in.
+
+A list of all the available timezone identifiers can be obtained using the
+`TZInfo::Timezone.all_identifiers` method. `TZInfo::Timezone.all` can be called
+to get an `Array` of all the `TZInfo::Timezone` instances.
+
+Timezones can also be accessed by country (using an ISO 3166-1 alpha-2 country 
+code). The following code retrieves the `TZInfo::Country` instance representing 
+the USA (country code 'US') and then gets all the timezone identifiers used in 
+the USA.
+
+    us = TZInfo::Country.get('US')
+    timezones = us.zone_identifiers
+  
+The `TZInfo::Country#zone_info` method provides an additional description and 
+geographic location for each timezone in a country.
+
+A list of all the available country codes can be obtained using the
+`TZInfo::Country.all_codes` method. `TZInfo::Country.all` can be called to get 
+an `Array` of all the `Country` instances.
+  
+For further detail, please refer to the API documentation for the 
+`TZInfo::Timezone` and `TZInfo::Country` classes.
+
+
+Thread-Safety
+-------------
+
+The `TZInfo::Country` and `TZInfo::Timezone` classes are thread-safe. It is safe
+to use class and instance methods of `TZInfo::Country` and `TZInfo::Timezone` in 
+concurrently executing threads. Instances of both classes can be shared across 
+thread boundaries.
+
+
+Documentation
+-------------
+
+API documentation for TZInfo is available on [RubyDoc.info](http://rubydoc.info/gems/tzinfo/frames).
+
+
+License
+-------
+
+TZInfo is released under the MIT license, see LICENSE for details.
+
+
+Source Code
+-----------
+
+Source code for TZInfo is available on [GitHub](https://github.com/tzinfo/tzinfo).
+
+
+Issue Tracker
+-------------
+
+Please post any bugs, issues, feature requests or questions to the 
+[GitHub issue tracker](https://github.com/tzinfo/tzinfo/issues).

data/Rakefile

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'fileutils'
+require 'rake/testtask'
+
+# Ignore errors loading rdoc/task (the rdoc tasks will be excluded if
+# rdoc is unavailable).
+begin
+  require 'rdoc/task'
+rescue LoadError, RuntimeError
+end
+
+BASE_DIR = File.expand_path(File.dirname(__FILE__))
+
+task :default => [:test]
+
+spec = eval(File.read('tzinfo.gemspec'))
+
+class TZInfoPackageTask < Gem::PackageTask
+  alias_method :orig_sh, :sh
+  private :orig_sh
+
+  def sh(*cmd, &block)
+    if cmd[0] == '__tar_with_owner__' && cmd[1] =~ /\A-?[zjcvf]+\z/
+      opts = cmd[1]
+      cmd = ['tar', 'c', '--owner', '0', '--group', '0', "#{opts.start_with?('-') ? '' : '-'}#{opts.gsub('c', '')}"] + cmd.drop(2)
+    elsif cmd.first =~ /\A__tar_with_owner__ -?([zjcvf]+)(.*)\z/
+      opts = $1
+      args = $2
+      cmd[0] = "tar c --owner 0 --group 0 -#{opts.gsub('c', '')}#{args}"    
+    end
+  
+    orig_sh(*cmd, &block)
+  end
+end
+
+def add_signing_key(spec)
+  # Attempt to find the private key and add options to sign the gem if found.
+  private_key_path = File.expand_path(File.join(BASE_DIR, '..', 'key', 'gem-private_key.pem'))
+  
+  if File.exist?(private_key_path)
+    spec = spec.clone
+    spec.signing_key = private_key_path
+    spec.cert_chain = [File.join(BASE_DIR, 'gem-public_cert.pem')]
+  else
+    puts 'WARNING: Private key not found. Not signing gem file.'
+  end
+  
+  spec
+end
+
+package_task = TZInfoPackageTask.new(add_signing_key(spec)) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar_gz = true
+  pkg.tar_command = '__tar_with_owner__'
+end
+
+# Skip the rdoc task if RDoc::Task is unavailable
+if defined?(RDoc) && defined?(RDoc::Task)
+  RDoc::Task.new do |rdoc|
+    rdoc.rdoc_dir = 'doc'
+    rdoc.options.concat spec.rdoc_options
+    rdoc.rdoc_files.include(spec.extra_rdoc_files) 
+    rdoc.rdoc_files.include('lib')  
+  end
+end
+
+Rake::Task[package_task.package_dir_path].enhance do
+  recurse_chmod(package_task.package_dir_path)
+end
+
+Rake::Task[:package].enhance do
+  FileUtils.rm_rf(package_task.package_dir_path)
+end
+
+def recurse_chmod(dir)
+  File.chmod(0755, dir)
+  
+  Dir.entries(dir).each do |entry|
+    if entry != '.' && entry != '..'    
+      path = File.join(dir, entry)
+      if File.directory?(path)
+        recurse_chmod(path)
+      else
+        File.chmod(0644, path)
+      end
+    end
+  end
+end
+
+desc 'Run tests using RubyDataSource, then ZoneinfoDataSource'
+task :test => [:test_ruby, :test_zoneinfo] do
+end
+
+def setup_tests(test_task, type)
+  test_task.libs = [File.join(BASE_DIR, 'lib')]
+  test_task.pattern = File.join(BASE_DIR, 'test', "ts_all_#{type}.rb")
+  test_task.warning = true
+end
+
+Rake::TestTask.new(:test_ruby) do |t|
+  setup_tests(t, :ruby)
+end
+
+Rake::TestTask.new(:test_zoneinfo) do |t|
+  setup_tests(t, :zoneinfo)
+end

data/lib/tzinfo.rb

@@ -0,0 +1,40 @@
+# Top level module for TZInfo.
+module TZInfo
+end
+
+require 'tzinfo/ruby_core_support'
+require 'tzinfo/offset_rationals'
+require 'tzinfo/time_or_datetime'
+
+require 'tzinfo/timezone_definition'
+
+require 'tzinfo/timezone_offset'
+require 'tzinfo/timezone_transition'
+require 'tzinfo/timezone_transition_definition'
+
+require 'tzinfo/timezone_index_definition'
+
+require 'tzinfo/timezone_info'
+require 'tzinfo/data_timezone_info'
+require 'tzinfo/linked_timezone_info'
+require 'tzinfo/transition_data_timezone_info'
+require 'tzinfo/zoneinfo_timezone_info'
+
+require 'tzinfo/data_source'
+require 'tzinfo/ruby_data_source'
+require 'tzinfo/zoneinfo_data_source'
+
+require 'tzinfo/timezone_period'
+require 'tzinfo/timezone'
+require 'tzinfo/info_timezone'
+require 'tzinfo/data_timezone'
+require 'tzinfo/linked_timezone'
+require 'tzinfo/timezone_proxy'
+
+require 'tzinfo/country_index_definition'
+require 'tzinfo/country_info'
+require 'tzinfo/ruby_country_info'
+require 'tzinfo/zoneinfo_country_info'
+
+require 'tzinfo/country'
+require 'tzinfo/country_timezone'

data/lib/tzinfo/country.rb

@@ -0,0 +1,196 @@
+require 'thread_safe'
+
+module TZInfo
+  # Raised by Country#get if the code given is not valid.
+  class InvalidCountryCode < StandardError
+  end
+  
+  # The Country class represents an ISO 3166-1 country. It can be used to 
+  # obtain a list of Timezones for a country. For example:
+  #
+  #  us = Country.get('US')
+  #  us.zone_identifiers
+  #  us.zones
+  #  us.zone_info
+  #
+  # The Country class is thread-safe. It is safe to use class and instance 
+  # methods of Country in concurrently executing threads. Instances of Country
+  # can be shared across thread boundaries.
+  #
+  # Country information available through TZInfo is intended as an aid for 
+  # users, to help them select time zone data appropriate for their practical 
+  # needs. It is not intended to take or endorse any position on legal or 
+  # territorial claims.
+  class Country
+    include Comparable
+    
+    # Defined countries.
+    #
+    # @!visibility private
+    @@countries = nil
+    
+    # Whether the countries index has been loaded yet.
+    #
+    # @!visibility private
+    @@index_loaded = false
+    
+    # Gets a Country by its ISO 3166-1 alpha-2 code. Raises an 
+    # InvalidCountryCode exception if it couldn't be found.
+    def self.get(identifier)
+      instance = @@countries[identifier]
+      
+      unless instance
+        # Thread-safety: It is possible that multiple equivalent Country 
+        # instances could be created here in concurrently executing threads. 
+        # The consequences of this are that the data may be loaded more than 
+        # once (depending on the data source) and memoized calculations could
+        # be discarded. The performance benefit of ensuring that only a single
+        # instance is created is unlikely to be worth the overhead of only
+        # allowing one Country to be loaded at a time.
+        info = data_source.load_country_info(identifier)  
+        instance = Country.new(info)
+        @@countries[identifier] = instance
+      end      
+      
+      instance        
+    end
+    
+    # If identifier is a CountryInfo object, initializes the Country instance, 
+    # otherwise calls get(identifier).
+    def self.new(identifier)      
+      if identifier.kind_of?(CountryInfo)
+        instance = super()
+        instance.send :setup, identifier
+        instance
+      else
+        get(identifier)
+      end
+    end
+    
+    # Returns an Array of all the valid country codes.
+    def self.all_codes
+      data_source.country_codes
+    end
+    
+    # Returns an Array of all the defined Countries.
+    def self.all
+      data_source.country_codes.collect {|code| get(code)}
+    end       
+    
+    # The ISO 3166-1 alpha-2 country code.
+    def code
+      @info.code
+    end
+    
+    # The name of the country.
+    def name
+      @info.name
+    end
+    
+    # Alias for name.
+    def to_s
+      name
+    end
+    
+    # Returns internal object state as a programmer-readable string.
+    def inspect
+      "#<#{self.class}: #{@info.code}>"
+    end
+    
+    # Returns a frozen array of all the zone identifiers for the country. These
+    # are in an order that
+    #
+    # 1. makes some geographical sense, and
+    # 2. puts the most populous zones first, where that does not contradict 1.
+    #
+    # Returned zone identifiers may refer to cities and regions outside of the
+    # country. This will occur if the zone covers multiple countries. Any zones
+    # referring to a city or region in a different country will be listed after
+    # those relating to this country.
+    def zone_identifiers
+      @info.zone_identifiers
+    end
+    alias zone_names zone_identifiers
+    
+    # An array of all the Timezones for this country. Returns TimezoneProxy
+    # objects to avoid the overhead of loading Timezone definitions until
+    # a conversion is actually required. The Timezones are returned in an order
+    # that
+    #
+    # 1. makes some geographical sense, and
+    # 2. puts the most populous zones first, where that does not contradict 1.
+    #
+    # Identifiers of the zones returned may refer to cities and regions outside
+    # of the country. This will occur if the zone covers multiple countries. Any
+    # zones referring to a city or region in a different country will be listed
+    # after those relating to this country.
+    def zones
+      zone_identifiers.collect {|id|
+        Timezone.get_proxy(id)        
+      }
+    end
+    
+    # Returns a frozen array of all the timezones for the for the country as
+    # CountryTimezone instances (containing extra information about each zone). 
+    # These are in an order that
+    #
+    # 1. makes some geographical sense, and
+    # 2. puts the most populous zones first, where that does not contradict 1.
+    #
+    # Identifiers and descriptions of the zones returned may refer to cities and
+    # regions outside of the country. This will occur if the zone covers
+    # multiple countries. Any zones referring to a city or region in a different
+    # country will be listed after those relating to this country.
+    def zone_info
+      @info.zones
+    end
+        
+    # Compare two Countries based on their code. Returns -1 if c is less
+    # than self, 0 if c is equal to self and +1 if c is greater than self.
+    #
+    # Returns nil if c is not comparable with Country instances.
+    def <=>(c)
+      return nil unless c.is_a?(Country)
+      code <=> c.code
+    end
+    
+    # Returns true if and only if the code of c is equal to the code of this
+    # Country.
+    def eql?(c)
+      self == c
+    end
+    
+    # Returns a hash value for this Country.
+    def hash
+      code.hash
+    end
+    
+    # Dumps this Country for marshalling.
+    def _dump(limit)
+      code
+    end
+    
+    # Loads a marshalled Country.
+    def self._load(data)
+      Country.get(data)
+    end
+    
+    private
+      # Called by Country.new to initialize a new Country instance. The info
+      # parameter is a CountryInfo that defines the country.
+      def setup(info)
+        @info = info        
+      end
+
+      # Initializes @@countries.
+      def self.init_countries
+        @@countries = ThreadSafe::Cache.new
+      end
+      init_countries
+      
+      # Returns the current DataSource
+      def self.data_source
+        DataSource.get
+      end
+  end 
+end