rufus-scheduler 3.2.0 → 3.3.0

data/lib/rufus/scheduler/cronline.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2015, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2016, John Mettraux, jmettraux@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
@@ -36,6 +36,7 @@ class Rufus::Scheduler
     # The string used for creating this cronline instance.
     #
     attr_reader :original
+    attr_reader :original_timezone
 
     attr_reader :seconds
     attr_reader :minutes
@@ -53,10 +54,15 @@ class Rufus::Scheduler
       ) unless line.is_a?(String)
 
       @original = line
+      @original_timezone = nil
 
       items = line.split
 
-      @timezone = items.pop if ZoTime.is_timezone?(items.last)
+      if @timezone = ZoTime.get_tzone(items.last)
+        @original_timezone = items.pop
+      else
+        @timezone = ZoTime.get_tzone(:current)
+      end
 
       fail ArgumentError.new(
         "not a valid cronline : '#{line}'"
@@ -67,7 +73,7 @@ class Rufus::Scheduler
       @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
       @minutes = parse_item(items[0 + offset], 0, 59)
       @hours = parse_item(items[1 + offset], 0, 24)
-      @days = parse_item(items[2 + offset], 1, 31)
+      @days = parse_item(items[2 + offset], -30, 31)
       @months = parse_item(items[3 + offset], 1, 12)
       @weekdays, @monthdays = parse_weekdays(items[4 + offset])
 
@@ -77,18 +83,26 @@ class Rufus::Scheduler
           "invalid cronline: '#{line}'"
         ) if es && es.find { |e| ! e.is_a?(Fixnum) }
       end
+
+      if @days && @days.include?(0) # gh-221
+
+        fail ArgumentError.new('invalid day 0 in cronline')
+      end
     end
 
     # Returns true if the given time matches this cron line.
     #
     def matches?(time)
 
-      time = ZoTime.new(time.to_f, @timezone || ENV['TZ']).time
+        # FIXME Don't create a new ZoTime if time is already a ZoTime in same
+        #       zone ...
+        #       Wait, this seems only used in specs...
+      t = ZoTime.new(time.to_f, @timezone)
 
-      return false unless sub_match?(time, :sec, @seconds)
-      return false unless sub_match?(time, :min, @minutes)
-      return false unless sub_match?(time, :hour, @hours)
-      return false unless date_match?(time)
+      return false unless sub_match?(t, :sec, @seconds)
+      return false unless sub_match?(t, :min, @minutes)
+      return false unless sub_match?(t, :hour, @hours)
+      return false unless date_match?(t)
       true
     end
 
@@ -119,36 +133,36 @@ class Rufus::Scheduler
     #
     # (Thanks to K Liu for the note and the examples)
     #
-    def next_time(from=Time.now)
+    def next_time(from=ZoTime.now)
 
-      time = nil
-      zotime = ZoTime.new(from.to_i + 1, @timezone || ENV['TZ'])
+      nt = nil
+      zt = ZoTime.new(from.to_i + 1, @timezone)
 
       loop do
 
-        time = zotime.time
+        nt = zt.dup
 
-        unless date_match?(time)
-          zotime.add((24 - time.hour) * 3600 - time.min * 60 - time.sec)
+        unless date_match?(nt)
+          zt.add((24 - nt.hour) * 3600 - nt.min * 60 - nt.sec)
           next
         end
-        unless sub_match?(time, :hour, @hours)
-          zotime.add((60 - time.min) * 60 - time.sec)
+        unless sub_match?(nt, :hour, @hours)
+          zt.add((60 - nt.min) * 60 - nt.sec)
           next
         end
-        unless sub_match?(time, :min, @minutes)
-          zotime.add(60 - time.sec)
+        unless sub_match?(nt, :min, @minutes)
+          zt.add(60 - nt.sec)
           next
         end
-        unless sub_match?(time, :sec, @seconds)
-          zotime.add(next_second(time))
+        unless sub_match?(nt, :sec, @seconds)
+          zt.add(next_second(nt))
           next
         end
 
         break
       end
 
-      time
+      nt
     end
 
     # Returns the previous time the cronline matched. It's like next_time, but
@@ -156,41 +170,41 @@ class Rufus::Scheduler
     #
     def previous_time(from=Time.now)
 
-      time = nil
-      zotime = ZoTime.new(from.to_i - 1, @timezone || ENV['TZ'])
+      pt = nil
+      zt = ZoTime.new(from.to_i - 1, @timezone)
 
       loop do
 
-        time = zotime.time
+        pt = zt.dup
 
-        unless date_match?(time)
-          zotime.substract(time.hour * 3600 + time.min * 60 + time.sec + 1)
+        unless date_match?(pt)
+          zt.substract(pt.hour * 3600 + pt.min * 60 + pt.sec + 1)
           next
         end
