rufus-scheduler 3.1.3 → 3.1.4

data/CHANGELOG.txt

@@ -2,6 +2,11 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.1.4    released 2015/08/29
+
+- fix cron issue reported by Jesse https://github.com/jhw-at-prosperworks-com
+
+
 == rufus-scheduler - 3.1.3    released 2015/06/20
 
 - prevent Thread[:rufus_scheduler_time] -> nil, gh-156

data/CREDITS.txt

@@ -4,6 +4,7 @@
 
 == Contributors
 
+- Jesse Willet (https://github.com/jhw-at-prosperworks-com) cron vs "*/10"
 - Pascal Ouellet (https://github.com/pouellet) Scheduler#timeline loop fix
 - Ryan Biesemeyer (https://github.com/yaauie) ZoTime.is_timezone? on OSX
 - Ketan Padegaonkar (https://github.com/ketan) .brute_frequency improvement

data/lib/rufus/scheduler.rb

@@ -39,7 +39,7 @@ module Rufus
     require 'rufus/scheduler/job_array'
     require 'rufus/scheduler/locks'
 
-    VERSION = '3.1.3'
+    VERSION = '3.1.4'
 
     #
     # A common error class for rufus-scheduler

data/lib/rufus/scheduler/cronline.rb

@@ -186,19 +186,6 @@ class Rufus::Scheduler
       time
     end
 
-    if RUBY_VERSION >= '1.9'
-      def toa(item)
-        item == nil ? nil : item.to_a
-      end
-    else
-      def toi(item); item.is_a?(String) ? item.hash.abs : item.to_i; end
-      protected :toi
-      def toa(item)
-        item.is_a?(Set) ? item.to_a.sort_by { |e| toi(e) } : item
-      end
-    end
-    protected :toa
-
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
     # months, weekdays).
     # This method is used by the cronline unit tests.
@@ -228,16 +215,12 @@ class Rufus::Scheduler
 
       return brute_frequency unless @seconds && @seconds.length > 1
 
-      delta = 60
       secs = toa(@seconds)
-      prev = secs[0]
 
-      secs[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
 
     # Returns the shortest delta between two potential occurences of the
@@ -288,13 +271,11 @@ class Rufus::Scheduler
       delta
     end
 
-    protected
-
     def next_second(time)
 
-      secs = @seconds.sort
+      secs = toa(@seconds)
 
-      return secs.last + 60 - time.sec if time.sec > secs.last
+      return secs.first + 60 - time.sec if time.sec > secs.last
 
       secs.shift while secs.first < time.sec
 
@@ -303,13 +284,30 @@ class Rufus::Scheduler
 
     def prev_second(time)
 
-      secs = @seconds.sort
+      secs = toa(@seconds)
 
       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
@@ -351,7 +349,7 @@ class Rufus::Scheduler
         end
       end
 
-      weekdays = weekdays.uniq if weekdays
+      weekdays = weekdays.uniq.sort if weekdays
 
       [ weekdays, monthdays ]
     end
@@ -366,6 +364,8 @@ class Rufus::Scheduler
         "found duplicates in #{item.inspect}"
       ) if r.uniq.size < r.size
 
+      r = sc_sort(r)
+
       Set.new(r)
     end
 

data/spec/cronline_spec.rb

@@ -32,6 +32,10 @@ describe Rufus::Scheduler::CronLine do
     in_zone(tz) { tu.getlocal }
   end
 
+  def ns(cronline, now)
+    Rufus::Scheduler::CronLine.new(cronline).next_second(now)
+  end
+
   def match(line, time)
     expect(cl(line).matches?(time)).to eq(true)
   end
@@ -68,20 +72,30 @@ describe Rufus::Scheduler::CronLine do
 
       to_a '52 0 * * *', [ [0], [52], [0], nil, nil, nil, nil, nil ]
 
-      if ruby18?
-        to_a '0 23-24 * * *', [ [0], [0], [0, 23], nil, nil, nil, nil, nil ]
-      else
-        to_a '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
-      end
+      #if ruby18?
+      #  to_a '0 23-24 * * *', [ [0], [0], [0, 23], nil, nil, nil, nil, nil ]
+      #else
+      #  to_a '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
+      #end
         #
         # as reported by Aimee Rose in
         # https://github.com/jmettraux/rufus-scheduler/issues/56
+      to_a '0 23-24 * * *', [ [0], [0], [0, 23], nil, nil, nil, nil, nil ]
 
-      if ruby18?
-        to_a '0 23-2 * * *', [ [0], [0], [0, 1, 2, 23], nil, nil, nil, nil, nil ]
-      else
-        to_a '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
-      end
+      #if ruby18?
+      #  to_a '0 23-2 * * *', [ [0], [0], [0, 1, 2, 23], nil, nil, nil, nil, nil ]
+      #else
+      #  to_a '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
+      #end
+      to_a '0 23-2 * * *', [ [0], [0], [0, 1, 2, 23], nil, nil, nil, nil, nil ]
+
+      # modulo forms work for five-field forms
+      to_a '*/17 * * * *', [[0], [0, 17, 34, 51], nil, nil, nil, nil, nil, nil]
+      to_a '13 */17 * * *', [[0], [13], [0, 17], nil, nil, nil, nil, nil]
+
+      # modulo forms work for six-field forms
+      to_a '*/17 * * * * *', [[0, 17, 34, 51], nil, nil, nil, nil, nil, nil, nil]
+      to_a '13 */17 * * * *', [[13], [0, 17, 34, 51], nil, nil, nil, nil, nil, nil]
     end
 
     it 'rejects invalid weekday expressions' do
@@ -215,6 +229,36 @@ describe Rufus::Scheduler::CronLine do
         # as reported by Aimee Rose in
         # https://github.com/jmettraux/rufus-scheduler/pull/58
     end
+
+    it 'sorts seconds' do
+
+      to_a(
+        '23,30,10 * * * * *', [ [10,23,30], nil, nil, nil, nil, nil, nil, nil ])
+    end
+
+    it 'sorts minutes' do
+
+      to_a(
+        '23,30,10 * * * * ', [ [0], [10,23,30], nil, nil, nil, nil, nil, nil ])
+    end
+
+    it 'sorts days' do
+
+      to_a(
+        '* * 14,7 * * ', [ [0], nil, nil, [7, 14], nil, nil, nil, nil ])
+    end
+
+    it 'sorts months' do
+
+      to_a(
+        '* * * 11,3,4 * ', [ [0], nil, nil, nil, [3,4,11], nil, nil, nil ])
+    end
+
+    it 'sorts days of week' do
+
+      to_a(
+        '* * * * Sun,Fri,2 ', [ [0], nil, nil, nil, nil, [0, 2, 5], nil, nil ])
+    end
   end
 
   describe '#next_time' do
@@ -363,6 +407,55 @@ describe Rufus::Scheduler::CronLine do
         )
       ).to eq(ltz('America/New_York', 2015, 3, 9, 2, 0, 0))
     end
+
+    it 'understands six-field crontabs' do
+
+      expect(nt('* * * * * *',local(1970,1,1,1,1,1))).to(
+        eq(local(1970,1,1,1,1,2))
+      )
+      expect(nt('* * * * * *',local(1970,1,1,1,1,2))).to(
+        eq(local(1970,1,1,1,1,3))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,0))).to(
+        eq(local(1970,1,1,1,1,10))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,9))).to(
+        eq(local(1970,1,1,1,1,10))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,10))).to(
+        eq(local(1970,1,1,1,1,20))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,40))).to(
+        eq(local(1970,1,1,1,1,50))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,49))).to(
+        eq(local(1970,1,1,1,1,50))
+      )
+      expect(nt('*/10 * * * * *',local(1970,1,1,1,1,50))).to(
+        eq(local(1970,1,1,1,2,00)) # FAILS: skips a minute to 2:50, not 2:00
+      )
+    end
+  end
+
+  describe '#next_second' do
+    [
+      [ '*/10 * * * * *', local(1970,1,1,1,1, 0),  0 ], # 0 sec to  0s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1, 1),  9 ], # 9 sec to 10s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1, 9),  1 ], # 1 sec to 10s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,10),  0 ], # 0 sec to 10s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,11),  9 ], # 9 sec to 20s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,19),  1 ], # 1 sec to 20s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,20),  0 ], # 0 sec to 20s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,21),  9 ], # 1 sec to 30s mark
+      # ...
+      [ '*/10 * * * * *', local(1970,1,1,1,1,49),  1 ], # 9 sec to 50s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,50),  0 ], # 0 sec to 50s mark
+      [ '*/10 * * * * *', local(1970,1,1,1,1,51),  9 ], # FAILS: gives 59
+    ].each do |cronline,now,sec|
+      it "understands that next_second('#{cronline}',#{now}) is #{sec}" do
+        expect(ns(cronline,now)).to eq(sec)
+      end
+    end
   end
 
   describe '#previous_time' do
