et-orbi 1.1.6 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a483e51ede4f1880d1d3ccafcbabcf418f34abf
-  data.tar.gz: 537d66567277eba18947f3c175c244715ce9917f
+  metadata.gz: 63be401cf92b7f62cbb8c778d9ec512c89cd7fc1
+  data.tar.gz: 9e9668a7250fe51ead41650067e04e7c4a29d505
 SHA512:
-  metadata.gz: 975490af3b9c016e8d8c3d30f19d4503ad6753fa7ef56493998f115aac78603db00f04790f04ec1d37bef2fe6132fa6290f3244b526a274eac95c512b7e83499
-  data.tar.gz: ab06522781f0bdf7caeb533c1a499999c9b363ee2d7f55a28d38fcd36706ad007645e66c9393f99cf62c1acc33c6c652d53d408952713e703f723999827545cc
+  metadata.gz: ec5bf95f98d1a528e2411b39c7bea0a32154b6c11345cb37b0da89aabdcf2d110dccee14e045433961bf849e78b381b945279cdeb4575bcd4a4da4c3f888e1c0
+  data.tar.gz: 33028c93d34cd0129f09f4dee8213311588f56f87c3b69495c58dae0f4de23803919b406df8538878c9ce0bb4628cf211f1c0cd27bc7c0b4acac6fb33382fcb1

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 # CHANGELOG.md
 
 
+## et-orbi 1.1.7  released 2019-01-14
+
+- Rework Chronic integration, prevent conflict with ActiveSupport Time.zone
+- Implement EtOrbi.extract_zone(s) (returns s1 and zone name)
+- Adapt specs and EoTime#to_debug_s to Windows on Appveyor
+
+
 ## et-orbi 1.1.6  released 2018-09-05
 
 - Ensure Olson timezone name regex covers all timezone names

data/CREDITS.md

@@ -1,6 +1,7 @@
 
 # et-orbi credits
 
+* Wenhui Wang https://github.com/w11th .parse vs Chronic+ActiveSupport, fugit 11
 * Marcel https://github.com/MTRNord "Mitteleuropaeische Sommerzeit", gh-15
 * Stanisław Pitucha https://github.com/viraptor rubygems link to changelog, gh-14
 * Jamie Stackhouse https://github.com/itsjamie reported warnings, gh-13

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2018, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2019, John Mettraux, jmettraux+flor@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -70,7 +70,7 @@ EtOrbi.platform_info
 
 ### Rails?
 
-If Rails is present, `Time.zone` is provided and EtOrbi will use it.
+If Rails is present, `Time.zone` is provided and EtOrbi will use it, unless `ENV['TZ']` is set to a valid timezone name. Setting `ENV['TZ']` to nil can give back precedence to `Time.zone`.
 
 Rails sets its timezone under `config/application.rb`.
 

data/et-orbi.gemspec

@@ -38,9 +38,18 @@ Time zones for fugit and rufus-scheduler. Urbi et Orbi.
   ]
 
   s.add_runtime_dependency 'tzinfo'
+    #
+    # YES, open dependency, fill an issue at
+    #   https://github.com/floraison/et-orbi/issues
+    # if you experience a conflict between et-orbi and tzinfo.
+    #
+    # DO NOT raise an issue at tzinfo
+    # this open dependency is my (@jmettraux) responsibility.
+
   #s.add_runtime_dependency 'raabro', '>= 1.1.3'
 
   s.add_development_dependency 'rspec', '~> 3.4'
+  s.add_development_dependency 'chronic', '~> 0.10'
 
   s.require_path = 'lib'
 end

data/lib/et-orbi.rb

@@ -4,12 +4,13 @@ require 'time'
 
 require 'tzinfo'
 
+require 'et-orbi/eo_time'
 require 'et-orbi/zone_aliases'
 
 
 module EtOrbi
 
-  VERSION = '1.1.6'
+  VERSION = '1.1.7'
 
   #
   # module methods
@@ -23,63 +24,40 @@ module EtOrbi
 
     def parse(str, opts={})
 
+      str, str_zone = extract_zone(str)
+
       if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-        return EoTime.new(t, nil)
+
+        str = [ t.strftime('%F %T'), str_zone ].compact.join(' ')
       end
 
-      #rold = RUBY_VERSION < '1.9.0'
-      #rold = RUBY_VERSION < '2.0.0'
       begin
         DateTime.parse(str)
       rescue
         fail ArgumentError, "No time information in #{str.inspect}"
-      end #if rold
+      end
+      #end if RUBY_VERSION < '1.9.0'
+      #end if RUBY_VERSION < '2.0.0'
         #
         # is necessary since Time.parse('xxx') in Ruby < 1.9 yields `now`
 
-      str_zone = get_tzone(list_iso8601_zones(str).last)
-#p [ :parse, str, str_zone ]
-#p ENV['TZ']
-
-#p [ :parse, :oz, opts[:zone] ]
-#p [ :parse, :sz, str_zone ]
-#p [ :parse, :foz, find_olson_zone(str) ]
-#p [ :parse, :ltz, local_tzone ]
       zone =
         opts[:zone] ||
