rufus-scheduler 3.1.0 → 3.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03122e92f3b47a4af3d12b06762f5f4caa604341
+  data.tar.gz: 8db6b1570347d1ffa1871fe9d90163729fbf7516
+SHA512:
+  metadata.gz: 0bf2d0ab22e975dc6832fc651dd415708a998960b4b9503865fe560c9b78284b54ac2b5957d8c912d1415776898e211eb6fe6a56c456613df85f5b4afcf35e0f
+  data.tar.gz: 52b001210ccea2c628e4a95e2bde023725cbb1ce9ee78bd635cfedddafcbed9851abda8eb0edb46e5816ba7ddc80e55dae256588a6caf079f9ebd126d5dbd3c7

data/CHANGELOG.txt

@@ -2,6 +2,54 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.1.9    released 2015-11-12
+
+- fix potential RuntimeError in CronLine#prev_second,
+  by Alexandru https://github.com/alexandru-calinoiu
+
+
+== rufus-scheduler - 3.1.8    released 2015-11-10
+
+- stop jumping eagerly out of DST, fix for one hour jump when leaving DST
+  thanks Alyssa http://github.com/alyssa
+
+
+== rufus-scheduler - 3.1.7    released 2015-10-15
+
+- ack #unscheduled_at in #scheduled?, by Claude https://github.com/claudeatsafe
+
+
+== rufus-scheduler - 3.1.6    released 2015-10-01
+
+- fix job id uniqueness (JRuby), thanks 김성식 https://github.com/kssminus
+
+
+== rufus-scheduler - 3.1.5    released 2015-09-25
+
+- fix for "not a valid cronline" on "mingw" Ruby distributions, gh-166
+
+
+== 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
+- fix inconsistency in Job#start_work_thread
+
+
+== rufus-scheduler - 3.1.2    released 2015/05/23
+
+- avoid cron/:first_at infinite loop, thanks https://github.com/pouellet
+
+
+== rufus-scheduler - 3.1.1    released 2015/04/19
+
+- fix ZoTime.is_timezone? on OSX, thanks https://github.com/yaauie
+
+
 == rufus-scheduler - 3.1.0    released 2015/04/18
 
 - go without tzinfo (and its dependencies)

data/CREDITS.txt

@@ -4,6 +4,13 @@
 
 == Contributors
 
