rufus-scheduler 3.2.2 → 3.3.0

data/lib/rufus/scheduler/jobs.rb

@@ -86,7 +86,7 @@ module Rufus
             nil
           end
 
-        @scheduled_at = Time.now
+        @scheduled_at = Rufus::Scheduler::ZoTime.now
         @unscheduled_at = nil
         @last_time = nil
 
@@ -124,27 +124,22 @@ module Rufus
         @previous_time = @next_time
         set_next_time(time)
 
-        return if (
-          opts[:overlap] == false &&
-          running?
-        )
-        return if (
-          callback(:confirm_lock, time) &&
-          callback(:on_pre_trigger, time)
-        ) == false
+        do_trigger(time)
+      end
 
-        @count += 1
+      # Trigger the job right now, off of its schedule.
+      #
+      # Done in collaboration with Piavka in
+      # https://github.com/jmettraux/rufus-scheduler/issues/214
+      #
+      def trigger_off_schedule(time=Rufus::Scheduler::ZoTime.now)
 
-        if opts[:blocking]
-          do_trigger(time)
-        else
-          do_trigger_in_thread(time)
-        end
+        do_trigger(time)
       end
 
       def unschedule
 
-        @unscheduled_at = Time.now
+        @unscheduled_at = Rufus::Scheduler::ZoTime.now
       end
 
       def threads
@@ -204,7 +199,7 @@ module Rufus
       #
       def call(do_rescue=false)
 
-        do_call(Time.now, do_rescue)
+        do_call(Rufus::Scheduler::ZoTime.now, do_rescue)
       end
 
       protected
@@ -251,7 +246,27 @@ module Rufus
 
       def do_trigger(time)
 
-        t = Time.now
+        return if (
+          opts[:overlap] == false &&
+          running?
+        )
+        return if (
+          callback(:confirm_lock, time) &&
+          callback(:on_pre_trigger, time)
+        ) == false
+
+        @count += 1
+
+        if opts[:blocking]
+          trigger_now(time)
+        else
+          trigger_queue(time)
+        end
+      end
+
+      def trigger_now(time)
+
+        t = Rufus::Scheduler::ZoTime.now
           # if there are mutexes, t might be really bigger than time
 
         Thread.current[:rufus_scheduler_job] = self
@@ -265,7 +280,7 @@ module Rufus
       ensure
 
         @last_work_time =
-          Time.now - Thread.current[:rufus_scheduler_time]
+          Rufus::Scheduler::ZoTime.now - Thread.current[:rufus_scheduler_time]
         @mean_work_time =
           ((@count - 1) * @mean_work_time + @last_work_time) / @count
 
@@ -302,7 +317,7 @@ module Rufus
               begin
 
                 (job.opts[:mutex] || []).reduce(
-                  lambda { job.do_trigger(time) }
+                  lambda { job.trigger_now(time) }
                 ) do |b, m|
                   lambda { mutex(m).synchronize { b.call } }
                 end.call
@@ -321,9 +336,11 @@ module Rufus
           # but since it has to be done as quickly as possible.
           # So, whoever is running first (scheduler thread vs job thread)
           # sets this information
+
+        thread
       end
 
-      def do_trigger_in_thread(time)
+      def trigger_queue(time)
 
         threads = @scheduler.work_threads
 
@@ -423,12 +440,12 @@ module Rufus
 
         return (@first_at = nil) if first == nil
 
-        n0 = Time.now
+        n0 = Rufus::Scheduler::ZoTime.now
         n1 = n0 + 0.003
 
         first = n0 if first == :now || first == :immediately || first == 0
 
-        @first_at = Rufus::Scheduler.parse_to_time(first)
+        @first_at = ZoTime.make(first)
         @first_at = n1 if @first_at >= n0 && @first_at < n1
 
         fail ArgumentError.new(
@@ -441,12 +458,13 @@ module Rufus
 
       def last_at=(last)
 
-        @last_at = last ? Rufus::Scheduler.parse_to_time(last) : nil
+        #@last_at = last ? Rufus::Scheduler.parse_to_time(last) : nil
+        @last_at = last ? ZoTime.make(last) : nil
 
         fail ArgumentError.new(
           "cannot set last[_at|_in] in the past: " +
           "#{last.inspect} -> #{@last_at.inspect}"
-        ) if last && @last_at < Time.now
+        ) if last && @last_at < Rufus::Scheduler::ZoTime.now
 
         @last_at
       end