-        unless sub_match?(time, :hour, @hours)
-          zotime.substract(time.min * 60 + time.sec + 1)
+        unless sub_match?(pt, :hour, @hours)
+          zt.substract(pt.min * 60 + pt.sec + 1)
           next
         end
-        unless sub_match?(time, :min, @minutes)
-          zotime.substract(time.sec + 1)
+        unless sub_match?(pt, :min, @minutes)
+          zt.substract(pt.sec + 1)
           next
         end
-        unless sub_match?(time, :sec, @seconds)
-          zotime.substract(prev_second(time))
+        unless sub_match?(pt, :sec, @seconds)
+          zt.substract(prev_second(pt))
           next
         end
 
         break
       end
 
-      time
+      pt
     end
 
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
     # months, weekdays).
-    # This method is used by the cronline unit tests.
+    # This method is mostly used by the cronline specs.
     #
-    def to_array
+    def to_a
 
       [
         toa(@seconds),
@@ -200,9 +214,10 @@ class Rufus::Scheduler
         toa(@months),
         toa(@weekdays),
         toa(@monthdays),
-        @timezone
+        @timezone.name
       ]
     end
+    alias to_array to_a
 
     # Returns a quickly computed approximation of the frequency for this
     # cron line.
@@ -259,7 +274,9 @@ class Rufus::Scheduler
         break if delta <= 1
         break if delta <= 60 && @seconds && @seconds.size == 1
 
+#st = Time.now
         t1 = next_time(t0)
+#p Time.now - st
         d = t1 - t0
         delta = d if d < delta
 
@@ -313,39 +330,38 @@ class Rufus::Scheduler
 
     WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
     DAY_S = 24 * 3600
-    WEEK_S = 7 * DAY_S
 
     def parse_weekdays(item)
 
       return nil if item == '*'
 
-      items = item.downcase.split(',')
-
       weekdays = nil
       monthdays = nil
 
-      items.each do |it|
+      item.downcase.split(',').each do |it|
 
