rufus-scheduler 3.0.0 → 3.0.9

data/CHANGELOG.txt

@@ -2,6 +2,65 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.0.9    released 2014/08/30
+
+- fix TZ with underscores, thanks https://github.com/gnilrets
+- integrate https://github.com/ecin Lock mecha
+
+
+== rufus-scheduler - 3.0.8    released 2014/06/09
+
+- handle TZInfo errors on DST transitions, thanks https://github.com/junhanamaki
+- implement Scheduler#up?
+- let schedule and schedule_at use Chronic if present
+- let Rufus::Scheduler.parse use Chronic if present
+
+
+== 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 switch 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
+
+
+== rufus-scheduler - 3.0.5    released 2014/01/30
+
+- implement Job#call(do_rescue=false), gh-97
+- implement :first => :now for repeat jobs, gh-96
+
+
+== rufus-scheduler - 3.0.4    released 2014/01/19
+
+- make CronLine#frequency faster (to avoid 20s schedule_cron times)
+
+
+== rufus-scheduler - 3.0.3    released 2013/12/12
+
+- CronLine#previous_time fix by Yassen Bantchev (https://github.com/yassenb)
+- introduce ZookeptScheduler example in the readme
+- rename #consider_lockfile to #lock and introduce #unlock
+
+
+== rufus-scheduler - 3.0.2    released 2013/10/22
+
+- default :max_work_threads to 28
+- fix "rufus rushes to create work threads" issue, thanks Gatis Tomsons
+- introduce Rufus::Scheduler::NotRunningError, thanks Gatis Tomsons
+
+
+== rufus-scheduler - 3.0.1    released 2013/10/19
+
+- fix post_install_message, thanks Ted Pennings
+- bring back .parse_time_string and .parse_duration_string
+
+
 == rufus-scheduler - 3.0.0    released 2013/10/02
 
 - complete rewrite.
@@ -148,5 +207,9 @@
 == rufus-scheduler - 2.0.1    released 2009/05/07
 == rufus-scheduler - 2.0.0    released 2009/05/07
 
+...
+
 - initial release
 
+(was openwferu-scheduler before that)
+

data/CREDITS.txt

@@ -4,6 +4,12 @@
 
 == Contributors
 