@@ -458,7 +476,7 @@ module Rufus
         return (@next_time = nil) if @times && @times < 1
         return (@next_time = nil) if @last_at && time >= @last_at
           #
-          # TODO: rework that, jobs are thus kept 1 step too much in @jobs
+          # It keeps jobs one step too much in @jobs, but it's OK
 
         super
 
@@ -467,7 +485,7 @@ module Rufus
 
       def pause
 
-        @paused_at = Time.now
+        @paused_at = Rufus::Scheduler::ZoTime.now
       end
 
       def resume
@@ -518,9 +536,7 @@ module Rufus
 
       def first_at=(first)
 
-        super
-
-        @next_time = @first_at
+        @next_time = super
       end
     end
 
@@ -548,10 +564,10 @@ module Rufus
 
         return if is_post
 
-        n = Time.now
+        n = Rufus::Scheduler::ZoTime.now
 
         @next_time =
-          if @first_at == nil || @first_at < n
+          if @first_at == nil || @first_at < (n - @scheduler.frequency)
             nt = (@next_time || trigger_time || n) + @frequency
             nt > n ? nt : (trigger_time || n) + @frequency
           else
@@ -589,10 +605,10 @@ module Rufus
 
         @next_time =
           if is_post
-            Time.now + @interval
+            Rufus::Scheduler::ZoTime.now + @interval
           elsif trigger_time.nil?
             if @first_at == nil || @first_at < Time.now
-              Time.now + @interval
+              Rufus::Scheduler::ZoTime.now + @interval
             else
               @first_at
             end

data/lib/rufus/scheduler/util.rb

@@ -38,27 +38,27 @@ module Rufus
       parse_cron(o, opts) ||
       parse_in(o, opts) || # covers 'every' schedule strings
       parse_at(o, opts) ||
-      fail(ArgumentError.new("couldn't parse \"#{o}\""))
+      fail(ArgumentError.new("couldn't parse #{o.inspect} (#{o.class})"))
     end
 
-    def self.parse_in(o, opts={})
-
-      o.is_a?(String) ? parse_duration(o, opts) : o
-    end
-
-    def self.parse_at(o, opts={})
+    def self.parse_cron(o, opts)
 
-      Rufus::Scheduler::ZoTime.parse(o, opts).time
+      CronLine.new(o)
 
-    rescue StandardError => se
+    rescue ArgumentError => ae
 
       return nil if opts[:no_error]
-      fail se
+      fail ae
     end
 
-    def self.parse_cron(o, opts)
+    def self.parse_in(o, opts={})
 
-      CronLine.new(o)
+      #o.is_a?(String) ? parse_duration(o, opts) : o
+
+      return parse_duration(o, opts) if o.is_a?(String)
+      return o if o.is_a?(Numeric)
+
+      fail ArgumentError.new("couldn't parse time point in #{o.inspect}")
 
     rescue ArgumentError => ae
 
@@ -66,17 +66,16 @@ module Rufus
       fail ae
     end
 
-    def self.parse_to_time(o)
+    def self.parse_at(o, opts={})
 
-      t = o
-      t = parse(t) if t.is_a?(String)
-      t = Time.now + t if t.is_a?(Numeric)
+      return o if o.is_a?(Rufus::Scheduler::ZoTime)
+      return Rufus::Scheduler::ZoTime.make(o) if o.is_a?(Time)
+      Rufus::Scheduler::ZoTime.parse(o, opts)
 
-      fail ArgumentError.new(
-        "cannot turn #{o.inspect} to a point in time, doesn't make sense"
-      ) unless t.is_a?(Time)
+    rescue StandardError => se
 
