rufus-scheduler 3.1.1 → 3.2.0

data/CHANGELOG.txt

@@ -2,6 +2,63 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.2.0    released 2015-12-28
+
+- cache CronLine#brute_frequency results, gh-188 and gh-89
+- "every" shift prevention by https://github.com/Korrigan
+- Ruby warnings silenced by https://github.com/vivitar
+
+
+== rufus-scheduler - 3.1.10    released 2015-11-18
+
+- allow for :first_in => 0, gh-179 by https://github.com/JonMcPherson
+  for https://github.com/Shopify/dashing/commit/ea3730fa4
+- stop shipping specs in gem
+
+
+== 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

data/CREDITS.txt

@@ -4,6 +4,16 @@
 
 == Contributors
 
+- Balasankar C (https://github.com/balasankarc) fix CronJob spec vs December
+- Matthieu Rosinski (https://github.com/Korrigan) prevent "every" shifts
+- vivitar (https://github.com/vivitar) silenced a set of Ruby warnings
+- Jon McPherson (https://github.com/JonMcPherson) :first_in => 0 back
+- 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
@@ -36,6 +46,11 @@
 
 == Feedback
 
+- Eduardo Maia - https://github.com/emaiax - rufus and the Rails console
+- 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)```
@@ -123,7 +123,8 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 * [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)
+* [The scheduler comes up when running the Rails console](https://github.com/jmettraux/rufus-scheduler#avoid-scheduling-when-running-the-ruby-on-rails-console)
+* [I don't get any of this, I just want it to work in my Rails application](#so-rails)
 
 
 ## scheduling
@@ -1399,6 +1400,7 @@ s = Rufus::Scheduler.singleton
 s.every '1m' do
 
   Rails.logger.info "hello, it's #{Time.now}"
+  Rails.logger.flush
 end
 ```
 
@@ -1427,6 +1429,49 @@ 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.
 
+### avoid scheduling when running the Ruby on Rails console
+
+(Written in reply to https://github.com/jmettraux/rufus-scheduler/issues/186 )
+
+If you don't want rufus-scheduler to kick in when running the Ruby on Rails console, you can wrap your initializer in a conditional:
+
+```ruby
+#
+# config/initializers/scheduler.rb
+
+require 'rufus-scheduler'
+
+s = Rufus::Scheduler.singleton
+
+
+unless defined?(Rails::Console)
+  # only schedule when not running from the Rails on Rails console
+
+  s.every '1m' do
+
+    Rails.logger.info "hello, it's #{Time.now}"
+    Rails.logger.flush
+  end
+end
+```
+
+It should work for Ruby on Rails 3 and 4.
+
+### 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

@@ -42,13 +42,13 @@ class Rufus::Scheduler
     attr_reader :hours
     attr_reader :days
     attr_reader :months
+    #attr_reader :monthdays # reader defined below
     attr_reader :weekdays
-    attr_reader :monthdays
     attr_reader :timezone
 
     def initialize(line)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "not a string: #{line.inspect}"
       ) unless line.is_a?(String)
 
@@ -58,7 +58,7 @@ class Rufus::Scheduler
 
       @timezone = items.pop if ZoTime.is_timezone?(items.last)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "not a valid cronline : '#{line}'"
       ) unless items.length == 5 or items.length == 6
 
@@ -73,7 +73,7 @@ class Rufus::Scheduler
 
       [ @seconds, @minutes, @hours, @months ].each do |es|
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "invalid cronline: '#{line}'"
         ) if es && es.find { |e| ! e.is_a?(Fixnum) }
       end
@@ -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,18 +215,18 @@ 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
 
+    # Caching facility. Currently only used for brute frequencies.
+    #
+    @cache = {}; class << self; attr_reader :cache; end
+
     # Returns the shortest delta between two potential occurences of the
     # schedule described by this cronline.
     #
@@ -256,16 +243,13 @@ class Rufus::Scheduler
     # Of course, this method can get VERY slow if you call on it a second-
     # based cronline...
     #
-    # Since it's a rarely used method, I haven't taken the time to make it
-    # smarter/faster.
-    #
-    # One obvious improvement would be to cache the result once computed...
-    #
-    # See https://github.com/jmettraux/rufus-scheduler/issues/89
-    # for a discussion about this method.
-    #
     def brute_frequency
 
+      key = "brute_frequency:#{@original}"
+
+      delta = self.class.cache[key]
+      return delta if delta
+
       delta = 366 * DAY_S
 
       t0 = previous_time(Time.local(2000, 1, 1))
@@ -285,16 +269,14 @@ class Rufus::Scheduler
         t0 = t1
       end
 
-      delta
+      self.class.cache[key] = 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 +285,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
@@ -327,7 +328,7 @@ class Rufus::Scheduler
 
         if m = it.match(/^(.+)#(l|-?[12345])$/)
 
-          raise ArgumentError.new(
+          fail ArgumentError.new(
             "ranges are not supported for monthdays (#{it})"
           ) if m[1].index('-')
 
@@ -340,7 +341,7 @@ class Rufus::Scheduler
           expr = it.dup
           WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
 
-          raise ArgumentError.new(
+          fail ArgumentError.new(
             "invalid weekday expression (#{it})"
           ) if expr !~ /^0*[0-7](-0*[0-7])?$/
 
@@ -351,7 +352,7 @@ class Rufus::Scheduler
         end
       end
 
-      weekdays = weekdays.uniq if weekdays
+      weekdays = weekdays.uniq.sort if weekdays
 
       [ weekdays, monthdays ]
     end
@@ -362,10 +363,12 @@ class Rufus::Scheduler
 
       r = item.split(',').map { |i| parse_range(i.strip, min, max) }.flatten
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "found duplicates in #{item.inspect}"
       ) if r.uniq.size < r.size
 
+      r = sc_sort(r)
+
       Set.new(r)
     end
 
@@ -375,11 +378,11 @@ class Rufus::Scheduler
 
       return %w[ L ] if item == 'L'
 
-      item = '*' + item if item.match(/^\//)
+      item = '*' + item if item[0, 1] == '/'
 
       m = item.match(RANGE_REGEX)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "cannot parse #{item.inspect}"
       ) unless m
 
@@ -393,7 +396,7 @@ class Rufus::Scheduler
       inc = m[3]
       inc = inc ? inc.to_i : 1
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "#{item.inspect} is not in range #{min}..#{max}"
       ) if sta < min || edn > max
 

data/lib/rufus/scheduler/jobs.rb

@@ -91,7 +91,7 @@ module Rufus
 
         @id = determine_id
 
-        raise(
+        fail(
           ArgumentError,
           'missing block or callable to schedule',
           caller[2..-1]
@@ -235,7 +235,7 @@ module Rufus
 
       rescue StandardError => se
 
-        raise se unless do_rescue
+        fail se unless do_rescue
 
         return if se.is_a?(KillSignal) # discard
 
@@ -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
 
@@ -391,7 +391,7 @@ module Rufus
       attr_reader :paused_at
 
       attr_reader :first_at
-      attr_accessor :last_at
+      attr_reader :last_at
       attr_accessor :times
 
       def initialize(scheduler, duration, opts, block)
@@ -402,7 +402,7 @@ module Rufus
 
         @times = opts[:times]
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot accept :times => #{@times.inspect}, not nil or an int"
         ) unless @times == nil || @times.is_a?(Fixnum)
 
@@ -416,27 +416,34 @@ module Rufus
 
       def first_at=(first)
 
-        return @first_at = nil if first == nil
+        return (@first_at = nil) if first == nil
 
-        n = Time.now
-        first = n + 0.003 if first == :now || first == :immediately
+        n0 = Time.now
+        n1 = n0 + 0.003
+
+        first = n0 if first == :now || first == :immediately || first == 0
 
         @first_at = Rufus::Scheduler.parse_to_time(first)
+        @first_at = n1 if @first_at >= n0 && @first_at < n1
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot set first[_at|_in] in the past: " +
           "#{first.inspect} -> #{@first_at.inspect}"
-        ) if first != 0 && @first_at < n
+        ) if @first_at < n0
+
+        @first_at
       end
 
       def last_at=(last)
 
         @last_at = last ? Rufus::Scheduler.parse_to_time(last) : nil
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot set last[_at|_in] in the past: " +
           "#{last.inspect} -> #{@last_at.inspect}"
         ) if last && @last_at < Time.now