-        str_zone ||
-        find_olson_zone(str) ||
+        get_tzone(str_zone) ||
         determine_local_tzone
-#p [ :parse, :zone, zone ]
-
-      str = str.sub(zone.name, '') unless zone.name.match(/\A[-+]/)
-        #
-        # for 'Sun Nov 18 16:01:00 Asia/Singapore 2012',
-        # although where does rufus-scheduler have it from?
 
       local = Time.parse(str)
-#p [ :parse, :local, local, local.zone ]
-
-      secs =
-        if str_zone
-          local.to_f
-        else
-          zone.local_to_utc(local).to_f
-        end
-#p [ :parse, :secs, secs ]
+      secs = zone.local_to_utc(local).to_f
 
       EoTime.new(secs, zone)
     end
 
     def make_time(*a)
 
-#p [ :mt, a ]
       zone = a.length > 1 ? get_tzone(a.last) : nil
       a.pop if zone
-#p [ :mt, zone ]
 
       o = a.length > 1 ? a : a.first
-#p [ :mt, :o, o ]
 
       case o
       when Time then make_from_time(o, zone)
@@ -92,6 +70,7 @@ module EtOrbi
         "Cannot turn #{o.inspect} to a ::EtOrbi::EoTime instance")
       end
     end
+    alias make make_time
 
     def make_from_time(t, zone)
 
@@ -156,6 +135,7 @@ module EtOrbi
       s = unalias(o)
 
       get_offset_tzone(s) ||
+      get_x_offset_tzone(s) ||
       (::TZInfo::Timezone.get(s) rescue nil)
     end
 
@@ -174,6 +154,20 @@ module EtOrbi
       "(secs:#{seconds},utc~:#{ts.inspect},ltz~:#{z.inspect})"
     end
 
+    def tzinfo_version
+
+      #TZInfo::VERSION
+      Gem.loaded_specs['tzinfo'].version.to_s
+    rescue => err
+      err.inspect
+    end
+
+    def tzinfo_data_version
+
+      #TZInfo::Data::VERSION rescue nil
+      Gem.loaded_specs['tzinfo-data'].version.to_s rescue nil
+    end
+
     def platform_info
 
       etos = Proc.new { |k, v| "#{k}:#{v.inspect}" }