-      t
+      return nil if opts[:no_error]
+      fail se
     end
 
     DURATIONS2M = [

data/lib/rufus/scheduler/zotime.rb

@@ -22,8 +22,6 @@
 # Made in Japan.
 #++
 
-require 'rufus/scheduler/zones'
-
 
 class Rufus::Scheduler
 
@@ -32,52 +30,72 @@ class Rufus::Scheduler
   #
   class ZoTime
 
-    attr_accessor :seconds
-    attr_accessor :zone
+    attr_reader :seconds
+    attr_reader :zone
 
     def initialize(s, zone)
 
       @seconds = s.to_f
-      @zone = zone
-    end
+      @zone = self.class.get_tzone(zone || :current)
 
-    def time
+      fail ArgumentError.new(
+        "cannot determine timezone from #{zone.inspect}"
+      ) unless @zone
 
-      in_zone do
+      @time = nil # cache for #to_time result
+    end
 
-        t = Time.at(@seconds)
+    def seconds=(f)
 
-        #if t.isdst
-        #  t1 = Time.at(@seconds + 3600)
-        #  t = t1 if t.zone != t1.zone && t.hour == t1.hour && t.min == t1.min
-        #    # ambiguous TZ (getting out of DST)
-        #else
-        #  t.hour # force t to compute itself
-        #end
-          #
-          # jump out of DST as soon as possible, jumps 1h as seen from UTC
+      @time = nil
+      @seconds = f
+    end
 
-        t.hour # force t to compute itself
-          #
-          # stay in DST as long as possible, no jump seen from UTC
+    def zone=(z)
 
-        t
-      end
+      @time = nil
+      @zone = self.class.get_tzone(zone || :current)
     end
 
     def utc
 
-      time.utc
+      Time.utc(1970, 1, 1) + @seconds
+    end
+
+    # Returns a Ruby Time instance.
+    #
+    # Warning: the timezone of that Time instance will be UTC.
+    #
+    def to_time
+
+      @time ||= begin; u = utc; @zone.period_for_utc(u).to_local(u); end
+    end
+
+    %w[
+      year month day wday hour min sec usec asctime
+    ].each do |m|
+      define_method(m) { to_time.send(m) }
     end
+    def iso8601(fraction_digits=0); to_time.iso8601(fraction_digits); end
 
-    def add(s)
+    def ==(o)
 
-      @seconds += s.to_f
+      o.is_a?(ZoTime) && o.seconds == @seconds && o.zone == @zone
     end
+    #alias eq? == # 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
+
+    alias getutc utc
+    alias getgm utc
 
-    def substract(s)
+    def to_i
 
-      @seconds -= s.to_f
+      @seconds.to_i
     end
 
     def to_f
@@ -85,82 +103,346 @@ class Rufus::Scheduler
       @seconds
     end
 
-    #DELTA_TZ_REX = /\A[+-][0-1][0-9]:?[0-5][0-9]\z/
+    def is_dst?
+
+      @zone.period_for_utc(utc).std_offset != 0
+    end
+    alias isdst is_dst?
+
+    def utc_offset
+
+      #@zone.period_for_utc(utc).utc_offset
+      #@zone.period_for_utc(utc).utc_total_offset
+      #@zone.period_for_utc(utc).std_offset
+      @zone.period_for_utc(utc).utc_offset
+    end
+
+    def strftime(format)
+
+      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
+
+      to_time.strftime(format)
+    end
+
+    def add(t); @time = nil; @seconds += t.to_f; end
+    def substract(t); @time = nil; @seconds -= t.to_f; 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_debug_s
+
+      uo = self.utc_offset
+      uos = uo < 0 ? '-' : '+'
+      uo = uo.abs
+      uoh, uom = [ uo / 3600, uo % 3600 ]
+
+      [
+        'zt',
+        self.strftime('%Y-%m-%d %H:%M:%S'),
+        "%s%02d:%02d" % [ uos, uoh, uom ],
+        "dst:#{self.isdst}"
+      ].join(' ')
+    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 self.now(zone=nil)
+
+      ZoTime.new(Time.now.to_f, zone)
+    end
+
+    # https://en.wikipedia.org/wiki/ISO_8601
+    # Postel's law applies
+    #
+    def self.extract_iso8601_zone(s)
+
+      m = s.match(
+        /[0-2]\d(?::?[0-6]\d(?::?[0-6]\d))?\s*([+-]\d\d(?::?\d\d)?)\s*\z/)
+      return nil unless m
+
+      zs = m[1].split(':')
+      zs << '00' if zs.length < 2
 
-    def self.envtzable?(s)
+      zh = zs[0].to_i.abs
 
-      TIMEZONES.include?(s)
+      return nil if zh > 24
+      return nil if zh == 24 && zs[1].to_i != 0
+
+      zs.join(':')
     end
 
     def self.parse(str, opts={})
 
       if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-        return ZoTime.new(t, ENV['TZ'])
+        return ZoTime.new(t, nil)
       end
 
+      #rold = RUBY_VERSION < '1.9.0'
+      #rold = RUBY_VERSION < '2.0.0'
+
       begin
         DateTime.parse(str)
       rescue
-        fail ArgumentError, "no time information in #{o.inspect}"
-      end if RUBY_VERSION < '1.9.0'
+        fail ArgumentError, "no time information in #{str.inspect}"
+      end #if rold
+        #
+        # is necessary since Time.parse('xxx') in Ruby < 1.9 yields `now`
 
       zone = nil
 
       s =
-        str.gsub(/\S+/) { |m|
-          if envtzable?(m)
-            zone ||= m
+        str.gsub(/\S+/) do |w|
+          if z = get_tzone(w)
+            zone ||= z
             ''
           else
-            m
+            w
+          end
+        end
+
+      local = Time.parse(s)
+      izone = extract_iso8601_zone(s)
+
+      zone ||=
+        if s.match(/\dZ\b/)
+          get_tzone('Zulu')
+        #elsif rold && izone
+        elsif izone
+          get_tzone(izone)
+        elsif local.zone.nil? && izone
+          get_tzone(local.strftime('%:z'))
+        else
+          get_tzone(:local)
+        end
+
+      secs =
+        #if rold && izone
+        if izone
+          local.to_f
+        else
+          zone.period_for_local(local).to_utc(local).to_f
+        end
+
+      ZoTime.new(secs, zone)
+    end
+
+    def self.get_tzone(str)
+
+      return str if str.is_a?(::TZInfo::Timezone)
+
+      # discard quickly when it's certainly not a timezone
+
+      return nil if str == nil
+      return nil if str == '*'
+
+      # ok, it's a timezone then
+
+      str = Time.now.zone if str == :current || str == :local
+
+      # utc_offset
+
+      if str.is_a?(Numeric)
+        i = str.to_i
+        sn = i < 0 ? '-' : '+'; i = i.abs
+        hr = i / 3600; mn = i % 3600; sc = i % 60
+        str = (sc > 0 ? "%s%02d:%02d:%02d" : "%s%02d:%02d") % [ sn, hr, mn, sc ]
+      end
+
+      return nil if str.index('#')
+        # counters "sun#2", etc... On OSX would go all the way to true
+
+      # vanilla time zones
+
+      z = (::TZInfo::Timezone.get(str) rescue nil)
+      return z if z
+
+      # time zone abbreviations
+
+      if str.match(/\A[A-Z0-9-]{3,6}\z/)
+
+        twin = Time.utc(Time.now.year, 1, 1)
+        tsum = Time.utc(Time.now.year, 7, 1)
+
+        z =
+          ::TZInfo::Timezone.all.find do |tz|
+            tz.period_for_utc(twin).abbreviation.to_s == str ||
+            tz.period_for_utc(tsum).abbreviation.to_s == str
           end
-        }
+        return z if z
+      end
+
+      # some time zone aliases
+
+      return ::TZInfo::Timezone.get('Zulu') if %w[ Z ].include?(str)
 
-      return nil unless zone.nil? || is_timezone?(zone)
+      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
+
+      tz = (@custom_tz_cache ||= {})[str]
+      return tz if tz
+
+      if m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])\z/)
+
+        hr = m[1].to_i
+        mn = m[2].to_i
+
+        hr = nil if hr.abs > 11
+        hr = nil if mn > 59
+        mn = -mn if hr && hr < 0
+
+        return (
+          @custom_tz_cache[str] =
+            begin
+              tzi = TZInfo::TransitionDataTimezoneInfo.new(str)
+              tzi.offset(str, hr * 3600 + mn * 60, 0, str)
+              tzi.create_timezone
+            end
+        ) if hr
+      end
 