+
+        @last_at
       end
 
       def trigger(time)
@@ -473,7 +480,7 @@ module Rufus
         [
           self.class.name.split(':').last.downcase[0..-4],
           @scheduled_at.to_f,
-          opts.hash.abs
+          self.hash.abs
         ].map(&:to_s).join('_')
       end
 
@@ -522,7 +529,7 @@ module Rufus
 
         @frequency = Rufus::Scheduler.parse_in(@original)
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot schedule #{self.class} with a frequency " +
           "of #{@frequency.inspect} (#{@original.inspect})"
         ) if @frequency <= 0
@@ -536,9 +543,12 @@ module Rufus
 
         return if is_post
 
+        n = Time.now
+
         @next_time =
-          if @first_at == nil || @first_at < Time.now
-            (trigger_time || Time.now) + @frequency
+          if @first_at == nil || @first_at < n
+            nt = (@next_time || trigger_time || n) + @frequency
+            nt > n ? nt : (trigger_time || n) + @frequency
           else
             @first_at
           end
@@ -560,7 +570,7 @@ module Rufus
 
         @interval = Rufus::Scheduler.parse_in(@original)
 
-        raise ArgumentError.new(
+        fail ArgumentError.new(
           "cannot schedule #{self.class} with an interval " +
           "of #{@interval.inspect} (#{@original.inspect})"
         ) if @interval <= 0
@@ -621,7 +631,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/util.rb

@@ -38,7 +38,7 @@ module Rufus
       parse_cron(o, opts) ||
       parse_in(o, opts) || # covers 'every' schedule strings
       parse_at(o, opts) ||
-      raise(ArgumentError.new("couldn't parse \"#{o}\""))
+      fail(ArgumentError.new("couldn't parse \"#{o}\""))
     end
 
     def self.parse_in(o, opts={})
@@ -53,7 +53,7 @@ module Rufus
     rescue StandardError => se
 
       return nil if opts[:no_error]
-      raise se
+      fail se
     end
 
     def self.parse_cron(o, opts)
@@ -63,7 +63,7 @@ module Rufus
     rescue ArgumentError => ae
 
       return nil if opts[:no_error]
-      raise ae
+      fail ae
     end
 
     def self.parse_to_time(o)
@@ -72,7 +72,7 @@ module Rufus
       t = parse(t) if t.is_a?(String)
       t = Time.now + t if t.is_a?(Numeric)
 
-      raise ArgumentError.new(
+      fail ArgumentError.new(
         "cannot turn #{o.inspect} to a point in time, doesn't make sense"
       ) unless t.is_a?(Time)
 
@@ -132,7 +132,7 @@ module Rufus
       m = string.match(/^(-?)([\d\.#{DURATION_LETTERS}]+)$/)
 
       return nil if m.nil? && opts[:no_error]
-      raise ArgumentError.new("cannot parse '#{string}'") if m.nil?
+      fail ArgumentError.new("cannot parse '#{string}'") if m.nil?
 
       mod = m[1] == '-' ? -1.0 : 1.0
       val = 0.0
@@ -150,9 +150,7 @@ module Rufus
         elsif opts[:no_error]
           return nil
         else
-          raise ArgumentError.new(
-            "cannot parse '#{string}' (especially '#{s}')"
-          )
+          fail ArgumentError.new("cannot parse '#{string}' (especially '#{s}')")
         end
         break unless m && m[3]
         s = m[3]

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
@@ -95,7 +101,7 @@ class Rufus::Scheduler
       begin
         DateTime.parse(str)
       rescue
-        raise ArgumentError, "no time information in #{o.inspect}"
+        fail ArgumentError, "no time information in #{o.inspect}"
       end if RUBY_VERSION < '1.9.0'
 
       zone = nil
@@ -121,17 +127,23 @@ 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' || str == 'UTC'
 
       return !! (::TZInfo::Timezone.get(str) rescue nil) if defined?(::TZInfo)
 
+      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 t.zone == 'UTC'
-      return false if str.match(/[a-z]/) && str.start_with?(t.zone)
+      return false if t.utc_offset == 0 && str.start_with?(t.zone)
         # 3 common fallbacks...
 
       return false if RUBY_PLATFORM.include?('java') && ! envtzable?(str)