+- Calinoiu Alexandru Nicolae (https://github.com/alexandru-calinoiu) CronLine#prev_second fix
+- Alyssa Pohahau (https://github.com/alyssa) out of DST transition specs
+- Claude Vessaz (https://github.com/claudeatsafe) ack #unscheduled_at in #scheduled?
+- 김성식 (https://github.com/kssminus) job id uniqueness effort
+- 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
 - Gabriel Gilder (https://github.com/ggilder) LA DST specs
 - Sterling Paramore (https://github.com/gnilrets) underscore TZ fix
@@ -35,6 +42,10 @@
 
 == Feedback
 
+- Suisea - https://github.com/suisea - readme rewording
+- Radek - http://stackoverflow.com/users/250422 - gh-166
+- Patrik Ragnarsson - https://github.com/dentarg - timeout vs nil, gh-156
+- twitter @adefilaedward1 - typo in readme
 - Michael Guymon - https://github.com/mguymon - #next_time vs :first_at
 - junhanamaki - https://github.com/junhanamaki - #next_time and dst ambiguities
 - kreynolds (tossrock) - inspiration for #occurrences

data/README.md

@@ -75,10 +75,10 @@ There is no EventMachine-based scheduler anymore.
 
 ## I don't know what this Ruby thing is, where are my Rails?
 
-Sir, I'll drive you right to the [tracks](#so-rails).
+I'll drive you right to the [tracks](#so-rails).
 
 
-## Notables changes:
+## Notable changes:
 
 * As said, no more EventMachine-based scheduler
 * ```scheduler.every('100') {``` will schedule every 100 seconds (previously, it would have been 0.1s). This aligns rufus-scheduler on Ruby's ```sleep(100)```
@@ -1399,6 +1399,7 @@ s = Rufus::Scheduler.singleton
 s.every '1m' do
 
   Rails.logger.info "hello, it's #{Time.now}"
+  Rails.logger.flush
 end
 ```
 
@@ -1427,6 +1428,21 @@ The rufus-scheduler singleton is instantiated in the ```config/initializers/sche
 
 *Warning*: this works well with single-process Ruby servers like Webrick and Thin. Using rufus-scheduler with Passenger or Unicorn requires a bit more knowledge and tuning, gently provided by a bit of googling and reading, see [Faq](#faq) above.
 
+### rails server -d
+
+(Written in reply to https://github.com/jmettraux/rufus-scheduler/issues/165 )
+
+There is the handy `rails server -d` that starts a development Rails as a daemon. The annoying thing is that the scheduler as seen above is started in the main process that then gets forked and daemonized. The rufus-scheduler thread (and any other thread) gets lost, no scheduling happens.
+
+I avoid running `-d` in development mode and bother about daemonizing only for production deployment.
+
+These are two well crafted articles on process daemonization, please read them:
+
+* http://www.mikeperham.com/2014/09/22/dont-daemonize-your-daemons/
+* http://www.mikeperham.com/2014/07/07/use-runit/
+
+If, anyway, you need something like `rails server -d`, why not try `bundle exec unicorn -D` instead? In my (limited) experience, it worked out of the box (well, had to add `gem 'unicorn'` to `Gemfile` first).
+
 
 ## support
 

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,32 @@ class Rufus::Scheduler
 
     def prev_second(time)
 
-      secs = @seconds.sort
+      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
@@ -351,7 +351,7 @@ class Rufus::Scheduler
         end
       end
 
-      weekdays = weekdays.uniq if weekdays
+      weekdays = weekdays.uniq.sort if weekdays
 
       [ weekdays, monthdays ]
     end
@@ -366,6 +366,8 @@ class Rufus::Scheduler
         "found duplicates in #{item.inspect}"
       ) if r.uniq.size < r.size
 
+      r = sc_sort(r)
+
       Set.new(r)
     end
 

data/lib/rufus/scheduler/jobs.rb

@@ -284,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
 
@@ -351,7 +351,7 @@ 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
 
@@ -473,7 +473,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
 
@@ -621,7 +621,7 @@ module Rufus
 
       def next_time_from(time)
 
-        if @first_at == nil || @first_at < time
+        if @first_at == nil || @first_at <= time
           @cron_line.next_time(time)
         else
           @first_at

data/lib/rufus/scheduler/zones.rb

@@ -151,6 +151,7 @@ America/Argentina/Catamarca America/Indiana/Indianapolis
 America/North_Dakota/New_Salem America/Argentina/Rio_Gallegos
 America/Argentina/Buenos_Aires America/Argentina/ComodRivadavia
 ]
+TIMEZONEs = TIMEZONES.collect(&:downcase)
 
 ##
 ## http://en.wikipedia.org/wiki/List_of_time_zone_abbreviations

data/lib/rufus/scheduler/zotime.rb

@@ -47,13 +47,19 @@ class Rufus::Scheduler
 
         t = Time.at(@seconds)
 
-        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
+        #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
+
+        t.hour # force t to compute itself
+          #
+          # stay in DST as long as possible, no jump seen from UTC
 
         t
       end
@@ -121,17 +127,24 @@ class Rufus::Scheduler
     def self.is_timezone?(str)
 
       return false if str == nil
+      return false if str == '*'
+
+      return false if str.index('#')
+        # "sun#2", etc... On OSX would go all the way to true
 
       return true if Time.zone_offset(str)
-      return true if str == 'Zulu'
 
       return !! (::TZInfo::Timezone.get(str) rescue nil) if defined?(::TZInfo)
 
-      zt = ZoTime.new(0, str)
-      t = zt.time
+      return true if TIMEZONES.include?(str)
+      return true if TIMEZONEs.include?(str)
+
+      t = ZoTime.new(0, str).time
 
       return false if t.zone == ''
-      return false if str.match(/[a-z]/) && str.start_with?(t.zone)
+      return false if t.zone == 'UTC'
+      return false if t.utc_offset == 0 && str.start_with?(t.zone)
+        # 3 common fallbacks...
 
       return false if RUBY_PLATFORM.include?('java') && ! envtzable?(str)
 

data/lib/rufus/scheduler.rb

@@ -39,7 +39,7 @@ module Rufus
     require 'rufus/scheduler/job_array'
     require 'rufus/scheduler/locks'
 
-    VERSION = '3.1.0'
+    VERSION = '3.1.9'
 
     #
     # A common error class for rufus-scheduler
@@ -387,7 +387,7 @@ module Rufus
 
       job, job_id = fetch(job_or_job_id)
 
-      !! (job && job.next_time != nil)
+      !! (job && job.unscheduled_at.nil? && job.next_time != nil)
     end
 
     # Lists all the threads associated with this scheduler.
@@ -592,11 +592,11 @@ module Rufus
 
         job = t[:rufus_scheduler_job]
         to = t[:rufus_scheduler_timeout]
+        ts = t[:rufus_scheduler_time]
 
-        next unless job && to
+        next unless job && to && ts
           # thread might just have become inactive (job -> nil)
 
-        ts = t[:rufus_scheduler_time]
         to = to.is_a?(Time) ? to : ts + to
 
         next if to > Time.now

data/spec/cronline_spec.rb

@@ -7,6 +7,17 @@
 
 require 'spec_helper'
 
+class Time
+
+  def to_compact_s
+
+    off = self.utc_offset / 3600
+    off = off >= 0 ? "+#{off}" : off.to_s
+
+    self.strftime('%H%M') + off + self.dup.utc.strftime('(%H%M)')
+  end
+end
+
 
 describe Rufus::Scheduler::CronLine do
 
@@ -32,6 +43,13 @@ 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 ps(cronline, now)
+    Rufus::Scheduler::CronLine.new(cronline).prev_second(now)
+  end
+
   def match(line, time)
     expect(cl(line).matches?(time)).to eq(true)
   end
@@ -66,30 +84,42 @@ describe Rufus::Scheduler::CronLine do
 
       to_a '0 0 1 1 *', [ [0], [0], [0], [1], [1], 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
+      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
         #
         # as reported by Aimee Rose in
         # https://github.com/jmettraux/rufus-scheduler/issues/56
-
-      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-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
+      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
 
-      expect { cl '0 17 * * MON_FRI' }.to raise_error
+      expect { cl '0 17 * * MON_FRI' }.to raise_error(ArgumentError)
         # underline instead of dash
 
-      expect { cl '* * * * 9' }.to raise_error
-      expect { cl '* * * * 0-12' }.to raise_error
-      expect { cl '* * * * BLABLA' }.to raise_error
+      expect { cl '* * * * 9' }.to raise_error(ArgumentError)
+      expect { cl '* * * * 0-12' }.to raise_error(ArgumentError)
+      expect { cl '* * * * BLABLA' }.to raise_error(ArgumentError)
     end
 
     it 'rejects invalid cronlines' do
@@ -109,8 +139,8 @@ describe Rufus::Scheduler::CronLine do
         '* * * * * * America/New_York',
         [ nil, nil, nil, nil, nil, nil, nil, 'America/New_York' ])
 
-      expect { cl '* * * * * NotATimeZone' }.to raise_error
-      expect { cl '* * * * * * NotATimeZone' }.to raise_error
+      expect { cl '* * * * * NotATimeZone' }.to raise_error(ArgumentError)
+      expect { cl '* * * * * * NotATimeZone' }.to raise_error(ArgumentError)
     end
 
     it 'interprets cron strings with / (slashes) correctly' do
@@ -213,6 +243,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
@@ -346,7 +406,10 @@ describe Rufus::Scheduler::CronLine do
             '30 1 31 10 * America/New_York',
             ltz('America/New_York', 2004, 10, 1)
           )
-        ).to eq(ltz('America/New_York', 2004, 10, 31, 1, 30, 0))
+        ).to eq(
+          ltz('America/New_York', 0, 30, 1, 31, 10, 2004, nil, nil, true, nil)
+            # EDT summer time UTC-4
+        )
       end
     end
 
@@ -361,6 +424,75 @@ 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))
+      )
+    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 ],
+    ].each do |cronline, now, sec|
+      it "ensures that next_second('#{cronline}', #{now}) is #{sec}" do
+        expect(ns(cronline,now)).to eq(sec)
+      end
+    end
+  end
+
+  describe '#prev_second' do
+
+    it 'returns the time to the closest previous second' do
+
+      t = local(1970, 1, 1, 1, 1, 42)
+
+      expect(ps('35,44 * * * * *', t)).to eq(7)
+    end
+
+    context 'when time sec is lower then all cron seconds (gh-177)' do
+
+      it 'returns the time to the last second a minute before' do
+
+        t = local(1970, 1, 1, 1, 1, 42)
+
+        expect(ps('43,44 * * * * *', t)).to eq(58)
+      end
+    end
   end
 
   describe '#previous_time' do