@@ -181,7 +175,8 @@ module EtOrbi
       h = {
         'etz' => ENV['TZ'],
         'tnz' => Time.now.zone,
-        'tzid' => defined?(TZInfo::Data),
+        'tziv' => tzinfo_version,
+        'tzidv' => tzinfo_data_version,
         'rv' => RUBY_VERSION,
         'rp' => RUBY_PLATFORM,
         'win' => Gem.win_platform?,
@@ -194,14 +189,13 @@ module EtOrbi
       if ltz = EtOrbi::EoTime.local_tzone
         h['eotnz'] = EtOrbi::EoTime.now.zone
         h['eotnfz'] = EtOrbi::EoTime.now.strftime('%z')
+        h['eotnfZ'] = EtOrbi::EoTime.now.strftime('%Z')
         h['eotlzn'] = ltz.name
       end
 
       "(#{h.map(&etos).join(',')},#{gather_tzs.map(&etos).join(',')})"
     end
 
-    alias make make_time
-
     # For `make info`
     #
     def _make_info
@@ -210,497 +204,104 @@ module EtOrbi
       puts platform_info
     end
 
-    protected
-
-    def get_local_tzone(t)
-
-      #lt = local_tzone
-      #lp = lt.period_for_local(t)
-      #ab = lp.abbreviation.to_s
-      #
-      #return lt \
-      #  if ab == t.zone
-      #return lt \
-      #  if ab.match(/\A[-+]\d{2}(:?\d{2})?\z/) && lp.utc_offset == t.utc_offset
-      #
-      #nil
-        #
-        # keep that in the fridge for now
-
-      l = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec, t.usec)
-
-      (t.zone == l.zone) ? determine_local_tzone : nil
-    end
-
-    def get_as_tzone(t)
-
-      t.respond_to?(:time_zone) ? t.time_zone : nil
-    end
-  end
-
-  # Our EoTime class (which quacks like a ::Time).
-  #
-  # An EoTime instance should respond to most of the methods ::Time instances
-  # respond to. If a method is missing, feel free to open an issue to
-  # ask (politely) for it. If it makes sense, it'll get added, else
-  # a workaround will get suggested.
-  # The immediate workaround is to call #to_t on the EoTime instance to get
-  # equivalent ::Time instance in the local, current, timezone.
-  #
-  class EoTime
-
-    #
-    # class methods
-
-    class << self
-
-      def now(zone=nil)
-
-        EtOrbi.now(zone)
-      end
-
-      def parse(str, opts={})
-
-        EtOrbi.parse(str, opts)
-      end
-
-      def get_tzone(o)
-
-        EtOrbi.get_tzone(o)
-      end
-
-      def local_tzone
-
-        EtOrbi.determine_local_tzone
-      end
-
-      def platform_info
-
-        EtOrbi.platform_info
-      end
-
-      def make(o)
-
-        EtOrbi.make_time(o)
-      end
-
-      def utc(*a)
-
-        EtOrbi.make_from_array(a, EtOrbi.get_tzone('UTC'))
-      end
-
-      def local(*a)
-
-        EtOrbi.make_from_array(a, local_tzone)
-      end
-    end
-
-    #
-    # instance methods
-
-    attr_reader :seconds
-    attr_reader :zone
-
-    def initialize(s, zone)
-
-      @seconds = s.to_f
-      @zone = self.class.get_tzone(zone || :local)
-
-      fail ArgumentError.new(
-        "Cannot determine timezone from #{zone.inspect}" +
-        "\n#{EtOrbi.render_nozone_time(@seconds)}" +
-        "\n#{EtOrbi.platform_info.sub(',debian:', ",\ndebian:")}" +
-        "\nTry setting `ENV['TZ'] = 'Continent/City'` in your script " +
-        "(see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)" +
-        (defined?(TZInfo::Data) ? '' : "\nand adding gem 'tzinfo-data'")
-      ) unless @zone
-
-      @time = nil
-        # cache for #to_time result
-    end
-
-    def seconds=(f)
-
-      @time = nil
-      @seconds = f
-    end
-
-    def zone=(z)
-
-      @time = nil
-      @zone = self.class.get_tzone(zone || :current)
-    end
-
-    # Returns true if this EoTime instance corresponds to 2 different UTC
-    # times.
-    # It happens when transitioning from DST to winter time.
-    #
-    # https://www.timeanddate.com/time/change/usa/new-york?year=2018
-    #
-    def ambiguous?
-
-      @zone.local_to_utc(@zone.utc_to_local(utc))
-
-      false
-
-    rescue TZInfo::AmbiguousTime
-
-      true
-    end
-
-    # Returns this ::EtOrbi::EoTime as a ::Time instance
-    # in the current UTC timezone.
-    #
-    def utc
-
-      Time.utc(1970) + @seconds
-    end
-
-    # Returns true if this ::EtOrbi::EoTime instance timezone is UTC.
-    # Returns false else.
-    #
-    def utc?
-
-      %w[ gmt utc zulu etc/gmt etc/utc ].include?(
-        @zone.canonical_identifier.downcase)
-    end
-
-    alias getutc utc
-    alias getgm utc
-    alias to_utc_time utc
-
-    def to_f
-
-      @seconds
-    end
-
-    def to_i
-
-      @seconds.to_i
-    end
-
-    def strftime(format)
-
-      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
-
-      to_time.strftime(format)
-    end
-
-    # Returns this ::EtOrbi::EoTime as a ::Time instance
-    # in the current timezone.
-    #
-    # Has a #to_t alias.
-    #
-    def to_local_time
-
-      Time.at(@seconds)
-    end
-
-    alias to_t to_local_time
-
-    def is_dst?
-
-      @zone.period_for_utc(utc).std_offset != 0
-    end
-    alias isdst is_dst?
-
-    def to_debug_s
-
-      uo = self.utc_offset
-      uos = uo < 0 ? '-' : '+'
-      uo = uo.abs
-      uoh, uom = [ uo / 3600, uo % 3600 ]
-
-      [
-        'ot',
-        self.strftime('%Y-%m-%d %H:%M:%S'),
-        "%s%02d:%02d" % [ uos, uoh, uom ],
-        "dst:#{self.isdst}"
-      ].join(' ')
-    end
-
-    def utc_offset
-
-      @zone.period_for_utc(utc).utc_offset
-    end
-
-    %w[
-      year month day wday hour min sec usec asctime
-    ].each do |m|
-      define_method(m) { to_time.send(m) }
-    end
-
-    def ==(o)
-
-      o.is_a?(EoTime) &&
-      o.seconds == @seconds &&
-      (o.zone == @zone || o.zone.current_period == @zone.current_period)
-    end
-    #alias eql? == # FIXME see Object#== (ri)
-
-    def >(o); @seconds > _to_f(o); end
-    def >=(o); @seconds >= _to_f(o); end
-    def <(o); @seconds < _to_f(o); end
-    def <=(o); @seconds <= _to_f(o); end
-    def <=>(o); @seconds <=> _to_f(o); end
-
-    def add(t); @time = nil; @seconds += t.to_f; self; end
-    def subtract(t); @time = nil; @seconds -= t.to_f; self; end
-
-    def +(t); inc(t, 1); end
-    def -(t); inc(t, -1); end
-
-    WEEK_S = 7 * 24 * 3600
-
-    def monthdays
-
-      date = to_time
-
-      pos = 1
-      d = self.dup
-
-      loop do
-        d.add(-WEEK_S)
-        break if d.month != date.month
-        pos = pos + 1
-      end
-
-      neg = -1
-      d = self.dup
-
-      loop do
-        d.add(WEEK_S)
-        break if d.month != date.month
-        neg = neg - 1
-      end
-
-      [ "#{date.wday}##{pos}", "#{date.wday}##{neg}" ]
-    end
-
-    def to_s
-
-      strftime('%Y-%m-%d %H:%M:%S %z')
-    end
-
-    def to_zs
-
-      strftime('%Y-%m-%d %H:%M:%S %/Z')
-    end
-
-    def iso8601(fraction_digits=0)
-
-      s = (fraction_digits || 0) > 0 ? ".%#{fraction_digits}N" : ''
-      strftime("%Y-%m-%dT%H:%M:%S#{s}%:z")
-    end
-
-    # Debug current time by showing local time / delta / utc time
-    # for example: "0120-7(0820)"
-    #
-    def to_utc_comparison_s
-
-      per = @zone.period_for_utc(utc)
-      off = per.utc_total_offset
-
-      off = off / 3600
-      off = off >= 0 ? "+#{off}" : off.to_s
-
-      strftime('%H%M') + off + utc.strftime('(%H%M)')
-    end
-
-    def to_time_s
-
-      strftime("%H:%M:%S.#{'%06d' % usec}")
-    end
-
-    def inc(t, dir=1)
-
-      case t
-      when Numeric
-        nt = self.dup
-        nt.seconds += dir * t.to_f
-        nt
-      when ::Time, ::EtOrbi::EoTime
-        fail ArgumentError.new(
-          "Cannot add #{t.class} to EoTime") if dir > 0
-        @seconds + dir * t.to_f
-      else
-        fail ArgumentError.new(
-          "Cannot call add or subtract #{t.class} to EoTime instance")
-      end
-    end
-
-    def localtime(zone=nil)
+    ZONES_ISO8601 =
+      %r{
+        (?<=:\d\d)\s*
+        (?:
+          [-+]
+          (?:[0-1][0-9]|2[0-4])
+          (?:(?::)?(?:[0-5][0-9]|60))?
+          (?![-+])
+            |Z
+        )
+      }x
 