@@ -417,6 +510,20 @@ describe Rufus::Scheduler::CronLine do
         )
       ).to eq(ltz('America/New_York', 2015, 3, 9, 2, 0, 0))
     end
+
+    it 'computes correctly when * 0,10,20' do
+
+      expect(
+        pt('* 0,10,20 * * *', lo(2000, 1, 1))).to eq(
+          lo(1999, 12, 31, 20, 59, 00))
+    end
+
+    it 'computes correctly when * */10' do
+
+      expect(
+        pt('* */10 * * *', lo(2000, 1, 1))).to eq(
+          lo(1999, 12, 31, 20, 59, 00))
+    end
   end
 
   describe '#matches?' do
@@ -543,6 +650,46 @@ describe Rufus::Scheduler::CronLine do
       expect(Rufus::Scheduler::CronLine.new(
         '10,20,30 * * * * *').frequency).to eq(10)
     end
+
+    it 'spots B-A vs C-B asymmetry in five-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,17,30 * * * *').frequency).to eq(7 * 60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,23,30 * * * *').frequency).to eq(7 * 60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '23,10,30 * * * *').frequency).to eq(7 * 60)
+    end
+
+    it 'spots B-A vs C-B asymmetry in six-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,17,30 * * * * *').frequency).to eq(7)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,23,30 * * * * *').frequency).to eq(7)
+      expect(Rufus::Scheduler::CronLine.new(
+        '23,10,30 * * * * *').frequency).to eq(7)
+    end
+
+    it 'handles crontab steps syntax in five-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '*/10 * * * *').frequency).to eq(10 * 60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* */10 * * *').frequency).to eq(60) # "*" all minutes [0..59]
+      expect(Rufus::Scheduler::CronLine.new(
+        '0 */10 * * *').frequency).to eq(4 * 60 * 60) # 2000 to 0000
+    end
+
+    it 'handles crontab steps syntax in six-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '*/10 * * * * *').frequency).to eq(10)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* */10 * * * *').frequency).to eq(1) # "*" all seconds [0..59]
+      expect(Rufus::Scheduler::CronLine.new(
+        '0 */10 * * * *').frequency).to eq(10 * 60)
+    end
   end
 
   describe '#brute_frequency' do
