rufus-scheduler 3.0.6 → 3.0.7

data/CHANGELOG.txt

@@ -2,6 +2,15 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.0.7    released 2014/03/18
+
+- implement Scheduler #occurrences and #timeline, inspired by kreynolds
+- implement Job #last_work_time and #mean_work_time
+- implement Job#count
+- add more info to the stderr error output (scheduler/tz info)
+- prevent skipping a day on swith to summertime, gh-114, thanks Matteo
+
+
 == rufus-scheduler - 3.0.6    released 2014/02/14
 
 - avoid "can't be called from trap context" on Ruby 2.0, gh-98

data/CREDITS.txt

@@ -30,6 +30,9 @@
 
 == Feedback
 
+- kreynolds (tossrock) - inspiration for #occurrences
+- Matteo - https://github.com/m4ce - dst and cron issue
+- Tobias Bielohlawek - https://github.com/rngtng - missing assertion
 - Joe Taylor and Agis Anastasopoulos -
   http://stackoverflow.com/questions/21280870 - :first => :now and Job#call
 - Gatis Tomsons - https://github.io/gacha - heavy work threads and lock errors

data/README.md

@@ -2,6 +2,7 @@
 # rufus-scheduler
 
 [![Build Status](https://secure.travis-ci.org/jmettraux/rufus-scheduler.png)](http://travis-ci.org/jmettraux/rufus-scheduler)
+[![Gem Version](https://badge.fury.io/rb/rufus-scheduler.png)](http://badge.fury.io/rb/rufus-scheduler)
 
 Job scheduler for Ruby (at, cron, in and every jobs).
 
@@ -113,6 +114,8 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 * [It doesn't work...](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html)
 * [I want a refund](http://blog.nodejitsu.com/getting-refunds-on-open-source-projects)
 * [Passenger and rufus-scheduler](http://stackoverflow.com/questions/18108719/debugging-rufus-scheduler/18156180#18156180)
+* [Passenger and rufus-scheduler (2)](http://stackoverflow.com/questions/21861387/rufus-cron-job-not-working-in-apache-passenger#answer-21868555)
+* [Unicorn and rufus-scheduler](https://jkraemer.net/running-rufus-scheduler-in-a-unicorn-rails-app)
 
 
 ## scheduling
@@ -249,6 +252,25 @@ The second argument is "time", it's the time when the job got cleared for trigge
 
 Note that time is the time when the job got cleared for triggering. If there are mutexes involved, now = mutex_wait_time + time...
 
+#### "every" jobs and changing the next_time in-flight
+
+It's OK to change the next_time of an every job in-flight:
+
+```ruby
+scheduler.every '10m' do |job|
+
+  # ...
+
+  status = determine_pie_status
+
+  job.next_time = Time.now + 30 * 60 if status == 'burnt'
+    #
+    # if burnt, wait 30 minutes for the oven to cool a bit
+end
+```
+
+It should work as well with cron jobs, not so with interval jobs whose next_time is computed after their block ends its current run.
+
 ### scheduling handler instances
 
 It's OK to pass any object, as long as it respond to #call(), when scheduling:
@@ -591,7 +613,6 @@ job.callable
   # => #<MyHandler:0x0000000163ae88 @counter=0>
 ```
 
-
 ### scheduled_at
 
 Returns the Time instance when the job got created.
@@ -613,6 +634,12 @@ job.scheduled_at
   # => 2013-07-17 23:48:54 +0900
 ```
 
+### last_work_time, mean_work_time
+
+The job keeps track of how long its work was in the `last_work_time` attribute. For a one time job (in, at) it's probably not very useful.
+
+The attribute `mean_work_time` contains a computed mean work time. It's recomputed after every run (if it's a repeat job).
+
 ### unschedule
 
 Unschedule the job, preventing it from firing again and removing it from the schedule. This doesn't prevent a running thread for this job to run until its end.
@@ -753,6 +780,10 @@ An alias to time.
 
 Returns the next time the job will trigger (hopefully).
 
+### count
+
+Returns how many times the job fired.
+
 ## EveryJob methods
 
 ### frequency
@@ -878,6 +909,16 @@ Kills all the job (threads) and then shuts the scheduler down. Radical.
 
 Returns true if the scheduler has been shut down.
 
+### Scheduler#started_at
+
+Returns the Time instance at which the scheduler got started.
+
+### Scheduler #uptime / #uptime_s
+
+Returns since the count of seconds for which the scheduler has been running.
+
+```#uptime_s``` returns this count in a String easier to grasp for humans, like ```"3d12m45s123"```.
+
 ### Scheduler#join
 
 Let's the current thread join the scheduling thread in rufus-scheduler. The thread comes back when the scheduler gets shut down.
@@ -900,6 +941,16 @@ Note that the main schedule thread will be returned if it is currently running a
 
 Returns true if the arg is a currently scheduled job (see Job#scheduled?).
 
+### Scheduler#occurrences(time0, time1)
+
+Returns a hash ```{ job => [ t0, t1, ... ] }``` mapping jobs to their potential trigger time within the ```[ time0, time1 ]``` span.
+
+Please note that, for interval jobs, the ```#mean_work_time``` is used, so the result is only a prediction.
+
+### Scheduler#timeline(time0, time1)
+
+Like `#occurrences` but returns a list ```[ [ t0, job0 ], [ t1, job1 ], ... ]``` of time + job pairs.
+
 
 ## dealing with job errors
 
@@ -1044,7 +1095,7 @@ If the lockfile mechanism here is not sufficient, you can plug your custom mecha
 
 ### :max_work_threads
 
-In rufus-scheduler 2.x, by default, each job triggering received its own, new, hthread of execution. In rufus-scheduler 3.x, execution happens in a work thread and the max work thread count defaults to 28.
+In rufus-scheduler 2.x, by default, each job triggering received its own, brand new, thread of execution. In rufus-scheduler 3.x, execution happens in a pooled work thread. The max work thread count (the pool size) defaults to 28.
 
 One can set this maximum value when starting the scheduler.
 
@@ -1262,6 +1313,57 @@ Unknown timezones, typos, will be rejected by tzinfo thus rufus-scheduler.
 On its own tzinfo derives the timezones from the system's information. On some system it needs some help, one can install the 'tzinfo-data' gem to provide the missing information.
 
 
+## so Rails?
+
+Yes, I know, all of the above is boring and you're only looking for a snippet to paste in your Ruby-on-Rails application to schedule...
+
+Here is an example initializer:
+
+```ruby
+#
+# config/initializers/scheduler.rb
+
+require 'rufus-scheduler'
+
+# Let's use the rufus-scheduler singleton
+#
+s = Rufus::Scheduler.singleton
+
+
+# Stupid recurrent task...
+#
+s.every '1m' do
+
+  Rails.logger.info "hello, it's #{Time.now}"
+end
+```
+
+And now you tell me that this is good, but you want to schedule stuff from your controller.
+
+Maybe:
+
+```ruby
+class ScheController < ApplicationController
+
+  # GET /sche/
+  #
+  def index
+
+    job_id =
+      Rufus::Scheduler.singleton.in '5s' do
+        Rails.logger.info "time flies, it's now #{Time.now}"
+      end
+
+    render :text => "scheduled job #{job_id}"
+  end
+end
+```
+
+The rufus-scheduler singleton is instantiated in the ```config/initializers/scheduler.rb``` file, it's then available throughout the webapp via ```Rufus::Scheduler.singleton```.
+
+*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.
+
+
 ## support
 
 see [getting help](#getting-help) above.

data/Rakefile

@@ -3,7 +3,6 @@ require 'rubygems'
 
 require 'rake'
 require 'rake/clean'
-#require 'rake/rdoctask'
 require 'rdoc/task'
 
 

data/lib/rufus/scheduler.rb

@@ -38,7 +38,7 @@ module Rufus
     require 'rufus/scheduler/cronline'
     require 'rufus/scheduler/job_array'
 
-    VERSION = '3.0.6'
+    VERSION = '3.0.7'
 
     #
     # A common error class for rufus-scheduler
@@ -370,13 +370,39 @@ module Rufus
       jobs(opts.merge(:running => true))
     end
 
+    def occurrences(time0, time1, format=:per_job)
+
+      h = {}
+
+      jobs.each do |j|
+        os = j.occurrences(time0, time1)
+        h[j] = os if os.any?
+      end
+
+      if format == :timeline
+        a = []
+        h.each { |j, ts| ts.each { |t| a << [ t, j ] } }
+        a.sort_by { |(t, j)| t }
+      else
+        h
+      end
+    end
+
+    def timeline(time0, time1)
+
+      occurrences(time0, time1, :timeline)
+    end
+
     def on_error(job, err)
 
       pre = err.object_id.to_s
 
+      ms = {}; mutexes.each { |k, v| ms[k] = v.locked? }
+
       stderr.puts("{ #{pre} rufus-scheduler intercepted an error:")
       stderr.puts("  #{pre}   job:")
       stderr.puts("  #{pre}     #{job.class} #{job.original.inspect} #{job.opts.inspect}")
+      # TODO: eventually use a Job#detail or something like that
       stderr.puts("  #{pre}   error:")
       stderr.puts("  #{pre}     #{err.object_id}")
       stderr.puts("  #{pre}     #{err.class}")
@@ -384,6 +410,33 @@ module Rufus
       err.backtrace.each do |l|
         stderr.puts("  #{pre}       #{l}")
       end
+      stderr.puts("  #{pre}   tz:")
+      stderr.puts("  #{pre}     ENV['TZ']: #{ENV['TZ']}")
+      stderr.puts("  #{pre}     Time.now: #{Time.now}")
+      stderr.puts("  #{pre}   scheduler:")
+      stderr.puts("  #{pre}     object_id: #{object_id}")
+      stderr.puts("  #{pre}     opts:")
+      stderr.puts("  #{pre}       #{@opts.inspect}")
+      stderr.puts("  #{pre}       frequency: #{self.frequency}")
+      stderr.puts("  #{pre}       lockfile: #{@lockfile.inspect}")
+      stderr.puts("  #{pre}     uptime: #{uptime} (#{uptime_s})")
+      stderr.puts("  #{pre}     down?: #{down?}")
+      stderr.puts("  #{pre}     threads: #{self.threads.size}")
+      stderr.puts("  #{pre}       thread: #{self.thread}")
+      stderr.puts("  #{pre}       thread_key: #{self.thread_key}")
+      stderr.puts("  #{pre}       work_threads: #{work_threads.size}")
+      stderr.puts("  #{pre}         active: #{work_threads(:active).size}")
+      stderr.puts("  #{pre}         vacant: #{work_threads(:vacant).size}")
+      stderr.puts("  #{pre}         max_work_threads: #{max_work_threads}")
+      stderr.puts("  #{pre}       mutexes: #{ms.inspect}")
+      stderr.puts("  #{pre}     jobs: #{jobs.size}")
+      stderr.puts("  #{pre}       at_jobs: #{at_jobs.size}")
+      stderr.puts("  #{pre}       in_jobs: #{in_jobs.size}")
+      stderr.puts("  #{pre}       every_jobs: #{every_jobs.size}")
+      stderr.puts("  #{pre}       interval_jobs: #{interval_jobs.size}")
+      stderr.puts("  #{pre}       cron_jobs: #{cron_jobs.size}")
+      stderr.puts("  #{pre}     running_jobs: #{running_jobs.size}")
+      stderr.puts("  #{pre}     work_queue: #{work_queue.size}")
       stderr.puts("} #{pre} .")
 
     rescue => e

data/lib/rufus/scheduler/cronline.rb

@@ -130,7 +130,10 @@ class Rufus::Scheduler
 
       loop do
         unless date_match?(time)
-          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec; next
+          dst = time.isdst
+          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
+          time -= 3600 if time.isdst != dst # not necessary for winter, but...
+          next
         end
         unless sub_match?(time, :hour, @hours)
           time += (60 - time.min) * 60 - time.sec; next

data/lib/rufus/scheduler/jobs.rb

@@ -45,6 +45,9 @@ module Rufus
       attr_reader :last_time
       attr_reader :unscheduled_at
       attr_reader :tags
+      attr_reader :count
+      attr_reader :last_work_time
+      attr_reader :mean_work_time
 
       # next trigger time
       #
@@ -96,6 +99,10 @@ module Rufus
 
         @tags = Array(opts[:tag] || opts[:tags]).collect { |t| t.to_s }
 
+        @count = 0
+        @last_work_time = 0.0
+        @mean_work_time = 0.0
+
         # tidy up options
 
         if @opts[:allow_overlap] == false || @opts[:allow_overlapping] == false
@@ -120,6 +127,8 @@ module Rufus
 
         return if r == false
 
+        @count += 1
+
         if opts[:blocking]
           do_trigger(time)
         else
@@ -249,6 +258,11 @@ module Rufus
 
       ensure
 
+        @last_work_time =
+          Time.now - Thread.current[:rufus_scheduler_time]
+        @mean_work_time =
+          ((@count - 1) * @mean_work_time + @last_work_time) / @count
+
         post_trigger(time)
 
         Thread.current[:rufus_scheduler_job] = nil
@@ -323,6 +337,11 @@ module Rufus
 
       alias time next_time
 
+      def occurrences(time0, time1)
+
+        time >= time0 && time <= time1 ? [ time ] : []
+      end
+
       protected
 
       def determine_id
@@ -428,7 +447,7 @@ module Rufus
 
         super
 
-        @times = @times - 1 if @times
+        @times -= 1 if @times
       end
 
       def pause
@@ -454,6 +473,27 @@ module Rufus
           opts.hash.abs
         ].map(&:to_s).join('_')
       end
+
+      def occurrences(time0, time1)
+
+        a = []
+
+        nt = @next_time
+        ts = @times
+
+        loop do
+
+          break if nt > time1
+          break if ts && ts <= 0
+
+          a << nt if nt >= time0
+
+          nt = next_time_from(nt)
+          ts = ts - 1 if ts
+        end
+
+        a
+      end
     end
 
     #
@@ -502,6 +542,11 @@ module Rufus
             @first_at
           end
       end
+
+      def next_time_from(time)
+
+        time + @frequency
+      end
     end
 
     class IntervalJob < EvInJob
@@ -539,6 +584,11 @@ module Rufus
             false
           end
       end
+
+      def next_time_from(time)
+
+        time + @mean_work_time + @interval
+      end
     end
 
     class CronJob < RepeatJob
@@ -567,6 +617,11 @@ module Rufus
 
         @next_time = @cron_line.next_time
       end
+
+      def next_time_from(time)
+
+        @cron_line.next_time(time)
+      end
     end
   end
 end

data/spec/cronline_spec.rb

@@ -116,6 +116,13 @@ describe Rufus::Scheduler::CronLine do
         [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
     end
 
+    it 'rejects / for days (every other wednesday)' do
+
+      lambda {
+        Rufus::Scheduler::CronLine.new('* * * * wed/2')
+      }.should raise_error(ArgumentError)
+    end
+
     it 'does not support ranges for monthdays (sun#1-sun#2)' do
 
       lambda {
@@ -476,5 +483,94 @@ describe Rufus::Scheduler::CronLine do
         # takes > 20s ...
     end
   end
+
+  context 'summer time' do
+
+    # let's assume summer time jumps always occur on sundays
+
+    # cf gh-114
+    #
+    it 'schedules correctly through a switch into summer time' do
+
+      #j = `zdump -v Europe/Berlin | grep "Sun Mar" | grep 2014`.split("\n")[0]
+      #j = j.match(/^.+ (Sun Mar .+ UTC) /)[1]
+        # only works on system that have a zdump...
+
+      in_zone 'Europe/Berlin' do
+
+        # find the summer jump
+
+        j = Time.parse('2014-02-28 12:00')
+        loop do
+          jj = j + 24 * 3600
+          break if jj.isdst
+          j = jj
+        end
+
+        # test
+
+        friday = j - 24 * 3600 # one day before
+
+        # verify the playground...
+        #
+        friday.isdst.should == false
+        (friday + 24 * 3600 * 3).isdst.should == true
+
+        cl0 = Rufus::Scheduler::CronLine.new('02 00 * * 1,2,3,4,5')
+        cl1 = Rufus::Scheduler::CronLine.new('45 08 * * 1,2,3,4,5')
+
+        n0 = cl0.next_time(friday)
+        n1 = cl1.next_time(friday)
+
+        n0.strftime('%H:%M:%S %^a').should == '00:02:00 MON'
+        n1.strftime('%H:%M:%S %^a').should == '08:45:00 MON'
+
+        n0.isdst.should == true
+        n1.isdst.should == true
+
+        (n0 - 24 * 3600 * 3).strftime('%H:%M:%S %^a').should == '23:02:00 THU'
+        (n1 - 24 * 3600 * 3).strftime('%H:%M:%S %^a').should == '07:45:00 FRI'
+      end
+    end
+
+    it 'schedules correctly through a switch out of summer time' do
+
+      in_zone 'Europe/Berlin' do
+
+        # find the winter jump
+
+        j = Time.parse('2014-08-31 12:00')
+        loop do
+          jj = j + 24 * 3600
+          break if jj.isdst == false
+          j = jj
+        end
+
+        # test
+
+        friday = j - 24 * 3600 # one day before
+
+        # verify the playground...
+        #
+        friday.isdst.should == true
+        (friday + 24 * 3600 * 3).isdst.should == false
+
+        cl0 = Rufus::Scheduler::CronLine.new('02 00 * * 1,2,3,4,5')
+        cl1 = Rufus::Scheduler::CronLine.new('45 08 * * 1,2,3,4,5')
+
+        n0 = cl0.next_time(friday)
+        n1 = cl1.next_time(friday)
+
+        n0.strftime('%H:%M:%S %^a').should == '00:02:00 MON'
+        n1.strftime('%H:%M:%S %^a').should == '08:45:00 MON'
+
+        n0.isdst.should == false
+        n1.isdst.should == false
+
+        (n0 - 24 * 3600 * 3).strftime('%H:%M:%S %^a').should == '01:02:00 FRI'
+        (n1 - 24 * 3600 * 3).strftime('%H:%M:%S %^a').should == '09:45:00 FRI'
+      end
+    end
+  end
 end
 

data/spec/error_spec.rb

@@ -91,6 +91,29 @@ describe Rufus::Scheduler do
     end
   end
 
+  context 'error information' do
+
+    it 'contains information about the error, the job and the scheduler' do
+
+      @scheduler.stderr = StringIO.new
+
+      @scheduler.in('0s') do
+        fail 'miserably'
+      end
+
+      sleep 0.5
+
+      s = @scheduler.stderr.string
+      #puts s
+
+      s.should match(/ENV\['TZ'\]:/)
+      s.should match(/down\?: false/)
+      s.should match(/work_threads: 1/)
+      s.should match(/running_jobs: 1/)
+      s.should match(/uptime: \d/)
+    end
+  end
+
   context 'Rufus::Scheduler#on_error(&block)' do
 
     it 'intercepts all StandardError instances' do

data/spec/job_every_spec.rb

@@ -30,6 +30,25 @@ describe Rufus::Scheduler::EveryJob do
     [ 2, 3 ].should include(counter)
   end
 
+  it 'lets its @next_time change in-flight' do
+
+    times = []
+
+    @scheduler.every '1s' do |job|
+      times << Time.now
+      job.next_time = Time.now + 3 if times.count == 2
+    end
+
+    sleep 0.3 while times.count < 3
+
+    #p [ times[1] - times[0], times[2] - times[1] ]
+
+    (times[1] - times[0]).should > 1.0
+    (times[1] - times[0]).should < 1.4
+    (times[2] - times[1]).should > 3.0
+    (times[2] - times[1]).should < 3.4
+  end
+
   context 'first_at/in' do
 
     it 'triggers for the first time at first_at' do

data/spec/job_repeat_spec.rb

@@ -332,5 +332,24 @@ describe Rufus::Scheduler::RepeatJob do
       job.last_at.strftime('%c').should == 'Thu Dec 12 12:00:30 2030'
     end
   end
+
+  describe '#count' do
+
+    it 'starts at 0' do
+
+      job = @scheduler.schedule_every '5m' do; end
+
+      job.count.should == 0
+    end
+
+    it 'keeps track of how many times the job fired' do
+
+      job = @scheduler.schedule_every '0.5s' do; end
+
+      sleep(2.0)
+
+      job.count.should == 3
+    end
+  end
 end
 

data/spec/job_spec.rb

@@ -574,5 +574,58 @@ describe Rufus::Scheduler::Job do
       counter.should > 1
     end
   end
+
+  context 'work time' do
+
+    describe '#last_work_time' do
+
+      it 'starts at 0' do
+
+        job = @scheduler.schedule_every '5m' do; end
+
+        job.last_work_time.should == 0.0
+      end
+
+      it 'keeps track of how long the work was upon last trigger' do
+
+        job =
+          @scheduler.schedule_in '0.5s'  do
+            sleep 0.7
+          end
+
+        sleep 2
+
+        job.last_work_time.should >= 0.7
+        job.last_work_time.should < 0.8
+      end
+    end
+
+    describe '#mean_work_time' do
+
+      it 'starts at 0' do
+
+        job = @scheduler.schedule_every '5m' do; end
+
+        job.mean_work_time.should == 0.0
+      end
+
+      it 'gathers work times and computes the mean' do
+
+        job =
+          @scheduler.schedule_every '0.5s' do |j|
+            #p j.last_work_time
+            #p j.mean_work_time
+            sleep 0.01 * (j.count + 1)
+          end
+
+        sleep 4.6
+
+        job.last_work_time.should >= 0.08
+        job.last_work_time.should < 0.099
+        job.mean_work_time.should > 0.05
+        job.mean_work_time.should < 0.06
+      end
+    end
+  end
 end
 

data/spec/scheduler_spec.rb

@@ -23,9 +23,14 @@ describe Rufus::Scheduler do
       t[:rufus_scheduler].should == scheduler
     end
 
-    it 'sets a :rufus_scheduler thread local var' do
+    it 'sets :name and :rufus_scheduler in the scheduler thread local vars' do
 
       scheduler = Rufus::Scheduler.new
+
+      scheduler.thread[:name].should ==
+        "rufus_scheduler_#{scheduler.object_id}_scheduler"
+      scheduler.thread[:rufus_scheduler].should ==
+        scheduler
     end
 
     it 'accepts a :frequency => integer option' do
@@ -544,6 +549,76 @@ describe Rufus::Scheduler do
     end
   end
 
+  describe '#occurrences(time0, time1)' do
+
+    it 'returns a { job => [ times ] } of job occurrences' do
+
+      j0 = @scheduler.schedule_in '7m' do; end
+      j1 = @scheduler.schedule_at '10m' do; end
+      j2 = @scheduler.schedule_every '5m' do; end
+      j3 = @scheduler.schedule_interval '5m' do; end
+      j4 = @scheduler.schedule_cron '* * * * *' do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 11 * 60)
+
+      h.size.should == 5
+      h[j0].should == [ j0.next_time ]
+      h[j1].should == [ j1.next_time ]
+      h[j2].size.should == 2
+      h[j3].size.should == 2
+      h[j4].size.should == 7
+    end
+
+    it 'returns a [ [ time, job ], ... ] of job occurrences when :timeline' do
+
+      j0 = @scheduler.schedule_in '5m' do; end
+      j1 = @scheduler.schedule_in '10m' do; end
+
+      a =
+        @scheduler.occurrences(Time.now + 4 * 60, Time.now + 11 * 60, :timeline)
+
+      a[0][0].should be_within_1s_of(Time.now + 5 * 60)
+      a[0][1].should == j0
+      a[1][0].should be_within_1s_of(Time.now + 10 * 60)
+      a[1][1].should == j1
+    end
+
+    it 'respects :first_at for repeat jobs' do
+
+      j0 = @scheduler.schedule_every '5m', :first_in => '10m' do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 16 * 60)
+
+      h[j0][0].should be_within_1s_of(Time.now + 10 * 60)
+      h[j0][1].should be_within_1s_of(Time.now + 15 * 60)
+    end
+
+    it 'respects :times for repeat jobs' do
+
+      j0 = @scheduler.schedule_every '1m', :times => 10 do; end
+
+      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 16 * 60)
+
+      h[j0].size.should == 6
+    end
+  end
+
+  describe '#timeline(time0, time1)' do
+
+    it 'returns a [ [ time, job ], ... ] of job occurrences' do
+
+      j0 = @scheduler.schedule_in '5m' do; end
+      j1 = @scheduler.schedule_in '10m' do; end
+
+      a = @scheduler.timeline(Time.now + 4 * 60, Time.now + 11 * 60)
+
+      a[0][0].should be_within_1s_of(Time.now + 5 * 60)
+      a[0][1].should == j0
+      a[1][0].should be_within_1s_of(Time.now + 10 * 60)
+      a[1][1].should == j1
+    end
+  end
+
   #--
   # management methods
   #++

data/spec/spec_helper.rb

@@ -35,6 +35,18 @@ def sleep_until_next_second
   while Time.now.sec == sec; sleep 0.2; end
 end
 
+def in_zone(zone_name, &block)
+
+  prev_tz = ENV['TZ']
+  ENV['TZ'] = zone_name
+
+  block.call
+
+ensure
+
+  ENV['TZ'] = prev_tz
+end
+
 
 #require 'rspec/expectations'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rufus-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-13 00:00:00.000000000 Z
+date: 2014-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo
@@ -98,13 +98,12 @@ files:
 - CHANGELOG.txt
 - TODO.txt
 - LICENSE.txt
-- out.txt
 - CREDITS.txt
 - README.md
 homepage: http://github.com/jmettraux/rufus-scheduler
 licenses:
 - MIT
-post_install_message: ! "\n***\n\nThanks for installing rufus-scheduler 3.0.6\n\nIt
+post_install_message: ! "\n***\n\nThanks for installing rufus-scheduler 3.0.7\n\nIt
   might not be 100% compatible with rufus-scheduler 2.x.\n\nIf you encounter issues
   with this new rufus-scheduler, especially\nif your app worked fine with previous
   versions of it, you can\n\nA) Forget it and peg your Gemfile to rufus-scheduler
@@ -120,12 +119,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1141686396098710527
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1141686396098710527
 requirements: []
 rubyforge_project: rufus
 rubygems_version: 1.8.23

data/out.txt

@@ -1,12 +0,0 @@
-4408
-:hello
-:hello
-:hello
-/home/jmettraux/w/rufus-scheduler/lib/rufus/scheduler/job_array.rb:74:in `synchronize': can't be called from trap context (ThreadError)
-	from /home/jmettraux/w/rufus-scheduler/lib/rufus/scheduler/job_array.rb:74:in `to_a'
-	from /home/jmettraux/w/rufus-scheduler/lib/rufus/scheduler.rb:276:in `jobs'
-	from /home/jmettraux/w/rufus-scheduler/lib/rufus/scheduler.rb:127:in `shutdown'
-	from t.rb:8:in `block in <main>'
-	from t.rb:18:in `call'
-	from t.rb:18:in `sleep'
-	from t.rb:18:in `<main>'