-      EoTime.new(self.to_f, zone)
-    end
-
-    alias translate localtime
-
-    def wday_in_month
-
-      [ count_weeks(-1), - count_weeks(1) ]
-    end
-
-    def reach(points)
-
-      t = EoTime.new(self.to_f, @zone)
-      step = 1
-
-      s = points[:second] || points[:sec] || points[:s]
-      m = points[:minute] || points[:min] || points[:m]
-      h = points[:hour] || points[:hou] || points[:h]
-
-      fail ArgumentError.new("missing :second, :minute, and :hour") \
-        unless s || m || h
-
-      if !s && !m
-        step = 60 * 60
-        t -= t.sec
-        t -= t.min * 60
-      elsif !s
-        step = 60
-        t -= t.sec
-      end
-
-      loop do
-        t += step
-        next if s && t.sec != s
-        next if m && t.min != m
-        next if h && t.hour != h
-        break
-      end
-
-      t
-    end
-
-    protected
-
-    # Returns a Ruby Time instance.
-    #
-    # Warning: the timezone of that Time instance will be UTC when used with
-    # TZInfo < 2.0.0.
+    # https://en.wikipedia.org/wiki/ISO_8601
+    # Postel's law applies
     #
-    def to_time
-
-      @time ||= @zone.utc_to_local(utc)
-    end
-
-    def count_weeks(dir)
-
-      c = 0
-      t = self
-      until t.month != self.month
-        c += 1
-        t += dir * (7 * 24 * 3600)
-      end
+    def list_iso8601_zones(s)
 
-      c
+      s.scan(ZONES_ISO8601).collect(&:strip)
     end
 
-    def strfz(code)
+    ZONES_OLSON = (
+      TZInfo::Timezone.all.collect { |z| z.name }.sort +
+      (0..12).collect { |i| [ "UTC-#{i}", "UTC+#{i}" ] })
+        .flatten
+        .sort_by(&:size)
+        .reverse
 
-      return @zone.name if code == '%/Z'
-
-      per = @zone.period_for_utc(utc)
+    def list_olson_zones(s)
 
-      return per.abbreviation.to_s if code == '%Z'
+      s = s.dup
 
-      off = per.utc_total_offset
-        #
-      sn = off < 0 ? '-' : '+'; off = off.abs
-      hr = off / 3600
-      mn = (off % 3600) / 60
-      sc = 0
-
-      if @zone.name == 'UTC'
-        'Z' # align on Ruby ::Time#iso8601
-      elsif code == '%z'
-        '%s%02d%02d' % [ sn, hr, mn ]
-      elsif code == '%:z'
-        '%s%02d:%02d' % [ sn, hr, mn ]
-      else
-        '%s%02d:%02d:%02d' % [ sn, hr, mn, sc ]
-      end
+      ZONES_OLSON
+        .inject([]) { |a, z|
+          i = s.index(z); next a unless i
+          s[i, z.length] = ''
+          a << z
+          a }
     end
 
-    def _to_f(o)
-
-      fail ArgumentError(
-        "Comparison of EoTime with #{o.inspect} failed"
-      ) unless o.is_a?(EoTime) || o.is_a?(Time)
+    def find_olson_zone(str)
 
-      o.to_f
+      list_olson_zones(str).each { |s| z = get_tzone(s); return z if z }
+      nil
     end
-  end
 
-  class << self
+    def extract_zone(str)
 
-    #
-    # extra public methods
+      s = str.dup
 
-    # https://en.wikipedia.org/wiki/ISO_8601
-    # Postel's law applies
-    #
-    def list_iso8601_zones(s)
+      zs = ZONES_OLSON
+        .inject([]) { |a, z|
+          i = s.index(z); next a unless i
+          a << z
+          s[i, z.length] = ''
+          a }
 
-      s
-        .scan(
-          %r{
-            (?<=:\d\d)
-            \s*
-            (?:
-              [-+]
-              (?:[0-1][0-9]|2[0-4])
-              (?:(?::)?(?:[0-5][0-9]|60))?
-              (?![-+])
-              |
-              Z
-            )
-          }x)
-        .collect(&:strip)
-    end
+      s.gsub!(ZONES_ISO8601) { |m| zs << m.strip; '' } #if zs.empty?
 
-    def list_olson_zones(s)
+      zs = zs.sort_by { |z| str.index(z) }
 
-      s
-        .scan(
-          %r{
-            (?<=\s|\A)
-            (?:[A-Z][A-Za-z0-9+_-]+)
-            (?:\/(?:[A-Z][A-Za-z0-9+_-]+)){0,2}
-          }x)
-    end
-
-    def find_olson_zone(str)
-
-      list_olson_zones(str).each { |s| z = get_tzone(s); return z if z }
-      nil
+      [ s.strip, zs.last ]
     end
 
     def determine_local_tzone
 
+      # ENV has the priority
+
       etz = ENV['TZ']
 
-      tz = etz && (::TZInfo::Timezone.get(etz) rescue nil)
+      tz = etz && get_tzone(etz)
       return tz if tz
 
+      # then Rails/ActiveSupport has the priority
+
       if Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
         tz = Time.zone.tzinfo
         return tz if tz
       end
 
+      # then the operating system is queried
+
       tz = ::TZInfo::Timezone.get(os_tz) rescue nil
       return tz if tz
 
+      # then Ruby's time zone abbs are looked at CST, JST, CEST, ... :-(
+
       tzs = determine_local_tzones
       tz = (etz && tzs.find { |z| z.name == etz }) || tzs.first
       return tz if tz
 
+      # then, fall back to GMT offest :-(
+
       n = Time.now
 
       get_tzone(n.zone) ||
       get_tzone(n.strftime('%Z%z'))
     end
+    alias zone determine_local_tzone
 
     attr_accessor :_os_zone # test tool
 
@@ -712,7 +313,9 @@ module EtOrbi
       @os_tz ||= (debian_tz || centos_tz || osx_tz)
     end
 
-    def to_windows_tz(zone_name, time=Time.now)
+    # Semi-helpful, since it requires the current time
+    #
+    def windows_zone_name(zone_name, time)
 
       twin = Time.utc(time.year, 1, 1) # winter
       tsum = Time.utc(time.year, 7, 1) # summer
@@ -729,7 +332,13 @@ module EtOrbi
         tz.period_for_utc(tsum).abbreviation.to_s ]
           .uniq
 
-      [ abbs[0], tzop, tzoh, tzos, abbs[1] ].compact.join
+      if abbs[0].match(/\A[A-Z]/)
+        [ abbs[0], tzop, tzoh, tzos, abbs[1] ]
+          .compact.join
+      else
+        [ windows_zone_code_x(zone_name), tzop, tzoh, tzos || ':00', zone_name ]
+          .collect(&:to_s).join
+      end
     end
 
     #
@@ -737,6 +346,31 @@ module EtOrbi
 
     protected
 
+    def windows_zone_code_x(zone_name)
+
+      a = [ '_' ]
+      a.concat(zone_name.split('/')[0, 2].collect { |s| s[0, 1].upcase })
+      a << '_' if a.size < 3
+
+      a.join
+    end
+
+    def get_local_tzone(t)
+
+      l = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec, t.usec)
+
+      (t.zone == l.zone) ? determine_local_tzone : nil
+    end
+
+    # https://api.rubyonrails.org/classes/ActiveSupport/TimeWithZone.html
+    #
+    # If it responds to #time_zone, then return that time zone.
+    #
+    def get_as_tzone(t)
+
+      t.respond_to?(:time_zone) ? t.time_zone : nil
+    end
+
     def to_offset(n)
 
       i = n.to_i