+- Sterling Paramore (https://github.com/gnilrets) underscore TZ fix
+- ecin (https://github.com/ecin) new lock mecha
+- Adam Jonas (https://github.com/adamjonas) migrate specs to "expect"
+- Yassen Bantchev (https://github.com/yassenb) CronLine#previous_time rewrite
+- Eric Lindvall (https://github.com/eric) Zookeeper locked example
+- Ted Pennings (https://github.com/tedpennings) typo in post_install_message
 - Tobias Kraze (https://github.com/kratob) timeout vs mutex fix
 - Patrick Farrell (https://github.com/pfarrell) pointing at deprecated start_new
 - Thomas Sevestre (https://github.com/thomassevestre) :exception option
@@ -27,6 +33,15 @@
 
 == Feedback
 
+- junhanamaki - https://github.com/junhanamaki - #next_time and dst ambiguities
+- 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
+- https://github.com/joast - missing .to_time_string alias (code and doc)
+- Tamir Duberstein - https://github.com/tamird - rdoc inaccuracies
 - Kevin Bouwkamp - https://github.com/bmxpert1 - first_at issues
 - Daniel Beauchamp - https://github.com/pushmatrix - pre/post trigger callbacks
 - Arthur Maltson - https://github.com/amaltson - readme fixes
@@ -60,5 +75,6 @@
 
 == and finally
 
+- many thanks to the author and contributors of the tzinfo gem (http://tzinfo.github.io/)
 - many thanks to the EventMachine team (especially Aman Gupta)
 

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2005-2013, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2005-2014, 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

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).
 
@@ -78,7 +79,7 @@ There is no EventMachine-based scheduler anymore.
 * The scheduler isn't catching the whole of Exception anymore, only StandardError
 * The error_handler is #on_error (instead of #on_exception), by default it now prints the details of the error to $stderr (used to be $stdout)
 * Rufus::Scheduler::TimeOutError renamed to Rufus::Scheduler::TimeoutError
-* Introduction of "interval" jobs. Whereas "every" jobs are like "every 10 minuts, do this", interval jobs are like "do that, then wait for 10 minutes, then do that again, and so on"
+* Introduction of "interval" jobs. Whereas "every" jobs are like "every 10 minutes, do this", interval jobs are like "do that, then wait for 10 minutes, then do that again, and so on"
 * Introduction of a :lockfile => true/filename mechanism to prevent multiple schedulers from executing
 * "discard_past" is on by default. If the scheduler (its host) sleeps for 1 hour and a ```every '10m'``` job is on, it will trigger once at wakeup, not 6 times (discard_past was false by default in rufus-scheduler 2.x). No intention to re-introduce ```:discard_past => false``` in 3.0 for now.
 * Introduction of Scheduler #on_pre_trigger and #on_post_trigger callback points
@@ -88,6 +89,8 @@ There is no EventMachine-based scheduler anymore.
 
 So you need help. People can help you, but first help them help you, and don't waste their time. Provide a complete description of the issue. If it works on A but not on B and others have to ask you: "so what is different between A and B" you are wasting everyone's time.
 
+"hello" and "thanks" are not swear words.
+
 Go read [how to report bugs effectively](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html), twice.
 
 Update: [help_help.md](https://gist.github.com/jmettraux/310fed75f568fd731814) might help help you.
@@ -113,6 +116,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 +254,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:
@@ -366,14 +390,14 @@ end
 
 The :timeout option accepts either a duration (like "1d" or "2w3d") or a point in time (like "2013/12/12 12:00").
 
-### :first_at, :first_in, :first
+### :first_at, :first_in, :first, :first_time
 
 This option is for repeat jobs (cron / every) only.
 
 It's used to specify the first time after which the repeat job should trigger for the first time.
 
-In the case of an "every" job, this will be the first time (module the scheduler frequency) the job triggers.
-For a "cron" job, it's the time after which the first schedule will trigger.
+In the case of an "every" job, this will be the first time (modulo the scheduler frequency) the job triggers.
+For a "cron" job, it's the time *after* which the first schedule will trigger.
 
 ```ruby
 scheduler.every '2d', :first_at => Time.now + 10 * 3600 do
@@ -383,6 +407,10 @@ end
 scheduler.every '2d', :first_in => '10h' do
   # ... every two days, but start in 10 hours
 end
+
+scheduler.cron '00 14 * * *', :first_in => '3d' do
+  # ... every day at 14h00, but start after 3 * 24 hours
+end
 ```
 
 :first, :first_at and :first_in all accept a point in time or a duration (number or time string). Use the symbol you think make your schedule more readable.
@@ -393,6 +421,34 @@ job.first_at = Time.now + 10
 job.first_at = Rufus::Scheduler.parse('2029-12-12')
 ```
 
+The first argument (in all its flavours) accepts a :now or :immediately value. That schedules the first occurence for immediate triggering. Consider:
+
+```ruby
+require 'rufus-scheduler'
+
+s = Rufus::Scheduler.new
+
+n = Time.now; p [ :scheduled_at, n, n.to_f ]
+
+s.every '3s', :first => :now do
+  n = Time.now; p [ :in, n, n.to_f ]
+end
+
+s.join
+
+```
+
+that'll output something like:
+
+```
+[:scheduled_at, 2014-01-22 22:21:21 +0900, 1390396881.344438]
+[:in, 2014-01-22 22:21:21 +0900, 1390396881.6453865]
+[:in, 2014-01-22 22:21:24 +0900, 1390396884.648807]
+[:in, 2014-01-22 22:21:27 +0900, 1390396887.651686]
+[:in, 2014-01-22 22:21:30 +0900, 1390396890.6571937]
+...
+```
+
 ### :last_at, :last_in, :last
 
 This option is for repeat jobs (cron / every) only.
@@ -563,7 +619,6 @@ job.callable
   # => #<MyHandler:0x0000000163ae88 @counter=0>
 ```
 
-
 ### scheduled_at
 
 Returns the Time instance when the job got created.
@@ -585,6 +640,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.
@@ -671,6 +732,44 @@ job.keys
 
 Job-local variables are thread-safe.
 
+### call
+
+Job instances have a #call method. It simply calls the scheduled block or callable immediately.
+
+```ruby
+job =
+  @scheduler.schedule_every '10m' do |job|
+    # ...
+  end
+
+job.call
+```
+
+Warning: the Scheduler#on_error handler is not involved. Error handling is the responsibility of the caller.
+
+If the call has to be rescued by the error handler of the scheduler, ```call(true)``` might help:
+
+```ruby
+require 'rufus-scheduler'
+
+s = Rufus::Scheduler.new
+
+def s.on_error(job, err)
+  p [ 'error in scheduled job', job.class, job.original, err.message ]
+rescue
+  p $!
+end
+
+job =
+  s.schedule_in('1d') do
+    fail 'again'
+  end
+
+job.call(true)
+  #
+  # true lets the error_handler deal with error in the job call
+```
+
 ## AtJob and InJob methods
 
 ### time
@@ -687,6 +786,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
@@ -717,16 +820,22 @@ Rufus::Scheduler.parse('* * * * * *').frequency       # ==> 1
 Rufus::Scheduler.parse('5 23 * * *').frequency        # ==> 24 * 3600
 Rufus::Scheduler.parse('5 * * * *').frequency         # ==> 3600
 Rufus::Scheduler.parse('10,20,30 * * * *').frequency  # ==> 600
+
+Rufus::Scheduler.parse('10,20,30 * * * * *').frequency  # ==> 10
 ```
 
 It's used to determine if the job frequency is higher than the scheduler frequency (it raises an ArgumentError if that is the case).
 
+### brute_frequency
+
+Cron jobs also have a ```#brute_frequency``` method that looks a one year of intervals to determine the shortest delta for the cron. This method can take between 20 to 50 seconds for cron lines that go the second level. ```#frequency``` above, when encountering second level cron lines will take a shortcut to answer as quickly as possible with a usable value.
+
 
 ## looking up jobs
 
 ### Scheduler#job(job_id)
 
-The scheduler #job(job_id) method can be used to lookup Job instances.
+The scheduler ```#job(job_id)``` method can be used to lookup Job instances.
 
 ```ruby
   require 'rufus-scheduler'
@@ -802,6 +911,20 @@ Shuts down the scheduler, waits (blocks) until all the jobs cease running.
 
 Kills all the job (threads) and then shuts the scheduler down. Radical.
 
+### Scheduler#down?
+
+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.
@@ -824,6 +947,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
 
@@ -964,9 +1097,62 @@ The idea is to guarantee only one scheduler (in a group of scheduler sharing the
 
 This is useful in environments where the Ruby process holding the scheduler gets started multiple times.
 
+If the lockfile mechanism here is not sufficient, you can plug your custom mechanism. It's explained in [advanced lock schemes](#advanced-lock-schemes) below.
+
+### :scheduler_lock
+
+(since rufus-scheduler 3.0.9)
+
+The scheduler lock is an object that responds to `#lock` and `#unlock`. The scheduler calls `#lock` when starting up. If the answer is `false`, the scheduler stops its initialization work and won't schedule anything.
+
+Here is a sample of a scheduler lock that only lets the scheduler on host "coffee.example.com" start:
+```ruby
+class HostLock
+  def initialize(lock_name)
+    @lock_name = lock_name
+  end
+  def lock
+    @lock_name == `hostname -f`.strip
+  end
+  def unlock
+    true
+  end
+end
+
+scheduler =
+  Rufus::Scheduler.new(:scheduler_lock => HostLock.new('coffee.example.com'))
+```
+
+By default, the scheduler_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that returns true.
+
+### :trigger_lock
+
+(since rufus-scheduler 3.0.9)
+
+The trigger lock in an object that responds to `#lock`. The scheduler calls that method on the job lock right before triggering any job. If the answer is false, the trigger doesn't happen, the job is not done (at least not in this scheduler).
+
+Here is a (stupid) PingLock example, it'll only trigger if an "other host" is not responding to ping. Do not use that in production, you don't want to fork a ping process for each trigger attempt...
+```ruby
+class PingLock
+  def initialize(other_host)
+    @other_host = other_host
+  end
+  def lock
+    ! system("ping -c 1 #{@other_host}")
+  end
+end
+
+scheduler =
+  Rufus::Scheduler.new(:trigger_lock => PingLock.new('main.example.com'))
+```
+
+By default, the trigger_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that always returns true.
+
+As explained in [advanced lock schemes](#advanced-lock-schemes), another way to tune that behaviour is by overriding the scheduler's `#confirm_lock` method. (You could also do that with an `#on_pre_trigger` callback).
+
 ### :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 35.
+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.
 
@@ -1004,6 +1190,67 @@ Rufus::Scheduler.s.every '10s' { puts "hello, world!" }
 ```
 
 
+## advanced lock schemes
+
+As seen above, rufus-scheduler proposes the [:lockfile](#lockfile--mylockfiletxt) system out of the box. If in a group of schedulers only one is supposed to run, the lockfile mecha prevents schedulers that have not set/created the lockfile from running.
+
+There are situation where this is not sufficient.
+
+By overriding #lock and #unlock, one can customize how his schedulers lock.
+
+This example was provided by [Eric Lindvall](https://github.com/eric):
+
+```ruby
+class ZookeptScheduler < Rufus::Scheduler
+
+  def initialize(zookeeper, opts={})
+    @zk = zookeeper
+    super(opts)
+  end
+
+  def lock
+    @zk_locker = @zk.exclusive_locker('scheduler')
+    @zk_locker.lock # returns true if the lock was acquired, false else
+  end
+
+  def unlock
+    @zk_locker.unlock
+  end
+
+  def confirm_lock
+    return false if down?
+    @zk_locker.assert!
+  rescue ZK::Exceptions::LockAssertionFailedError => e
+    # we've lost the lock, shutdown (and return false to at least prevent
+    # this job from triggering
+    shutdown
+    false
+  end
+end
+```
+
+This uses a [zookeeper](http://zookeeper.apache.org/) to make sure only one scheduler in a group of distributed schedulers runs.
+
+The methods #lock and #unlock are overriden and #confirm_lock is provided,
+to make sure that the lock is still valid.
+
+The #confirm_lock method is called right before a job triggers (if it is provided). The more generic callback #on_pre_trigger is called right after #confirm_lock.
+
+### :scheduler_lock and :trigger_lock
+
+(introduced in rufus-scheduler 3.0.9).
+
+Another way of prodiving `#lock`, `#unlock` and `#confirm_lock` to a rufus-scheduler is by using the `:scheduler_lock` and `:trigger_lock` options.
+
+See [:trigger_lock](#trigger_lock) and [:scheduler_lock](#scheduler_lock).
+
+The scheduler lock may be used to prevent a scheduler from starting, while a trigger lock prevents individual jobs from triggering (the scheduler goes on scheduling).
+
+One has to be careful with what goes in `#confirm_lock` or in a trigger lock, as it gets called before each trigger.
+
+Warning: you may think you're heading towards "high availability" by using a trigger lock and having lots of schedulers at hand. It may be so if you limit yourself to scheduling the same set of jobs at scheduler startup. But if you add schedules at runtime, they stay local to their scheduler. There is no magic that propagates the jobs to all the schedulers in your pack.
+
+
 ## parsing cronlines and time strings
 
 Rufus::Scheduler provides a class method ```.parse``` to parse time durations and cron strings. It's what it's using when receiving schedules. One can use it diectly (no need to instantiate a Scheduler).
@@ -1052,6 +1299,141 @@ Rufus::Scheduler.to_duration_hash(62.127, :drop_seconds => true)
   # => { :m => 1 }
 ```
 
+### cronline notations specific to rufus-scheduler
+
+#### first Monday, last Sunday et al
+
+To schedule something at noon every first Monday of the month:
+
+```ruby
+scheduler.cron('00 12 * * mon#1') do
+  # ...
+end
+```
+
+To schedule something at noon the last Sunday of every month:
+
+```ruby
+scheduler.cron('00 12 * * sun#-1') do
+  # ...
+end
+#
+# OR
+#
+scheduler.cron('00 12 * * sun#L') do
+  # ...
+end
+```
+
+Such cronlines can be tested with scripts like:
+
+```ruby
+require 'rufus-scheduler'
+
+Time.now
+  # => 2013-10-26 07:07:08 +0900
+Rufus::Scheduler.parse('* * * * mon#1').next_time
+  # => 2013-11-04 00:00:00 +0900
+```
+
+#### L (last day of month)
+
+L can be used in the "day" slot:
+
+In this example, the cronline is supposed to trigger every last day of the month at noon:
+
+```ruby
+require 'rufus-scheduler'
+Time.now
+  # => 2013-10-26 07:22:09 +0900
+Rufus::Scheduler.parse('00 12 L * *').next_time
+  # => 2013-10-31 12:00:00 +0900
+```
+
+
+## a note about timezones
+
+Cron schedules and at schedules support the specification of a timezone.
+
+```ruby
+scheduler.cron '0 22 * * 1-5 America/Chicago' do
+  # the job...
+end
+
+scheduler.at '2013-12-12 14:00 Pacific/Samoa' do
+  puts "it's tea time!"
+end
+
+# or even
+
+Rufus::Scheduler.parse("2013-12-12 14:00 Pacific/Saipan")
+  # => 2013-12-12 04:00:00 UTC
+```
+
+Behind the scenes, rufus-scheduler uses [tzinfo](http://tzinfo.github.io/) to deal with timezones.
+
+Here is a [list of timezones](misc/tz_all.txt) known to my Debian GNU/Linux 7. It was generated with this script:
+
+```ruby
+require 'tzinfo'
+TZInfo::Timezone.all.each { |tz| puts tz.name }
+```
+
+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
 

data/Rakefile

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

data/TODO.txt

@@ -145,3 +145,7 @@
       end
     end
 
+~~~
+
+[ ] scheduler.at('chronic string', chronic_options...)
+