-        if m = it.match(/^(.+)#(l|-?[12345])$/)
+        WEEKDAYS.each_with_index { |a, i| it.gsub!(/#{a}/, i.to_s) }
+
+        it = it.gsub(/([^#])l/, '\1#-1')
+          # "5L" == "5#-1" == the last Friday
+
+        if m = it.match(/\A(.+)#(l|-?[12345])\z/)
 
           fail ArgumentError.new(
             "ranges are not supported for monthdays (#{it})"
           ) if m[1].index('-')
 
-          expr = it.gsub(/#l/, '#-1')
+          it = it.gsub(/#l/, '#-1')
 
-          (monthdays ||= []) << expr
+          (monthdays ||= []) << it
 
         else
 
-          expr = it.dup
-          WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
-
           fail ArgumentError.new(
-            "invalid weekday expression (#{it})"
-          ) if expr !~ /^0*[0-7](-0*[0-7])?$/
+            "invalid weekday expression (#{item})"
+          ) if it !~ /\A0*[0-7](-0*[0-7])?\z/
 
-          its = expr.index('-') ? parse_range(expr, 0, 7) : [ Integer(expr) ]
+          its = it.index('-') ? parse_range(it, 0, 7) : [ Integer(it) ]
           its = its.collect { |i| i == 7 ? 0 : i }
 
           (weekdays ||= []).concat(its)
@@ -372,7 +388,7 @@ class Rufus::Scheduler
       Set.new(r)
     end
 
-    RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
+    RANGE_REGEX = /\A(\*|-?\d{1,2})(?:-(-?\d{1,2}))?(?:\/(\d{1,2}))?\z/
 
     def parse_range(item, min, max)
 
@@ -386,8 +402,10 @@ class Rufus::Scheduler
         "cannot parse #{item.inspect}"
       ) unless m
 
+      mmin = min == -30 ? 1 : min # days
+
       sta = m[1]
-      sta = sta == '*' ? min : sta.to_i
+      sta = sta == '*' ? mmin : sta.to_i
 
       edn = m[2]
       edn = edn ? edn.to_i : sta
@@ -396,16 +414,28 @@ class Rufus::Scheduler
       inc = m[3]
       inc = inc ? inc.to_i : 1
 
+      fail ArgumentError.new(
+        "#{item.inspect} positive/negative ranges not allowed"
+      ) if (sta < 0 && edn > 0) || (sta > 0 && edn < 0)
+
+      fail ArgumentError.new(
+        "#{item.inspect} descending day ranges not allowed"
+      ) if min == -30 && sta > edn
+
       fail ArgumentError.new(
         "#{item.inspect} is not in range #{min}..#{max}"
       ) if sta < min || edn > max
 
+      fail ArgumentError.new(
+        "#{item.inspect} increment must be greater than zero"
+      ) if inc == 0
+
       r = []
       val = sta
 
       loop do
         v = val
-        v = 0 if max == 24 && v == 24
+        v = 0 if max == 24 && v == 24 # hours
         r << v
         break if inc == 1 && val == edn
         val += inc
@@ -416,57 +446,52 @@ class Rufus::Scheduler
       r.uniq
     end
 
+    # FIXME: Eventually split into day_match?, hour_match? and monthdays_match?o
+    #
     def sub_match?(time, accessor, values)
 
-      value = time.send(accessor)
-
       return true if values.nil?
-      return true if values.include?('L') && (time + DAY_S).day == 1
 
-      return true if value == 0 && accessor == :hour && values.include?(24)
+      value = time.send(accessor)
 
-      values.include?(value)
-    end
+      if accessor == :day
 
-    def monthday_match?(date, values)
+        values.each do |v|
+          return true if v == 'L' && (time + DAY_S).day == 1
+          return true if v.to_i < 0 && (time + (1 - v) * DAY_S).day == 1
+        end
+      end
 
-      return true if values.nil?
+      if accessor == :hour
 
-      today_values = monthdays(date)
+        return true if value == 0 && values.include?(24)
+      end
 
-      (today_values & values).any?
-    end
+      if accessor == :monthdays
 
-    def date_match?(date)
+        return true if (values & value).any?
+      end
 
-      return false unless sub_match?(date, :day, @days)
-      return false unless sub_match?(date, :month, @months)
-      return false unless sub_match?(date, :wday, @weekdays)
-      return false unless monthday_match?(date, @monthdays)
-      true
+      values.include?(value)
     end
 
-    def monthdays(date)
-
-      pos = 1
-      d = date.dup
-
-      loop do
-        d = d - WEEK_S
-        break if d.month != date.month
-        pos = pos + 1
-      end
-
-      neg = -1
-      d = date.dup
+#    def monthday_match?(zt, values)
+#
+#      return true if values.nil?
+#
+#      today_values = monthdays(zt)
+#
+#      (today_values & values).any?
+#    end
 
-      loop do
-        d = d + WEEK_S
-        break if d.month != date.month
-        neg = neg - 1
-      end
+    def date_match?(zt)
 
-      [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
+      return false unless sub_match?(zt, :day, @days)
+      return false unless sub_match?(zt, :month, @months)
+      return false unless sub_match?(zt, :wday, @weekdays)
+      #return false unless monthday_match?(zt, @monthdays)
+      return false unless sub_match?(zt, :monthdays, @monthdays)
+      true
     end
   end
 end

data/lib/rufus/scheduler/job_array.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2015, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2016, John Mettraux, jmettraux@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
@@ -53,10 +53,14 @@ module Rufus
 
       def each(now, &block)
 
-        to_a.sort_by { |j| j.next_time || (now + 1) }.each do |job|
+        to_a.sort_by do |job|
 
-          break unless job.next_time
-          break if job.next_time > now
+          job.next_time || (now + 1)
+
+        end.each do |job|
+
+          nt = job.next_time
+          break if ( ! nt) || (nt > now)
 
           block.call(job)
         end

data/lib/rufus/scheduler/jobs.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2015, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2016, John Mettraux, jmettraux@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
@@ -53,6 +53,10 @@ module Rufus
       #
       attr_accessor :next_time
 
+      # previous "next trigger time"
+      #
+      attr_accessor :previous_time
+
       # anything with a #call(job[, timet]) method,
       # what gets actually triggered
       #
@@ -82,7 +86,7 @@ module Rufus
             nil
           end
 
-        @scheduled_at = Time.now
+        @scheduled_at = Rufus::Scheduler::ZoTime.now
         @unscheduled_at = nil
         @last_time = nil
 
@@ -117,29 +121,25 @@ module Rufus
 
       def trigger(time)
 
+        @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
@@ -199,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
@@ -246,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
@@ -260,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
 
@@ -297,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
@@ -316,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
 
@@ -418,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(
@@ -436,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
@@ -453,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
 
@@ -462,7 +485,7 @@ module Rufus
 
       def pause
 
-        @paused_at = Time.now
+        @paused_at = Rufus::Scheduler::ZoTime.now
       end
 
       def resume
@@ -513,9 +536,7 @@ module Rufus
 
       def first_at=(first)
 
-        super
-
-        @next_time = @first_at
+        @next_time = super
       end
     end
 
@@ -543,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
@@ -584,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/locks.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2015, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2016, John Mettraux, jmettraux@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
@@ -41,7 +41,7 @@ class Rufus::Scheduler
   end
 
   #
-  # The standard flock mecha, with its own class thanks to @ecin
+  # The standard flock mechanism, with its own class thanks to @ecin
   #
   class FileLock