@@ -380,6 +512,27 @@ describe Rufus::Scheduler::CronLine do
         pt('* * * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 59))
     end
 
+    it 'jumps to the previous minute if necessary (gh-177)' do
+
+      t = local(1970, 12, 31, 1, 1, 0) # vanilla
+      expect(pt('43,44 * * * * *', t)).to eq(lo(1970, 12, 31, 1, 0, 44))
+
+      t = local(1970, 12, 31, 1, 1, 30) # 30 < 43 <---- here!
+      expect(pt('43,44 * * * * *', t)).to eq(lo(1970, 12, 31, 1, 0, 44))
+
+      t = local(1970, 12, 31, 1, 1, 43) # 43 <= 43 < 44
+      expect(pt('43,44 * * * * *', t)).to eq(lo(1970, 12, 31, 1, 0, 44))
+
+      t = local(1970, 12, 31, 1, 1, 44) # 44 <= 44
+      expect(pt('43,44 * * * * *', t)).to eq(lo(1970, 12, 31, 1, 1, 43))
+
+      t = local(1970, 12, 31, 1, 1, 59) # 44 < 59
+      expect(pt('43,44 * * * * *', t)).to eq(lo(1970, 12, 31, 1, 1, 44))
+
+      t = local(1970, 12, 31, 1, 1, 30) # a bigger jump
+      expect(pt('43,44 10 * * * *', t)).to eq(lo(1970, 12, 31, 0, 10, 44))
+    end
+
     # New York      EST: UTC-5
     # summer (dst)  EDT: UTC-4
 
@@ -400,7 +553,10 @@ describe Rufus::Scheduler::CronLine do
             '30 1 31 10 * America/New_York',
             ltz('America/New_York', 2004, 10, 31, 14, 30, 0)
           )