-      zt = ZoTime.new(0, zone || ENV['TZ'])
-      zt.in_zone { zt.seconds = Time.parse(s).to_f }
+      # so it's not a timezone.
 
-      zt.seconds == nil ? nil : zt
+      nil
     end
 
-    def self.is_timezone?(str)
+    def self.local_tzone
 
-      return false if str == nil
-      return false if str == '*'
+      get_tzone(:local)
+    end
 
-      return false if str.index('#')
-        # "sun#2", etc... On OSX would go all the way to true
+    def self.make(o)
+
+      zt =
+        case o
+          when Time
+            ZoTime.new(o.to_f, o.zone)
+          when Date
+            t =
+              o.respond_to?(:to_time) ?
+              o.to_time :
+              Time.parse(o.strftime('%Y-%m-%d %H:%M:%S'))
+            ZoTime.new(t.to_f, t.zone)
+          when String
+            Rufus::Scheduler.parse_in(o, :no_error => true) || self.parse(o)
+          else
+            o
+        end
 
-      return true if Time.zone_offset(str)
+      zt = ZoTime.new(Time.now.to_f + zt, nil) if zt.is_a?(Numeric)
 
-      return !! (::TZInfo::Timezone.get(str) rescue nil) if defined?(::TZInfo)
+      fail ArgumentError.new(
+        "cannot turn #{o.inspect} to a ZoTime instance"
+      ) unless zt.is_a?(ZoTime)
 