@@ -748,17 +382,20 @@ module EtOrbi
         '%s%02d:%02d' % [ sn, hr, mn ]
     end
 
+    # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
+    #
     def get_offset_tzone(str)
 
-      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
-
-      m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])?\z/) rescue nil
+      m = str.match(/\A([+-][0-1]?[0-9]):?([0-5][0-9])?\z/) rescue nil
         #
         # On Windows, the real encoding could be something other than UTF-8,
         # and make the match fail
         #
       return nil unless m
 
+      tz = custom_tzs[str]
+      return tz if tz
+
       hr = m[1].to_i
       mn = m[2].to_i
 
@@ -766,15 +403,12 @@ module EtOrbi
       hr = nil if mn > 59
       mn = -mn if hr && hr < 0
 
-      return (
-        (@custom_tz_cache ||= {})[str] =
-          create_offset_tzone(hr * 3600 + mn * 60, str)
-      ) if hr
-
-      nil
+      hr ?
+        custom_tzs[str] = create_offset_tzone(hr * 3600 + mn * 60, str) :
+        nil
     end
 
-    if defined? TZInfo::DataSources::ConstantOffsetDataTimezoneInfo
+    if defined?(TZInfo::DataSources::ConstantOffsetDataTimezoneInfo)
       # TZInfo >= 2.0.0
 
       def create_offset_tzone(utc_off, id)
@@ -795,6 +429,16 @@ module EtOrbi
       end
     end
 
+    def get_x_offset_tzone(str)
+
+      m = str.match(/\A_..-?[0-1]?\d:?(?:[0-5]\d)?(.+)\z/) rescue nil
+        #
+        # On Windows, the real encoding could be something other than UTF-8,
+        # and make the match fail (as in .get_offset_tzone above)
+
+      m ? ::TZInfo::Timezone.get(m[1]) : nil
+    end
+
     def determine_local_tzones
 
       tabbs = (-6..5)
@@ -811,10 +455,9 @@ module EtOrbi
       twin = Time.local(t.year, 1, 1) # winter
       tsum = Time.local(t.year, 7, 1) # summer
 
-      @tz_all ||= ::TZInfo::Timezone.all
       @tz_winter_summer ||= {}
 
-      @tz_winter_summer[tabbs] ||= @tz_all
+      @tz_winter_summer[tabbs] ||= tz_all
         .select { |tz|
           pw = tz.period_for_local(twin)
           ps = tz.period_for_local(tsum)
@@ -826,6 +469,9 @@ module EtOrbi
       @tz_winter_summer[tabbs]
     end
 
+    def custom_tzs; @custom_tzs ||= {}; end
+    def tz_all; @tz_all ||= ::TZInfo::Timezone.all; end
+
     #
     # system tz determination
 
@@ -863,19 +509,5 @@ module EtOrbi
       { :debian => debian_tz, :centos => centos_tz, :osx => osx_tz }
     end
   end
-
-  #def in_zone(&block)
-  #
-  #  current_timezone = ENV['TZ']
-  #  ENV['TZ'] = @zone
-  #
-  #  block.call
-  #
-  #ensure
-  #
-  #  ENV['TZ'] = current_timezone
-  #end
-    #
-    # kept around as a (thread-unsafe) relic
 end
 

data/lib/et-orbi/eo_time.rb

@@ -0,0 +1,409 @@
+
+module EtOrbi
+
+  # Our EoTime class (which quacks like a ::Time).
+  #
+  # An EoTime instance should respond to most of the methods ::Time instances
+  # respond to. If a method is missing, feel free to open an issue to
+  # ask (politely) for it. If it makes sense, it'll get added, else
+  # a workaround will get suggested.
+  # The immediate workaround is to call #to_t on the EoTime instance to get
+  # equivalent ::Time instance in the local, current, timezone.
+  #
+  class EoTime
+
+    #
+    # class methods
+
+    class << self
+
+      def now(zone=nil)
+
+        EtOrbi.now(zone)
+      end
+
+      def parse(str, opts={})
+
+        EtOrbi.parse(str, opts)
+      end
+
+      def get_tzone(o)
+
+        EtOrbi.get_tzone(o)
+      end
+
+      def local_tzone
+
+        EtOrbi.determine_local_tzone
+      end
+
+      def platform_info
+
+        EtOrbi.platform_info
+      end
+
+      def make(o)
+
+        EtOrbi.make_time(o)
+      end
+
+      def utc(*a)
+
+        EtOrbi.make_from_array(a, EtOrbi.get_tzone('UTC'))
+      end
+
+      def local(*a)
+
+        EtOrbi.make_from_array(a, local_tzone)
+      end
+    end
+
+    #
+    # instance methods
+
+    attr_reader :seconds
+    attr_reader :zone
+
+    def initialize(s, zone)
+
+      z = zone
+      z = nil if zone.is_a?(String) && zone.strip == ''
+        #
+        # happens with JRuby (and offset tzones like +04:00)
+        #
+        # $ jruby -r time -e "p Time.parse('2012-1-1 12:00 +04:00').zone"
+        # # => ""
+        # ruby -r time -e "p Time.parse('2012-1-1 12:00 +04:00').zone"
+        # # => nil
+
+      @seconds = s.to_f
+      @zone = self.class.get_tzone(z || :local)
+
+      fail ArgumentError.new(
+        "Cannot determine timezone from #{zone.inspect}" +
+        "\n#{EtOrbi.render_nozone_time(@seconds)}" +
+        "\n#{EtOrbi.platform_info.sub(',debian:', ",\ndebian:")}" +
+        "\nTry setting `ENV['TZ'] = 'Continent/City'` in your script " +
+        "(see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)" +
+        (defined?(TZInfo::Data) ? '' : "\nand adding gem 'tzinfo-data'")
+      ) unless @zone
+
+      @time = nil
+        # cache for #to_time result
+    end
+
+    def seconds=(f)
+
+      @time = nil
+      @seconds = f
+    end
+
+    def zone=(z)
+
+      @time = nil
+      @zone = self.class.get_tzone(zone || :current)
+    end
+
+    # Returns true if this EoTime instance corresponds to 2 different UTC
+    # times.
+    # It happens when transitioning from DST to winter time.
+    #
+    # https://www.timeanddate.com/time/change/usa/new-york?year=2018
+    #
+    def ambiguous?
+
+      @zone.local_to_utc(@zone.utc_to_local(utc))
+
+      false
+
+    rescue TZInfo::AmbiguousTime
+
+      true
+    end
+
+    # Returns this ::EtOrbi::EoTime as a ::Time instance
+    # in the current UTC timezone.
+    #
+    def utc
+
+      Time.utc(1970) + @seconds
+    end
+
+    # Returns true if this ::EtOrbi::EoTime instance timezone is UTC.
+    # Returns false else.
+    #
+    def utc?
+
+      %w[ gmt utc zulu etc/gmt etc/utc ].include?(
+        @zone.canonical_identifier.downcase)
+    end
+
+    alias getutc utc
+    alias getgm utc
+    alias to_utc_time utc
+
+    def to_f
+
+      @seconds
+    end
+
+    def to_i
+
+      @seconds.to_i
+    end
+
+    def strftime(format)
+
+      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
+
+      to_time.strftime(format)
+    end
+
+    # Returns this ::EtOrbi::EoTime as a ::Time instance
+    # in the current timezone.
+    #
+    # Has a #to_t alias.
+    #
+    def to_local_time
+
+      Time.at(@seconds)
+    end
+
+    alias to_t to_local_time
+
+    def is_dst?
+
+      @zone.period_for_utc(utc).std_offset != 0
+    end
+    alias isdst is_dst?
+
+    def to_debug_s
+
+      uo = self.utc_offset
+      uos = uo < 0 ? '-' : '+'
+      uo = uo.abs
+      uoh, uom = [ uo / 3600, uo % 3600 ]
+
+      [
+        'ot',
+        self.strftime('%Y-%m-%d %H:%M:%S'),
+        "%s%02d:%02d" % [ uos, uoh, uom ],
+        "dst:#{self.isdst}"
+      ].join(' ')
+    end
+
+    def utc_offset
+
+      @zone.period_for_utc(utc).utc_total_offset
+    end
+
+    %w[
+      year month day wday hour min sec usec asctime
+    ].each do |m|
+      define_method(m) { to_time.send(m) }
+    end
+
+    def ==(o)
+
+      o.is_a?(EoTime) &&
+      o.seconds == @seconds &&
+      (o.zone == @zone || o.zone.current_period == @zone.current_period)
+    end
+    #alias eql? == # FIXME see Object#== (ri)
+
+    def >(o); @seconds > _to_f(o); end
+    def >=(o); @seconds >= _to_f(o); end
+    def <(o); @seconds < _to_f(o); end
+    def <=(o); @seconds <= _to_f(o); end
+    def <=>(o); @seconds <=> _to_f(o); end
+
+    def add(t); @time = nil; @seconds += t.to_f; self; end
+    def subtract(t); @time = nil; @seconds -= t.to_f; self; end
+
+    def +(t); inc(t, 1); end
+    def -(t); inc(t, -1); end
+
+    WEEK_S = 7 * 24 * 3600
+
+    def monthdays
+
+      date = to_time
+
+      pos = 1
+      d = self.dup
+
+      loop do
+        d.add(-WEEK_S)
+        break if d.month != date.month
+        pos = pos + 1
+      end
+
+      neg = -1
+      d = self.dup
+
+      loop do
+        d.add(WEEK_S)
+        break if d.month != date.month
+        neg = neg - 1
+      end
+
+      [ "#{date.wday}##{pos}", "#{date.wday}##{neg}" ]
+    end
+
+    def to_s
+
+      strftime('%Y-%m-%d %H:%M:%S %z')
+    end
+
+    def to_zs
+
+      strftime('%Y-%m-%d %H:%M:%S %/Z')
+    end
+
+    def iso8601(fraction_digits=0)
+
+      s = (fraction_digits || 0) > 0 ? ".%#{fraction_digits}N" : ''
+      strftime("%Y-%m-%dT%H:%M:%S#{s}%:z")
+    end
+
+    # Debug current time by showing local time / delta / utc time
+    # for example: "0120-7(0820)"
+    #
+    def to_utc_comparison_s
+
+      per = @zone.period_for_utc(utc)
+      off = per.utc_total_offset
+
+      off = off / 3600
+      off = off >= 0 ? "+#{off}" : off.to_s
+
+      strftime('%H%M') + off + utc.strftime('(%H%M)')
+    end
+
+    def to_time_s
+
+      strftime("%H:%M:%S.#{'%06d' % usec}")
+    end
+
+    def inc(t, dir=1)
+
+      case t
+      when Numeric
+        nt = self.dup
+        nt.seconds += dir * t.to_f
+        nt
+      when ::Time, ::EtOrbi::EoTime
+        fail ArgumentError.new(
+          "Cannot add #{t.class} to EoTime") if dir > 0
+        @seconds + dir * t.to_f
+      else
+        fail ArgumentError.new(
+          "Cannot call add or subtract #{t.class} to EoTime instance")
+      end
+    end
+
+    def localtime(zone=nil)
+
+      EoTime.new(self.to_f, zone)
+    end
+
+    alias translate localtime
+
+    def wday_in_month
+
+      [ count_weeks(-1), - count_weeks(1) ]
+    end
+
+    def reach(points)
+
+      t = EoTime.new(self.to_f, @zone)
+      step = 1
+
+      s = points[:second] || points[:sec] || points[:s]
+      m = points[:minute] || points[:min] || points[:m]
+      h = points[:hour] || points[:hou] || points[:h]
+
+      fail ArgumentError.new("missing :second, :minute, and :hour") \
+        unless s || m || h
+
+      if !s && !m
+        step = 60 * 60
+        t -= t.sec
+        t -= t.min * 60
+      elsif !s
+        step = 60
+        t -= t.sec
+      end
+
+      loop do
+        t += step
+        next if s && t.sec != s
+        next if m && t.min != m
+        next if h && t.hour != h
+        break
+      end
+
+      t
+    end
+
+    protected
+
+    # Returns a Ruby Time instance.
+    #
+    # Warning: the timezone of that Time instance will be UTC when used with
+    # TZInfo < 2.0.0.
+    #
+    def to_time
+
+      @time ||= @zone.utc_to_local(utc)
+    end
+
+    def count_weeks(dir)
+
+      c = 0
+      t = self
+      until t.month != self.month
+        c += 1
+        t += dir * (7 * 24 * 3600)
+      end
+
+      c
+    end
+
+    def strfz(code)
+
+      return @zone.name if code == '%/Z'
+
+      per = @zone.period_for_utc(utc)
+
+      return per.abbreviation.to_s if code == '%Z'
+
+      off = per.utc_total_offset
+        #
+      sn = off < 0 ? '-' : '+'; off = off.abs
+      hr = off / 3600
+      mn = (off % 3600) / 60
+      sc = 0
+
+      if @zone.name == 'UTC'
+        'Z' # align on Ruby ::Time#iso8601
+      elsif code == '%z'
+        '%s%02d%02d' % [ sn, hr, mn ]
+      elsif code == '%:z'
+        '%s%02d:%02d' % [ sn, hr, mn ]
+      else
+        '%s%02d:%02d:%02d' % [ sn, hr, mn, sc ]
+      end
+    end
+
+    def _to_f(o)
+
+      fail ArgumentError(
+        "Comparison of EoTime with #{o.inspect} failed"
+      ) unless o.is_a?(EoTime) || o.is_a?(Time)
+
+      o.to_f
+    end
+  end
+end
+

data/lib/et-orbi/zone_aliases.rb

@@ -37,6 +37,10 @@ module EtOrbi
     nil
   end
 
+  # https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/default-time-zones
+  # https://support.microsoft.com/en-ca/help/973627/microsoft-time-zone-index-values
+  # https://ss64.com/nt/timezones.html
+
   ZONE_ALIASES = {
     'Coordinated Universal Time' => 'UTC',
     'Afghanistan Standard Time' => 'Asia/Kabul',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: et-orbi
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.7
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-04 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 description: Time zones for fugit and rufus-scheduler. Urbi et Orbi.
 email:
 - jmettraux+flor@gmail.com
@@ -52,6 +66,7 @@ files:
 - README.md
 - et-orbi.gemspec
 - lib/et-orbi.rb
+- lib/et-orbi/eo_time.rb
 - lib/et-orbi/zone_aliases.rb
 - lib/et_orbi.rb
 - lib/etorbi.rb