-        ).to eq(ltz('America/New_York', 2004, 10, 31, 1, 30, 0))
+        ).to eq(
+          ltz('America/New_York', 0, 30, 1, 31, 10, 2004, nil, nil, false, nil)
+            # EST time UTC-5
+        )
       end
     end
 
@@ -415,6 +571,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
@@ -541,6 +711,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
@@ -572,6 +782,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
@@ -678,19 +924,17 @@ describe Rufus::Scheduler::CronLine do
         t = Time.local(2015, 3, 8, 1, 57)
 
         points =
-          [ 0, 1, 2, 3 ].collect do
+          4.times.collect do
             t = line.next_time(t)
-            t.strftime('%H:%M:%Sl') + ' ' + t.dup.utc.strftime('%H:%M:%Su')
+            t.to_compact_s
           end
 
-        expect(points).to eq(
-          [
-            '01:58:00l 09:58:00u',
-            '01:59:00l 09:59:00u',
-            '03:00:00l 10:00:00u',
-            '03:01:00l 10:01:00u'
-          ]
-        )
+        expect(points).to eq([
+          '0158-8(0958)',
+          '0159-8(0959)',
+          '0300-7(1000)',
+          '0301-7(1001)'
+        ])
       end
     end
 
@@ -710,19 +954,158 @@ describe Rufus::Scheduler::CronLine do
         t = Time.local(2015, 3, 8, 3, 2)
 
         points =
-          [ 0, 1, 2, 3 ].collect do
+          4.times.collect do
             t = line.previous_time(t)
-            t.strftime('%H:%M:%Sl') + ' ' + t.dup.utc.strftime('%H:%M:%Su')
+            t.to_compact_s
           end
 