-      return true if TIMEZONES.include?(str)
-      return true if TIMEZONEs.include?(str)
+      zt
+    end
 
-      t = ZoTime.new(0, str).time
+#    def in_zone(&block)
+#
+#      current_timezone = ENV['TZ']
+#      ENV['TZ'] = @zone
+#
+#      block.call
+#
+#    ensure
+#
+#      ENV['TZ'] = current_timezone
+#    end
+
+    protected
+
+    def inc(t, dir)
+
+      if t.is_a?(Numeric)
+        nt = self.dup
+        nt.seconds += dir * t.to_f
+        nt
+      elsif t.respond_to?(:to_f)
+        @seconds + dir * t.to_f
+      else
+        fail ArgumentError.new(
+          "cannot call ZoTime #- or #+ with arg of class #{t.class}")
+      end
+    end
 
-      return false if t.zone == ''
-      return false if t.zone == 'UTC'
-      return false if t.utc_offset == 0 && str.start_with?(t.zone)
-        # 3 common fallbacks...
+    def _to_f(o)
 
-      return false if RUBY_PLATFORM.include?('java') && ! envtzable?(str)
+      fail ArgumentError(
+        "comparison of ZoTime with #{o.inspect} failed"
+      ) unless o.is_a?(ZoTime) || o.is_a?(Time)
 
-      true
+      o.to_f
     end
 
-    def in_zone(&block)
+    def strfz(code)
+
+      return @zone.name if code == '%/Z'
+
+      per = @zone.period_for_utc(utc)
 
-      current_timezone = ENV['TZ']
-      ENV['TZ'] = @zone
+      return per.abbreviation.to_s if code == '%Z'
 
-      block.call
+      off = per.utc_total_offset
+        #
+      sn = off < 0 ? '-' : '+'; off = off.abs
+      hr = off / 3600
+      mn = (off % 3600) / 60
+      sc = 0
 
-    ensure
+      fmt =
+        if code == '%z'
+          "%s%02d%02d"
+        elsif code == '%:z'
+          "%s%02d:%02d"
+        else
+          "%s%02d:%02d:%02d"
+        end
 
-      ENV['TZ'] = current_timezone
+      fmt % [ sn, hr, mn, sc ]
     end
   end
 end