tzinfo 1.2.5 → 1.2.9

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2018 Philip Ross
+Copyright (c) 2005-2020 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 

data/README.md

@@ -1,9 +1,9 @@
 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)
+[![RubyGems](https://img.shields.io/gem/v/tzinfo)](https://rubygems.org/gems/tzinfo) [![Travis CI Build](https://img.shields.io/travis/com/tzinfo/tzinfo/1.2?logo=travis)](https://travis-ci.com/tzinfo/tzinfo) [![AppVeyor Build](https://img.shields.io/appveyor/build/philr/tzinfo/1.2?logo=appveyor)](https://ci.appveyor.com/project/philr/tzinfo/branch/1.2)
 
-[TZInfo](http://tzinfo.github.io) provides daylight savings aware 
+[TZInfo](https://tzinfo.github.io) provides daylight savings aware
 transformations between times in different timezones.
 
 
@@ -13,10 +13,10 @@ 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).
+   of Ruby modules that are generated from the [IANA Time Zone Database](https://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).
+   [IANA Time Zone Database](https://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
@@ -25,7 +25,7 @@ directory instead (using the search path specified by
 
 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 
+[in the wiki](https://tzinfo.github.io/datasourcenotfound) to help with
 resolving `TZInfo::DataSourceNotFound` errors.
 
 The default data source selection can be overridden using 
@@ -60,8 +60,9 @@ of `TZInfo::Timezone`) and convert a time in UTC to local New York time:
     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.
+return `"UTC"`). This is because the Time class in older (but still supported by
+TZInfo) versions of Ruby can only handle two timezones: UTC and the system local
+timezone.
   
 To convert from a local time to UTC, the `local_to_utc` method can be used as
 follows:
@@ -129,7 +130,7 @@ thread boundaries.
 Documentation
 -------------
 
-API documentation for TZInfo is available on [RubyDoc.info](http://rubydoc.info/gems/tzinfo/frames).
+API documentation for TZInfo is available on [RubyDoc.info](https://rubydoc.info/gems/tzinfo/frames).
 
 
 License

data/lib/tzinfo.rb

@@ -10,6 +10,8 @@ require 'tzinfo/timezone_definition'
 
 require 'tzinfo/timezone_offset'
 require 'tzinfo/timezone_transition'
+require 'tzinfo/transition_rule'
+require 'tzinfo/annual_rules'
 require 'tzinfo/timezone_transition_definition'
 
 require 'tzinfo/timezone_index_definition'
@@ -22,6 +24,7 @@ require 'tzinfo/zoneinfo_timezone_info'
 
 require 'tzinfo/data_source'
 require 'tzinfo/ruby_data_source'
+require 'tzinfo/posix_time_zone_parser'
 require 'tzinfo/zoneinfo_data_source'
 
 require 'tzinfo/timezone_period'

data/lib/tzinfo/annual_rules.rb

@@ -0,0 +1,51 @@
+module TZInfo
+  # A set of rules that define when transitions occur in time zones with
+  # annually occurring daylight savings time.
+  #
+  # @private
+  class AnnualRules #:nodoc:
+    # Returned by #transitions. #offset is the TimezoneOffset that applies
+    # from the UTC TimeOrDateTime #at. #previous_offset is the prior
+    # TimezoneOffset.
+    Transition = Struct.new(:offset, :previous_offset, :at)
+
+    # The standard offset that applies when daylight savings time is not in
+    # force.
+    attr_reader :std_offset
+
+    # The offset that applies when daylight savings time is in force.
+    attr_reader :dst_offset
+
+    # The rule that determines when daylight savings time starts.
+    attr_reader :dst_start_rule
+
+    # The rule that determines when daylight savings time ends.
+    attr_reader :dst_end_rule
+
+    # Initializes a new {AnnualRules} instance.
+    def initialize(std_offset, dst_offset, dst_start_rule, dst_end_rule)
+      @std_offset = std_offset
+      @dst_offset = dst_offset
+      @dst_start_rule = dst_start_rule
+      @dst_end_rule = dst_end_rule
+    end
+
+    # Returns the transitions between standard and daylight savings time for a
+    # given year. The results are ordered by time of occurrence (earliest to
+    # latest).
+    def transitions(year)
+      start_dst = apply_rule(@dst_start_rule, @std_offset, @dst_offset, year)
+      end_dst = apply_rule(@dst_end_rule, @dst_offset, @std_offset, year)
+
+      end_dst.at < start_dst.at ? [end_dst, start_dst] : [start_dst, end_dst]
+    end
+
+    private
+
+    # Applies a given rule between offsets on a year.
+    def apply_rule(rule, from_offset, to_offset, year)
+      at = rule.at(from_offset, year)
+      Transition.new(to_offset, from_offset, at)
+    end
+  end
+end

data/lib/tzinfo/data_source.rb

@@ -179,7 +179,7 @@ module TZInfo
       begin
         return ZoneinfoDataSource.new
       rescue ZoneinfoDirectoryNotFound
-        raise DataSourceNotFound, "No source of timezone data could be found.\nPlease refer to http://tzinfo.github.io/datasourcenotfound for help resolving this error."
+        raise DataSourceNotFound, "No source of timezone data could be found.\nPlease refer to https://tzinfo.github.io/datasourcenotfound for help resolving this error."
       end
     end
 

data/lib/tzinfo/posix_time_zone_parser.rb

@@ -0,0 +1,136 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'strscan'
+
+module TZInfo
+  # An {InvalidPosixTimeZone} exception is raised if an invalid POSIX-style
+  # time zone string is encountered.
+  #
+  # @private
+  class InvalidPosixTimeZone < StandardError #:nodoc:
+  end
+
+  # A parser for POSIX-style TZ strings used in zoneinfo files and specified
+  # by tzfile.5 and tzset.3.
+  #
+  # @private
+  class PosixTimeZoneParser #:nodoc:
+    # Parses a POSIX-style TZ string, returning either a TimezoneOffset or
+    # an AnnualRules instance.
+    def parse(tz_string)
+      raise InvalidPosixTimeZone unless tz_string.kind_of?(String)
+      return nil if tz_string.empty?
+
+      s = StringScanner.new(tz_string)
+      check_scan(s, /([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
+      std_abbrev = s[1] || s[2]
+      check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+      std_offset = get_offset_from_hms(s[1], s[2], s[3])
+
+      if s.scan(/([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
+        dst_abbrev = s[1] || s[2]
+
+        if s.scan(/([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+          dst_offset = get_offset_from_hms(s[1], s[2], s[3])
+        else
+          # POSIX is negative for ahead of UTC.
+          dst_offset = std_offset - 3600
+        end
+
+        dst_difference = std_offset - dst_offset
+
+        start_rule = parse_rule(s, 'start')
+        end_rule = parse_rule(s, 'end')
+
+        raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'." if s.rest?
+
+        if start_rule.is_always_first_day_of_year? && start_rule.transition_at == 0 &&
+              end_rule.is_always_last_day_of_year? && end_rule.transition_at == 86400 + dst_difference
+          # Constant daylight savings time.
+          # POSIX is negative for ahead of UTC.
+          TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev.to_sym)
+        else
+          AnnualRules.new(
+            TimezoneOffset.new(-std_offset, 0, std_abbrev.to_sym),
+            TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev.to_sym),
+            start_rule,
+            end_rule)
+        end
+      elsif !s.rest?
+        # Constant standard time.
+        # POSIX is negative for ahead of UTC.
+        TimezoneOffset.new(-std_offset, 0, std_abbrev.to_sym)
+      else
+        raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'."
+      end
+    end
+
+    private
+
+    # Parses the rule from the TZ string, returning a TransitionRule.
+    def parse_rule(s, type)
+      check_scan(s, /,(?: (?: J(\d+) ) | (\d+) | (?: M(\d+)\.(\d)\.(\d) ) )/x)
+      julian_day_of_year = s[1]
+      absolute_day_of_year = s[2]
+      month = s[3]
+      week = s[4]
+      day_of_week = s[5]
+
+      if s.scan(/\//)
+        check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
+        transition_at = get_seconds_after_midnight_from_hms(s[1], s[2], s[3])
+      else
+        transition_at = 7200
+      end
+
+      begin
+        if julian_day_of_year
+          JulianDayOfYearTransitionRule.new(julian_day_of_year.to_i, transition_at)
+        elsif absolute_day_of_year
+          AbsoluteDayOfYearTransitionRule.new(absolute_day_of_year.to_i, transition_at)
+        elsif week == '5'
+          LastDayOfMonthTransitionRule.new(month.to_i, day_of_week.to_i, transition_at)
+        else
+          DayOfMonthTransitionRule.new(month.to_i, week.to_i, day_of_week.to_i, transition_at)
+        end
+      rescue ArgumentError => e
+        raise InvalidPosixTimeZone, "Invalid #{type} rule in POSIX-style time zone string: #{e}"
+      end
+    end
+
+    # Returns an offset in seconds from hh:mm:ss values. The value can be
+    # negative. -02:33:12 would represent 2 hours, 33 minutes and 12 seconds
+    # ahead of UTC.
+    def get_offset_from_hms(h, m, s)
+      h = h.to_i
+      m = m.to_i
+      s = s.to_i
+      raise InvalidPosixTimeZone, "Invalid minute #{m} in offset for POSIX-style time zone string." if m > 59
+      raise InvalidPosixTimeZone, "Invalid second #{s} in offset for POSIX-style time zone string." if s > 59
+      magnitude = (h.abs * 60 + m) * 60 + s
+      h < 0 ? -magnitude : magnitude
+    end
+
+    # Returns the seconds from midnight from hh:mm:ss values. Hours can exceed
+    # 24 for a time on the following day. Hours can be negative to subtract
+    # hours from midnight on the given day. -02:33:12 represents 22:33:12 on
+    # the prior day.
+    def get_seconds_after_midnight_from_hms(h, m, s)
+      h = h.to_i
+      m = m.to_i
+      s = s.to_i
+      raise InvalidPosixTimeZone, "Invalid minute #{m} in time for POSIX-style time zone string." if m > 59
+      raise InvalidPosixTimeZone, "Invalid second #{s} in time for POSIX-style time zone string." if s > 59
+      (h * 3600) + m * 60 + s
+    end
+
+    # Scans for a pattern and raises an exception if the pattern does not
+    # match the input.
+    def check_scan(s, pattern)
+      result = s.scan(pattern)
+      raise InvalidPosixTimeZone, "Expected '#{s.rest}' to match #{pattern} in POSIX-style time zone string." unless result
+      result
+    end
+  end
+end

data/lib/tzinfo/ruby_core_support.rb

@@ -137,10 +137,33 @@ module TZInfo
       def self.open_file(file_name, mode, opts, &block)
         File.open(file_name, mode, &block)
       end
-    else
+    elsif RUBY_VERSION =~ /\A1\.9\./
       def self.open_file(file_name, mode, opts, &block)
         File.open(file_name, mode, opts, &block)
       end
+    else
+      # Evaluate method as a string because **opts isn't valid syntax prior to
+      # Ruby 2.0.
+      eval(<<-EOF
+        def self.open_file(file_name, mode, opts, &block)
+          File.open(file_name, mode, **opts, &block)
+        end
+      EOF
+      )
+    end
+
+
+    # Object#untaint is a deprecated no-op in Ruby >= 2.7 and will be removed in
+    # 3.2. Add a refinement to either silence the warning, or supply the method
+    # if needed.
+    if !Object.new.respond_to?(:untaint) || RUBY_VERSION =~ /\A(\d+)\.(\d+)(?:\.|\z)/ && ($1 == '2' && $2.to_i >= 7 || $1.to_i >= 3)
+      module UntaintExt
+        refine Object do
+          def untaint
+            self
+          end
+        end
+      end
     end
   end
 end

data/lib/tzinfo/ruby_data_source.rb

@@ -1,4 +1,8 @@
 module TZInfo
+  # Use send as a workaround for erroneous 'wrong number of arguments' errors
+  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
+  send(:using, RubyCoreSupport::UntaintExt) if RubyCoreSupport.const_defined?(:UntaintExt)
+
   # A DataSource that loads data from the set of Ruby modules included in the
   # TZInfo::Data library (tzinfo-data gem).
   #
@@ -6,15 +10,30 @@ module TZInfo
   #
   #   TZInfo::DataSource.set(:ruby)
   class RubyDataSource < DataSource
-    # Base path for require.
-    REQUIRE_PATH = File.join('tzinfo', 'data', 'definitions')
-    
     # Whether the timezone index has been loaded yet.
     @@timezone_index_loaded = false
     
     # Whether the country index has been loaded yet.
     @@country_index_loaded = false
   
+    # Initializes a new RubyDataSource instance.
+    def initialize
+      tzinfo_data = File.join('tzinfo', 'data')
+      begin
+        require(tzinfo_data)
+
+        data_file = File.join('', 'tzinfo', 'data.rb')
+        path = $".reverse_each.detect {|p| p.end_with?(data_file) }
+        if path
+          @base_path = File.join(File.dirname(path), 'data').untaint
+        else
+          @base_path = tzinfo_data
+        end
+      rescue LoadError
+        @base_path = tzinfo_data
+      end
+    end
+
     # Returns a TimezoneInfo instance for a given identifier. 
     # Raises InvalidTimezoneIdentifier if the timezone is not found or the 
     # identifier is invalid.
@@ -93,27 +112,17 @@ module TZInfo
     end
     
     # Requires an index by its name.
-    def self.require_index(name)
+    def require_index(name)
       require_data(*['indexes', name])
     end
     
     # Requires a file from tzinfo/data.
     def require_data(*file)
-      self.class.require_data(*file)
-    end
-    
-    # Requires a file from tzinfo/data.
-    def self.require_data(*file)
-      require File.join('tzinfo', 'data', *file)
+      require(File.join(@base_path, *file))
     end
     
     # Loads in the index of timezones if it hasn't already been loaded.
     def load_timezone_index
-      self.class.load_timezone_index
-    end
-    
-    # Loads in the index of timezones if it hasn't already been loaded.
-    def self.load_timezone_index
       unless @@timezone_index_loaded
         require_index('timezones')
         @@timezone_index_loaded = true
@@ -122,11 +131,6 @@ module TZInfo
     
     # Loads in the index of countries if it hasn't already been loaded.
     def load_country_index
-      self.class.load_country_index
-    end
-    
-    # Loads in the index of countries if it hasn't already been loaded.
-    def self.load_country_index
       unless @@country_index_loaded
         require_index('countries')
         @@country_index_loaded = true

data/lib/tzinfo/time_or_datetime.rb

@@ -160,6 +160,17 @@ module TZInfo
       end
     end
     alias :day :mday
+
+    # Returns the day of the week (0..6 for Sunday to Saturday).
+    def wday
+      if @time
+        @time.wday
+      elsif @datetime
+        @datetime.wday
+      else
+        to_time.wday
+      end
+    end
     
     # Returns the hour of the day (0..23).
     def hour

data/lib/tzinfo/timezone.rb

@@ -571,17 +571,21 @@ module TZInfo
     # version 2.0.0, %z will be passed to Time#strftime and DateTime#strftime
     # instead. Some of the formatting options may cease to be available
     # depending on the version of Ruby in use (for example, %:::z is only
-    # supported by Time#strftime from MRI version 2.0.0 onwards.)
+    # supported by Time#strftime from MRI version 2.0.0 onwards).
     def strftime(format, utc = Time.now.utc)      
+      utc = TimeOrDateTime.wrap(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)
+      local_wrapped = period.to_local(utc)
+      local = local_wrapped.to_orig
+      local = local_wrapped.to_time unless local.kind_of?(Time) || local.kind_of?(DateTime)
       abbreviation = period.abbreviation.to_s.gsub(/%/, '%%')
       
-      format = format.gsub(/%(%*)(Z|:*z)/) do
+      format = format.gsub(/%(%*)([sZ]|:*z)/) do
         if $1.length.odd?
           # Escaped literal percent or series of percents. Pass on to strftime.          
           "#$1%#$2"
+        elsif $2 == "s"
+          "#$1#{utc.to_i}"
         elsif $2 == "Z"
           "#$1#{abbreviation}"
         else
@@ -600,8 +604,8 @@ module TZInfo
             # Passing the invalid format string through to Time#strftime or
             # DateTime#strtime would normally result in it being returned in the
             # result. However, with Ruby 1.8.7 on Windows (as tested with Ruby
-            # 1.8.7-p374 from http://rubyinstaller.org/downloads/archives), this
-            # causes Time#strftime to always return an empty string (e.g.
+            # 1.8.7-p374 from https://rubyinstaller.org/downloads/archives),
+            # this causes Time#strftime to always return an empty string (e.g.
             # Time.now.strftime('a %::::z b') returns '').
             #
             # Escape the percent to force it to be evaluated as a literal.