-        expect(points).to eq(
-          [
-            '03:01:00l 10:01:00u',
-            '03:00:00l 10:00:00u',
-            '01:59:00l 09:59:00u',
-            '01:58:00l 09:58:00u'
-          ]
-        )
+        expect(points).to eq([
+          '0301-7(1001)',
+          '0300-7(1000)',
+          '0159-8(0959)',
+          '0158-8(0958)'
+        ])
+      end
+    end
+
+    it 'correctly increments when entering DST' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('*/10 * * * * America/Los_Angeles')
+
+        t = Time.local(2015, 3, 8, 1, 40)
+        t1 = t.dup
+
+        points = []
+        while t1 - t < 1 * 3600
+          t1 = line.next_time(t1)
+          points << t1.to_compact_s
+        end
+
+        expect(points).to eq(%w[
+          0150-8(0950)
+          0300-7(1000)
+          0310-7(1010)
+          0320-7(1020)
+          0330-7(1030)
+          0340-7(1040)
+        ])
+      end
+    end
+  end
+
+  context 'fall time' do
+
+    it 'correctly increments through a DST transition' do
+
+      expect(
+        nt('* * * * * America/Los_Angeles', Time.utc(2015, 11, 1, 9, 59))
+      ).to eq(Time.utc(2015, 11, 1, 10, 00))
+    end
+
+    it 'correctly increments every minute through a DST transition' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('* * * * * America/Los_Angeles')
+
+        #t = Time.local(2015, 11, 1, 1, 57)
+          #
+          # --> 2015-11-01 01:57:00 -0800 (already PST)
+
+        t = Time.local(0, 57, 1, 1, 11, 2015, nil, nil, true, nil)
+          #
+          # --> 2015-11-01 01:57:00 -0700 (still PDT)
+
+        points =
+          4.times.collect do
+            t = line.next_time(t)
+            t.to_compact_s
+          end
+
+        expect(points).to eq([
+          '0158-7(0858)',
+          '0159-7(0859)',
+          '0100-8(0900)',
+          '0101-8(0901)'
+        ])
+      end
+    end
+
+    it 'correctly decrements through a DST transition' do
+
+      expect(
+        pt('* * * * * America/Los_Angeles', Time.utc(2015, 11, 1, 10, 00))
+      ).to eq(Time.utc(2015, 11, 1, 9, 59))
+    end
+
+    it 'correctly decrements every minute through a DST transition' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('* * * * * America/Los_Angeles')
+
+        t = Time.local(0, 2, 1, 1, 11, 2015, nil, nil, true, nil)
+          #
+          # try to force PST
+
+        # TODO: at some point, try to find out if the latest jRuby still
+        #       exhibits that behaviour, report to them if necessary
+
+        points =
+          (0..3).collect do
+            t = line.previous_time(t)
+            t.to_compact_s
+          end
+
+        if t.zone == 'PST'
+          expect(points).to eq([
+            '0101-8(0901)',
+            '0100-8(0900)',
+            '0159-7(0859)',
+            '0158-7(0858)'
+          ])
+        else
+          expect(points).to eq([
+            '0101-7(0801)',
+            '0100-7(0800)',
+            '0059-7(0759)',
+            '0058-7(0758)'
+          ])
+        end
+      end
+    end
+
+    it 'correctly increments when leaving DST' do
+
+      in_zone 'America/Los_Angeles' do
+
+        line = cl('*/10 * * * * America/Los_Angeles')
+
+        t = Time.local(2015, 11, 1, 0, 40)
+        t1 = t.dup
+
+        points = []
+        while t1 - t < 2 * 3600
+          t1 = line.next_time(t1)
+          points << t1.to_compact_s
+        end
+
+        expect(points).to eq([
+          '0050-7(0750)', # | PDT
+          '0100-7(0800)', # |
+          '0110-7(0810)', # V
+          '0120-7(0820)',
+          '0130-7(0830)',
+          '0140-7(0840)',
+          '0150-7(0850)',
+          '0100-8(0900)', # + PST
+          '0110-8(0910)', # |
+          '0120-8(0920)', # V
+          '0130-8(0930)',
+          '0140-8(0940)'
+        ])
       end
     end
   end

data/spec/job_spec.rb

@@ -176,6 +176,16 @@ describe Rufus::Scheduler::Job do
       expect(job.running?).to eq(true)
       expect(job.scheduled?).to eq(true)
     end
+
+    it 'returns false if job is unscheduled' do
+      job = @scheduler.schedule_interval('0.1s') { sleep 0.1 }
+      job.unschedule
+
+      sleep 0.3
+
+      expect(job.running?).to eq(false)
+      expect(job.scheduled?).to eq(false)
+    end
   end
 
   describe '#call' do
@@ -627,5 +637,35 @@ describe Rufus::Scheduler::Job do
       end
     end
   end
+
+  context 'one time job' do
+
+    describe '#determine_id' do
+
+      it 'returns unique ids' do
+
+        ids = []
+
+        10_000.times { ids << @scheduler.in('1y') {} }
+
+        expect(ids.uniq.length).to eq(ids.length)
+      end
+    end
+  end
+
+  context 'repeat job' do
+
+    describe '#determine_id' do
+
+      it 'returns unique ids' do
+
+        ids = []
+
+        10_000.times { ids << @scheduler.every('1y') {} }
+
+        expect(ids.uniq.length).to eq(ids.length)
+      end
+    end
+  end
 end
 

data/spec/scheduler_spec.rb

@@ -611,7 +611,7 @@ describe Rufus::Scheduler do
     end
   end
 
-  describe '#timeline(time0, time1)' do
+  describe '#timeline' do
 
     it 'returns a [ [ time, job ], ... ] of job occurrences' do
 
@@ -625,6 +625,21 @@ describe Rufus::Scheduler do
       expect(a[1][0]).to be_within_1s_of(Time.now + 10 * 60)
       expect(a[1][1]).to eq(j1)
     end
+
+    it 'should not lock when running timeline with a :first_at specified' do
+
+      now = Time.now
+
+      # scheduling a cron job with a first_at and running #timeline used
+      # to result in an infinite loop.
+
+      @scheduler.cron('* * * * * *', :first_at => now + 3) {}
+
+      jobs = @scheduler.timeline(now, now + 4)
+      expect(jobs.size).to be 2
+      expect(jobs[0][0]).to be_within_1s_of now + 3
+      expect(jobs[1][0]).to be_within_1s_of now + 4
+    end
   end
 
   #--

data/spec/spec_helper.rb

@@ -5,6 +5,8 @@
 # Wed Apr 17 06:00:59 JST 2013
 #
 
+require 'pp'
+
 puts "RUBY_VERSION: #{RUBY_VERSION}"
 puts "RUBY_PLATFORM: #{RUBY_PLATFORM}"
 

data/spec/zotime_spec.rb

@@ -73,22 +73,17 @@ describe Rufus::Scheduler::ZoTime do
     # New York      EST: UTC-5
     # summer (dst)  EDT: UTC-4
 
-    it 'chooses the non DST time when there is ambiguity' do
+    it 'chooses the DST time when there is ambiguity' do
 
       t = ltz('America/New_York', 2004, 10, 31, 0, 30, 0)
       zt = Rufus::Scheduler::ZoTime.new(t, 'America/New_York')
       zt.add(3600)
       ztt = zt.time
 
-      expect(ztt.to_i).to eq(1099204200)
+      expect(ztt.to_i).to eq(1099204200 - 3600)
 
-      if ruby18?
-        expect(ztt.strftime('%Y/%m/%d %H:%M:%S %Z %z')
-          ).to eq('2004/10/31 01:30:00 EST -0500')
-      else
-        expect(ztt.strftime('%Y/%m/%d %H:%M:%S %Z %z')
-          ).to eq('2004/10/31 01:30:00 EST -0500')
-      end
+      expect(ztt.strftime('%Y/%m/%d %H:%M:%S %Z %z')
+        ).to eq('2004/10/31 01:30:00 EDT -0400')
     end
   end
 
@@ -162,17 +157,17 @@ describe Rufus::Scheduler::ZoTime do
       st3 = t3.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t3.isdst}"
 
       expect(t0.to_i).to eq(1414281599)
-      expect(t1.to_i).to eq(1414285200)
+      expect(t1.to_i).to eq(1414285200 - 3600)
       expect(t2.to_i).to eq(1414285200)
       expect(t3.to_i).to eq(1414285201)
 
       expect(st0).to eq('2014/10/26 01:59:59 CEST true')
-      expect(st1).to eq('2014/10/26 02:00:00 CET false')
+      expect(st1).to eq('2014/10/26 02:00:00 CEST true')
       expect(st2).to eq('2014/10/26 02:00:00 CET false')
       expect(st3).to eq('2014/10/26 02:00:01 CET false')
 
-      expect(t1 - t0).to eq(3601)
-      expect(t2 - t1).to eq(0)
+      expect(t1 - t0).to eq(1)
+      expect(t2 - t1).to eq(3600)
       expect(t3 - t2).to eq(1)
     end
   end

data/t.txt