@@ -574,6 +721,42 @@ describe Rufus::Scheduler::CronLine do
       expect(Rufus::Scheduler::CronLine.new(
         '1 2 3 4 5').brute_frequency).to eq(31622400)
     end
+
+    it 'spots B-A vs C-B asymmetry in five-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,17,30 * * * *').brute_frequency).to eq(7 * 60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,23,30 * * * *').brute_frequency).to eq(7 * 60)
+    end
+
+    it 'spots B-A vs C-B asymmetry in six-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,17,30 * * * * *').brute_frequency).to eq(7)
+      expect(Rufus::Scheduler::CronLine.new(
+        '10,23,30 * * * * *').brute_frequency).to eq(7)
+    end
+
+    it 'handles crontab modulo syntax in five-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '*/10 * * * *').brute_frequency).to eq(10 * 60)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* */10 * * *').brute_frequency).to eq(60) # "*" all minutes [0..59]
+      expect(Rufus::Scheduler::CronLine.new(
+        '0 */10 * * *').brute_frequency).to eq(4 * 60 * 60) # 2000 to 0000
+    end
+
+    it 'handles crontab modulo syntax in six-field forms' do
+
+      expect(Rufus::Scheduler::CronLine.new(
+        '*/10 * * * * *').brute_frequency).to eq(10)
+      expect(Rufus::Scheduler::CronLine.new(
+        '* */10 * * * *').brute_frequency).to eq(1) # "*" all seconds [0..59]
+      expect(Rufus::Scheduler::CronLine.new(
+        '0 */10 * * * *').brute_frequency).to eq(10 * 60)
+    end
   end
 
   context 'summer time' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rufus-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-19 00:00:00.000000000 Z
+date: 2015-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake