rufus-scheduler 3.0.8 → 3.2.0

data/lib/rufus/scheduler/cronline.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2015, 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
@@ -22,6 +22,8 @@
 # Made in Japan.
 #++
 
+require 'set'
+
 
 class Rufus::Scheduler
 
@@ -40,13 +42,13 @@ class Rufus::Scheduler
     attr_reader :hours
     attr_reader :days
     attr_reader :months
+    #attr_reader :monthdays # reader defined below
     attr_reader :weekdays
-    attr_reader :monthdays
     attr_reader :timezone
 
     def initialize(line)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "not a string: #{line.inspect}"
       ) unless line.is_a?(String)
 
@@ -54,10 +56,9 @@ class Rufus::Scheduler
 
       items = line.split
 
-      @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
-      items.pop if @timezone
+      @timezone = items.pop if ZoTime.is_timezone?(items.last)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "not a valid cronline : '#{line}'"
       ) unless items.length == 5 or items.length == 6
 
@@ -72,7 +73,7 @@ class Rufus::Scheduler
 
       [ @seconds, @minutes, @hours, @months ].each do |es|
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "invalid cronline: '#{line}'"
         ) if es && es.find { |e| ! e.is_a?(Fixnum) }
       end
@@ -82,9 +83,7 @@ class Rufus::Scheduler
     #
     def matches?(time)
 
-      time = Time.at(time) unless time.kind_of?(Time)
-
-      time = @timezone.utc_to_local(time.getutc) if @timezone
+      time = ZoTime.new(time.to_f, @timezone || ENV['TZ']).time
 
       return false unless sub_match?(time, :sec, @seconds)
       return false unless sub_match?(time, :min, @minutes)
@@ -122,37 +121,34 @@ class Rufus::Scheduler
     #
     def next_time(from=Time.now)
 
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the next second
-      time = time + 1
+      time = nil
+      zotime = ZoTime.new(from.to_i + 1, @timezone || ENV['TZ'])
 
       loop do
+
+        time = zotime.time
+
         unless date_match?(time)
-          dst = time.isdst
-          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
-          time -= 3600 if time.isdst != dst # not necessary for winter, but...
+          zotime.add((24 - time.hour) * 3600 - time.min * 60 - time.sec)
           next
         end
         unless sub_match?(time, :hour, @hours)
-          time += (60 - time.min) * 60 - time.sec; next
+          zotime.add((60 - time.min) * 60 - time.sec)
+          next
         end
         unless sub_match?(time, :min, @minutes)
-          time += 60 - time.sec; next
+          zotime.add(60 - time.sec)
+          next
         end
         unless sub_match?(time, :sec, @seconds)
-          time += 1; next
+          zotime.add(next_second(time))
+          next
         end
 
         break
       end
 
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
-
-      next_time(from + 3600)
+      time
     end
 
     # Returns the previous time the cronline matched. It's like next_time, but
@@ -160,34 +156,34 @@ class Rufus::Scheduler
     #
     def previous_time(from=Time.now)
 
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the previous second
-      time = time - 1
+      time = nil
+      zotime = ZoTime.new(from.to_i - 1, @timezone || ENV['TZ'])
 
       loop do
+
+        time = zotime.time
+
         unless date_match?(time)
-          time -= time.hour * 3600 + time.min * 60 + time.sec + 1; next
+          zotime.substract(time.hour * 3600 + time.min * 60 + time.sec + 1)
+          next
         end
         unless sub_match?(time, :hour, @hours)
-          time -= time.min * 60 + time.sec + 1; next
+          zotime.substract(time.min * 60 + time.sec + 1)
+          next
         end
         unless sub_match?(time, :min, @minutes)
-          time -= time.sec + 1; next
+          zotime.substract(time.sec + 1)
+          next
         end
         unless sub_match?(time, :sec, @seconds)
-          time -= 1; next
+          zotime.substract(prev_second(time))
+          next
         end
 
         break
       end
 
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
-
-      previous_time(time)
+      time
     end
 
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
@@ -197,14 +193,14 @@ class Rufus::Scheduler
     def to_array
 
       [
-        @seconds,
-        @minutes,
-        @hours,
-        @days,
-        @months,
-        @weekdays,
-        @monthdays,
-        @timezone ? @timezone.name : nil
+        toa(@seconds),
+        toa(@minutes),
+        toa(@hours),
+        toa(@days),
+        toa(@months),
+        toa(@weekdays),
+        toa(@monthdays),
+        @timezone
       ]
     end
 
@@ -212,24 +208,25 @@ class Rufus::Scheduler
     # cron line.
     #
     # #brute_frequency, on the other hand, will compute the frequency by
-    # examining a whole, that can take more than seconds for a seconds
+    # examining a whole year, that can take more than seconds for a seconds
     # level cron...
     #
     def frequency
 
       return brute_frequency unless @seconds && @seconds.length > 1
 
-      delta = 60
-      prev = @seconds[0]
+      secs = toa(@seconds)
 
-      @seconds[1..-1].each do |sec|
+      secs[1..-1].inject([ secs[0], 60 ]) { |(prev, delta), sec|
         d = sec - prev
-        delta = d if d < delta
-      end
-
-      delta
+        [ sec, d < delta ? d : delta ]
+      }[1]
     end
 
+    # Caching facility. Currently only used for brute frequencies.
+    #
+    @cache = {}; class << self; attr_reader :cache; end
+
     # Returns the shortest delta between two potential occurences of the
     # schedule described by this cronline.
     #
@@ -246,16 +243,13 @@ class Rufus::Scheduler
     # Of course, this method can get VERY slow if you call on it a second-
     # based cronline...
     #
-    # Since it's a rarely used method, I haven't taken the time to make it
-    # smarter/faster.
-    #
-    # One obvious improvement would be to cache the result once computed...
-    #
-    # See https://github.com/jmettraux/rufus-scheduler/issues/89
-    # for a discussion about this method.
-    #
     def brute_frequency
 
+      key = "brute_frequency:#{@original}"
+
+      delta = self.class.cache[key]
+      return delta if delta
+
       delta = 366 * DAY_S
 
       t0 = previous_time(Time.local(2000, 1, 1))
@@ -270,16 +264,53 @@ class Rufus::Scheduler
         delta = d if d < delta
 
         break if @months == nil && t1.month == 2
-        break if t1.year == 2001
+        break if t1.year >= 2001
 
         t0 = t1
       end
 
-      delta
+      self.class.cache[key] = delta
+    end
+
+    def next_second(time)
+
+      secs = toa(@seconds)
+
+      return secs.first + 60 - time.sec if time.sec > secs.last
+
+      secs.shift while secs.first < time.sec
+
+      secs.first - time.sec
+    end
+
+    def prev_second(time)
+
+      secs = toa(@seconds)
+
+      return time.sec + 60 - secs.last if time.sec < secs.first
+
+      secs.pop while time.sec < secs.last
+
+      time.sec - secs.last
     end
 
     protected
 
+    def sc_sort(a)
+
+      a.sort_by { |e| e.is_a?(String) ? 61 : e.to_i }
+    end
+
+    if RUBY_VERSION >= '1.9'
+      def toa(item)
+        item == nil ? nil : item.to_a
+      end
+    else
+      def toa(item)
+        item.is_a?(Set) ? sc_sort(item.to_a) : item
+      end
+    end
+
     WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
     DAY_S = 24 * 3600
     WEEK_S = 7 * DAY_S
@@ -297,7 +328,7 @@ class Rufus::Scheduler
 
         if m = it.match(/^(.+)#(l|-?[12345])$/)
 
-          raise ArgumentError.new(
+          fail ArgumentError.new(
             "ranges are not supported for monthdays (#{it})"
           ) if m[1].index('-')
 
@@ -310,7 +341,7 @@ class Rufus::Scheduler
           expr = it.dup
           WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
 
-          raise ArgumentError.new(
+          fail ArgumentError.new(
             "invalid weekday expression (#{it})"
           ) if expr !~ /^0*[0-7](-0*[0-7])?$/
 
@@ -321,7 +352,7 @@ class Rufus::Scheduler
         end
       end
 
-      weekdays = weekdays.uniq if weekdays
+      weekdays = weekdays.uniq.sort if weekdays
 
       [ weekdays, monthdays ]
     end
@@ -332,11 +363,13 @@ class Rufus::Scheduler
 
       r = item.split(',').map { |i| parse_range(i.strip, min, max) }.flatten
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "found duplicates in #{item.inspect}"
       ) if r.uniq.size < r.size
 
-      r
+      r = sc_sort(r)
+
+      Set.new(r)
     end
 
     RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
@@ -345,11 +378,11 @@ class Rufus::Scheduler
 
       return %w[ L ] if item == 'L'
 
-      item = '*' + item if item.match(/^\//)
+      item = '*' + item if item[0, 1] == '/'
 
       m = item.match(RANGE_REGEX)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "cannot parse #{item.inspect}"
       ) unless m
 
@@ -363,7 +396,7 @@ class Rufus::Scheduler
       inc = m[3]
       inc = inc ? inc.to_i : 1
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "#{item.inspect} is not in range #{min}..#{max}"
       ) if sta < min || edn > max
 
@@ -435,32 +468,6 @@ class Rufus::Scheduler
 
       [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
     end
-
-    def local_time(time)
-
-      @timezone ? @timezone.utc_to_local(time.getutc) : time
-    end
-
-    def global_time(time, from_in_utc)
-
-      if @timezone
-        time =
-          begin
-            @timezone.local_to_utc(time)
-          rescue TZInfo::AmbiguousTime
-            @timezone.local_to_utc(time, time.isdst)
-          end
-        time = time.getlocal unless from_in_utc
-      end
-
-      time
-    end
-
-    def round_to_seconds(time)
-
-      # Ruby 1.8 doesn't have #round
-      time.respond_to?(:round) ? time.round : time - time.usec * 1e-6
-    end
   end
 end
 

data/lib/rufus/scheduler/job_array.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2015, 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
@@ -22,6 +22,7 @@
 # Made in Japan.
 #++
 
+
 module Rufus
 
   class Scheduler

data/lib/rufus/scheduler/jobs.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2014, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2015, 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
@@ -91,7 +91,7 @@ module Rufus
 
         @id = determine_id
 
-        raise(
+        fail(
           ArgumentError,
           'missing block or callable to schedule',
           caller[2..-1]
@@ -117,15 +117,16 @@ module Rufus
 
       def trigger(time)
 
-        set_next_time(false, time)
+        set_next_time(time)
 
-        return if opts[:overlap] == false && running?
-
-        r =
+        return if (
+          opts[:overlap] == false &&
+          running?
+        )
+        return if (
           callback(:confirm_lock, time) &&
           callback(:on_pre_trigger, time)
-
-        return if r == false
+        ) == false
 
         @count += 1
 
@@ -234,7 +235,7 @@ module Rufus
 
       rescue StandardError => se
 
-        raise se unless do_rescue
+        fail se unless do_rescue
 
         return if se.is_a?(KillSignal) # discard
 
@@ -272,7 +273,7 @@ module Rufus
 
       def post_trigger(time)
 
-        set_next_time(true, time)
+        set_next_time(time, true)
 
         callback(:on_post_trigger, time)
       end
@@ -283,7 +284,7 @@ module Rufus
           Thread.new do
 
             Thread.current[@scheduler.thread_key] = true
-            Thread.current[:rufus_scheduler_job_thread] = true
+            Thread.current[:rufus_scheduler_work_thread] = true
 
             loop do
 
@@ -339,7 +340,7 @@ module Rufus
 
       def occurrences(time0, time1)
 
-        time >= time0 && time <= time1 ? [ time ] : []
+        (time >= time0 && time <= time1) ? [ time ] : []
       end
 
       protected
@@ -350,13 +351,13 @@ module Rufus
           self.class.name.split(':').last.downcase[0..-4],
           @scheduled_at.to_f,
           @next_time.to_f,
-          opts.hash.abs
+          self.hash.abs
         ].map(&:to_s).join('_')
       end
 
       # There is no next_time for one time jobs, hence the false.
       #
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time = is_post ? nil : false
       end
@@ -390,7 +391,7 @@ module Rufus
       attr_reader :paused_at
 
       attr_reader :first_at
-      attr_accessor :last_at
+      attr_reader :last_at
       attr_accessor :times
 
       def initialize(scheduler, duration, opts, block)
@@ -401,47 +402,53 @@ module Rufus
 
         @times = opts[:times]
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot accept :times => #{@times.inspect}, not nil or an int"
         ) unless @times == nil || @times.is_a?(Fixnum)
 
         self.first_at =
           opts[:first] || opts[:first_time] ||
           opts[:first_at] || opts[:first_in] ||
-          0
+          nil
         self.last_at =
           opts[:last] || opts[:last_at] || opts[:last_in]
       end
 
       def first_at=(first)
 
-        n = Time.now
-        first = n + 0.001 if first == :now || first == :immediately
+        return (@first_at = nil) if first == nil
+
+        n0 = Time.now
+        n1 = n0 + 0.003
+
+        first = n0 if first == :now || first == :immediately || first == 0
 
         @first_at = Rufus::Scheduler.parse_to_time(first)
+        @first_at = n1 if @first_at >= n0 && @first_at < n1
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot set first[_at|_in] in the past: " +
           "#{first.inspect} -> #{@first_at.inspect}"
-        ) if first != 0 && @first_at < n
+        ) if @first_at < n0
+
+        @first_at
       end
 
       def last_at=(last)
 
         @last_at = last ? Rufus::Scheduler.parse_to_time(last) : nil
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot set last[_at|_in] in the past: " +
           "#{last.inspect} -> #{@last_at.inspect}"
         ) if last && @last_at < Time.now
+
+        @last_at
       end
 
       def trigger(time)
 
         return if @paused_at
-        return if time < @first_at
-          #
-          # TODO: remove me when @first_at gets reworked
 
         return (@next_time = nil) if @times && @times < 1
         return (@next_time = nil) if @last_at && time >= @last_at
@@ -473,7 +480,7 @@ module Rufus
         [
           self.class.name.split(':').last.downcase[0..-4],
           @scheduled_at.to_f,
-          opts.hash.abs
+          self.hash.abs
         ].map(&:to_s).join('_')
       end
 
@@ -522,25 +529,26 @@ module Rufus
 
         @frequency = Rufus::Scheduler.parse_in(@original)
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot schedule #{self.class} with a frequency " +
           "of #{@frequency.inspect} (#{@original.inspect})"
         ) if @frequency <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         return if is_post
 
+        n = Time.now
+
         @next_time =
-          if trigger_time
-            trigger_time + @frequency
-          elsif @first_at < Time.now
-            Time.now + @frequency
+          if @first_at == nil || @first_at < n
+            nt = (@next_time || trigger_time || n) + @frequency
+            nt > n ? nt : (trigger_time || n) + @frequency
           else
             @first_at
           end
@@ -562,23 +570,23 @@ module Rufus
 
         @interval = Rufus::Scheduler.parse_in(@original)
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot schedule #{self.class} with an interval " +
           "of #{@interval.inspect} (#{@original.inspect})"
         ) if @interval <= 0
 
-        set_next_time(false, nil)
+        set_next_time(nil)
       end
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
         @next_time =
           if is_post
             Time.now + @interval
           elsif trigger_time.nil?
-            if @first_at < Time.now
+            if @first_at == nil || @first_at < Time.now
               Time.now + @interval
             else
               @first_at
@@ -601,7 +609,7 @@ module Rufus
         super(scheduler, cronline, opts, block)
 
         @cron_line = opts[:_t] || CronLine.new(cronline)
-        @next_time = @cron_line.next_time
+        set_next_time(nil)
       end
 
       def frequency
@@ -616,14 +624,18 @@ module Rufus
 
       protected
 
-      def set_next_time(is_post, trigger_time)
+      def set_next_time(trigger_time, is_post=false)
 
-        @next_time = @cron_line.next_time
+        @next_time = next_time_from(trigger_time || Time.now)
       end
 
       def next_time_from(time)
 
-        @cron_line.next_time(time)
+        if @first_at == nil || @first_at <= time
+          @cron_line.next_time(time)
+        else
+          @first_at
+        end
       end
     end
   end