@@ -0,0 +1,31 @@
+
+JRUBY
+
+1) Rufus::Scheduler::CronLine fall time correctly decrements every minute through a DST transition
+
+Failure/Error: expect(points).to eq([
+
+expected: ["0101-8(0901)", "0100-8(0900)", "0159-7(0859)", "0158-7(0858)"]
+     got: ["0101-7(0801)", "0100-7(0800)", "0059-7(0759)", "0058-7(0758)"]
+
+(compared using ==)
+# ./spec/cronline_spec.rb:1013:in `(root)'
+# ./spec/spec_helper.rb:69:in `in_zone'
+# ./spec/cronline_spec.rb:1001:in `(root)'
+
+
+RUBY1.8
+
+1) Rufus::Scheduler::CronLine fall time correctly decrements every minute through a DST transition
+
+Failure/Error: expect(points).to eq([
+
+expected: ["0101-8(0901)", "0100-8(0900)", "0159-7(0859)", "0158-7(0858)"]
+     got: ["0101-7(0801)", "0100-7(0800)", "0059-7(0759)", "0058-7(0758)"]
+
+(compared using ==)
+# ./spec/cronline_spec.rb:1013
+# ./spec/spec_helper.rb:69:in `call'
+# ./spec/spec_helper.rb:69:in `in_zone'
+# ./spec/cronline_spec.rb:1001
+

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: rufus-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.1.0
-  prerelease: 
+  version: 3.1.9
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-17 00:00:00.000000000 Z
+date: 2015-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.13.0
 - !ruby/object:Gem::Dependency
   name: chronic
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: job scheduler for Ruby (at, cron, in and every jobs).
@@ -82,70 +73,70 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.txt
+- CREDITS.txt
+- LICENSE.txt
+- README.md
 - Rakefile
+- TODO.txt
 - lib/rufus-scheduler.rb
 - lib/rufus/scheduler.rb
-- lib/rufus/scheduler/locks.rb
-- lib/rufus/scheduler/zotime.rb
 - lib/rufus/scheduler/cronline.rb
-- lib/rufus/scheduler/util.rb
+- lib/rufus/scheduler/job_array.rb
 - lib/rufus/scheduler/jobs.rb
+- lib/rufus/scheduler/locks.rb
+- lib/rufus/scheduler/util.rb
 - lib/rufus/scheduler/zones.rb
-- lib/rufus/scheduler/job_array.rb
-- spec/job_spec.rb
-- spec/schedule_in_spec.rb
-- spec/zotime_spec.rb
-- spec/spec_helper.rb
+- lib/rufus/scheduler/zotime.rb
+- rufus-scheduler.gemspec
+- spec/basics_spec.rb
+- spec/cronline_spec.rb
+- spec/error_spec.rb
 - spec/job_array_spec.rb
-- spec/schedule_interval_spec.rb
 - spec/job_at_spec.rb
-- spec/schedule_at_spec.rb
-- spec/error_spec.rb
-- spec/lock_spec.rb
-- spec/schedule_cron_spec.rb
+- spec/job_cron_spec.rb
+- spec/job_every_spec.rb
+- spec/job_in_spec.rb
 - spec/job_interval_spec.rb
 - spec/job_repeat_spec.rb
-- spec/schedule_every_spec.rb
-- spec/threads_spec.rb
-- spec/cronline_spec.rb
+- spec/job_spec.rb
+- spec/lock_custom_spec.rb
+- spec/lock_flock_spec.rb
 - spec/lock_lockfile_spec.rb
-- spec/job_in_spec.rb
+- spec/lock_spec.rb
 - spec/parse_spec.rb
+- spec/schedule_at_spec.rb
+- spec/schedule_cron_spec.rb
+- spec/schedule_every_spec.rb
+- spec/schedule_in_spec.rb
+- spec/schedule_interval_spec.rb
 - spec/scheduler_spec.rb
-- spec/lock_custom_spec.rb
-- spec/basics_spec.rb
-- spec/job_cron_spec.rb
-- spec/job_every_spec.rb
-- spec/lock_flock_spec.rb
-- rufus-scheduler.gemspec
-- CHANGELOG.txt
-- TODO.txt
-- LICENSE.txt
-- CREDITS.txt
-- README.md
+- spec/spec_helper.rb
+- spec/threads_spec.rb
+- spec/zotime_spec.rb
+- t.txt
 homepage: http://github.com/jmettraux/rufus-scheduler
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: rufus
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: job scheduler for Ruby (at, cron, in and every jobs)
 test_files: []