rufus-scheduler 3.4.2 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b2f35e030fcf0e6338856400c56ebc4ac4cc8f7
-  data.tar.gz: bf3e0d885255a7654d4dfbcb95ed3ad4ead9c0ad
+  metadata.gz: b8c6844d5f77112580ff29651a33fe2bc3b9545f
+  data.tar.gz: 329289b1d8a476270440672b4efd71d4d41e976d
 SHA512:
-  metadata.gz: a05aed4a749ec1ddff6423b732f0c3db85fd58836301b70a4a6efbc83fccab5a156f2877800d2cf7be34ec1f600342b30660fa71947322aba38e165c9490a118
-  data.tar.gz: 4ef7fa38c78541dbf72312fadbb3f3a3dc2090dcd13ed2df5390a0950ec45c757c4af0d9ed7109fe3057281deeb0c86a7b75f3e27bbb47338e72bef14528a1dd
+  metadata.gz: 8a7a056a68f73e62a54b44cbb40c3862e70b75cd92bfbe887ac39c8f72c7398798bb5062272d7d78b8aeeaf3083971276febfa36fb2e7e534b4cd9efb5b7e41a
+  data.tar.gz: a0e682b539d953cf706ee0d431dfd175994c67f8ddeeb61dc5e1d966bf5fd56e79b0c92d5f32e1abaf80fa1674a774d743cb4acc1b248125b55b000a98344d1a

data/CHANGELOG.txt

@@ -2,6 +2,13 @@
 = rufus-scheduler CHANGELOG.txt
 
 
+== rufus-scheduler - 3.5.0    released 2018-05-15
+
+- Use fugit to parse durations
+- Drop .parse_time_string and .parse_duration_string
+- Use fugit to parse cronlines
+
+
 == rufus-scheduler - 3.4.2    released 2017-05-24
 
 (had yanked 3.4.1, going 3.4.2)

data/CREDITS.txt

@@ -58,6 +58,7 @@
 
 == Feedback
 
+- Gian - https://github.com/snmgian - cron vs :first clarification - gh-266
 - Vito Laurenza - https://github.com/veetow - help debugging tz issues - gh-240
 - Yoshimi Keiji - https://githuc.com/walf443 - v.3.3.3 mislabelling
 - Alexander Deeb - https://github.com/adeeb1 - gh-230

data/Makefile

@@ -4,6 +4,10 @@ NAME = \
 VERSION = \
   $(shell ruby -e "s = eval(File.read(Dir['*.gemspec'][0])); puts s.version")
 
+count_lines:
+	find lib -name "*.rb" | xargs cat | ruby -e "p STDIN.readlines.count { |l| l = l.strip; l[0, 1] != '#' && l != '' }"
+	find spec -name "*_spec.rb" | xargs cat | ruby -e "p STDIN.readlines.count { |l| l = l.strip; l[0, 1] != '#' && l != '' }"
+cl: count_lines
 
 gemspec_validate:
 	@echo "---"

data/README.md

@@ -128,6 +128,7 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 * [Passenger in-depth spawn methods](https://www.phusionpassenger.com/library/indepth/ruby/spawn_methods/)
 * [Passenger in-depth spawn methods (smart spawning)](https://www.phusionpassenger.com/library/indepth/ruby/spawn_methods/#smart-spawning-hooks)
 * [The scheduler comes up when running the Rails console or a Rake task](https://github.com/jmettraux/rufus-scheduler#avoid-scheduling-when-running-the-ruby-on-rails-console)
+* [The job triggers twice](https://github.com/jmettraux/rufus-scheduler#lockfile--mylockfiletxt)
 * [I don't get any of this, I just want it to work in my Rails application](#so-rails)
 * [I get "zotime.rb:41:in `initialize': cannot determine timezone from nil"](#i-get-zotimerb41in-initialize-cannot-determine-timezone-from-nil)
 
@@ -376,7 +377,7 @@ Since, by default, jobs are triggered in their own new thread, job instances mig
 
 To prevent overlap, one can set :overlap => false. Such a job will not trigger if one of its instance is already running.
 
-The `:overlap` option is considered before the `:mutex` option when the scheduler is reviewing jobs for triggering.
+The `:overlap` option is considered after the `:mutex` option when the scheduler is reviewing jobs for triggering.
 
 ### :mutex => mutex_instance / mutex_name / array of mutexes
 
@@ -415,7 +416,7 @@ 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 (modulo the scheduler frequency) the job triggers.
-For a "cron" job, it's the time *after* which the first schedule will trigger.
+For a "cron" job as well, the :first will point to the first time the job has to trigger, the following trigger time are then determined by the cron string.
 
 ```ruby
 scheduler.every '2d', :first_at => Time.now + 10 * 3600 do

data/lib/rufus/scheduler.rb

@@ -4,20 +4,19 @@ require 'date' if RUBY_VERSION < '1.9.0'
 require 'time'
 require 'thread'
 
-require 'et-orbi'
+require 'fugit'
 
 
 module Rufus
 
   class Scheduler
 
-    VERSION = '3.4.2'
+    VERSION = '3.5.0'
 
     EoTime = ::EtOrbi::EoTime
 
     require 'rufus/scheduler/util'
     require 'rufus/scheduler/jobs'
-    require 'rufus/scheduler/cronline'
     require 'rufus/scheduler/job_array'
     require 'rufus/scheduler/locks'
 
@@ -238,9 +237,9 @@ module Rufus
       opts[:_t] = Scheduler.parse(arg, opts)
 
       case opts[:_t]
-        when CronLine then schedule_cron(arg, callable, opts, &block)
-        when Time then schedule_at(arg, callable, opts, &block)
-        else schedule_in(arg, callable, opts, &block)
+      when ::Fugit::Cron then schedule_cron(arg, callable, opts, &block)
+      when ::EtOrbi::EoTime, Time then schedule_at(arg, callable, opts, &block)
+      else schedule_in(arg, callable, opts, &block)
       end
     end
 
@@ -252,8 +251,8 @@ module Rufus
       opts[:_t] = Scheduler.parse(arg, opts)
 
       case opts[:_t]
-        when CronLine then schedule_cron(arg, callable, opts, &block)
-        else schedule_every(arg, callable, opts, &block)
+      when ::Fugit::Cron then schedule_cron(arg, callable, opts, &block)
+      else schedule_every(arg, callable, opts, &block)
       end
     end
 
@@ -620,10 +619,35 @@ module Rufus
 
       job = job_class.new(self, t, opts, block || callable)
 
-      fail ArgumentError.new(
-        "job frequency (#{job.frequency}) is higher than " +
-        "scheduler frequency (#{@frequency})"
-      ) if job.respond_to?(:frequency) && job.frequency < @frequency
+      #fail ArgumentError.new(
+      #  "job frequency (#{job.frequency}) is higher than " +
+      #  "scheduler frequency (#{@frequency})"
+      #) if job.respond_to?(:frequency) && job.frequency < @frequency
+        #
+        # This was expensive
+
+      if (
+        ! job.is_a?(Rufus::Scheduler::IntervalJob) &&
+        job.methods.include?(:next_time_from)
+      ) then
+
+        nts = (1..365)
+          .inject([ job.send(:next_time_from, EtOrbi.now) ]) { |a, i|
+            a << job.send(:next_time_from, a.last); a }
+        deltas = []; prev = nts.shift
+        while (nt = nts.shift); deltas << (nt - prev).to_f; prev = nt; end
+
+        deltas = deltas[1..-1] \
+          if opts.keys.find { |k| k.to_s.match(/\Afirst/) }
+            #
+            # do not consider the first delta if there is a first, first_at,
+            # or first_in involved
+
+        fail ArgumentError.new(
+          "job frequency (~max #{deltas.min}s) is higher than " +
+          "scheduler frequency (#{@frequency})"
+        ) if deltas.min < @frequency * 0.9
+      end
 
       @jobs.push(job)
 

data/lib/rufus/scheduler/jobs.rb

@@ -612,9 +612,7 @@ module Rufus
 
         super(scheduler, cronline, opts, block)
 
-        @cron_line =
-          opts[:_t] ||
-          (cronline.is_a?(CronLine) ? cronline : CronLine.new(cronline))
+        @cron_line = opts[:_t] || ::Fugit::Cron.parse(cronline)
 
         set_next_time(nil)
       end

data/lib/rufus/scheduler/util.rb

@@ -3,255 +3,190 @@ module Rufus
 
   class Scheduler
 
-    #--
-    # time and string methods
-    #++
-
-    def self.parse(o, opts={})
-
-      opts[:no_error] = true
-
-      parse_cron(o, opts) ||
-      parse_in(o, opts) || # covers 'every' schedule strings
-      parse_at(o, opts) ||
-      fail(ArgumentError.new("couldn't parse #{o.inspect} (#{o.class})"))
-    end
-
-    def self.parse_cron(o, opts)
-
-      o.is_a?(CronLine) ? o : CronLine.new(o)
-
-    rescue ArgumentError => ae
-
-      return nil if opts[:no_error]
-      fail ae
-    end
-
-    def self.parse_in(o, opts={})
-
-      #o.is_a?(String) ? parse_duration(o, opts) : o
-
-      return parse_duration(o, opts) if o.is_a?(String)
-      return o if o.is_a?(Numeric)
+    class << self
 
-      fail ArgumentError.new("couldn't parse time point in #{o.inspect}")
+      #--
+      # time and string methods
+      #++
 
-    rescue ArgumentError => ae
+      def parse(o, opts={})
 
-      return nil if opts[:no_error]
-      fail ae
-    end
+        opts[:no_error] = true
 
-    def self.parse_at(o, opts={})
+        parse_cron(o, opts) ||
+        parse_in(o, opts) || # covers 'every' schedule strings
+        parse_at(o, opts) ||
+        fail(ArgumentError.new("couldn't parse #{o.inspect} (#{o.class})"))
+      end
 
-      return o if o.is_a?(EoTime)
-      return EoTime.make(o) if o.is_a?(Time)
-      EoTime.parse(o, opts)
+      def parse_cron(o, opts)
 
-    rescue StandardError => se
+        Fugit.parse_cron(o)
+      end
 
-      return nil if opts[:no_error]
-      fail se
-    end
+      def parse_in(o, opts={})
 
-    DURATIONS2M = [
-      [ 'y', 365 * 24 * 3600 ],
-      [ 'M', 30 * 24 * 3600 ],
-      [ 'w', 7 * 24 * 3600 ],
-      [ 'd', 24 * 3600 ],
-      [ 'h', 3600 ],
-      [ 'm', 60 ],
-      [ 's', 1 ]
-    ]
-    DURATIONS2 = DURATIONS2M.dup
-    DURATIONS2.delete_at(1)
-
-    DURATIONS = DURATIONS2M.inject({}) { |r, (k, v)| r[k] = v; r }
-    DURATION_LETTERS = DURATIONS.keys.join
-
-    DU_KEYS = DURATIONS2M.collect { |k, v| k.to_sym }
-
-    # Turns a string like '1m10s' into a float like '70.0', more formally,
-    # turns a time duration expressed as a string into a Float instance
-    # (millisecond count).
-    #
-    # w -> week
-    # d -> day
-    # h -> hour
-    # m -> minute
-    # s -> second
-    # M -> month
-    # y -> year
-    # 'nada' -> millisecond
-    #
-    # Some examples:
-    #
-    #   Rufus::Scheduler.parse_duration "0.5"    # => 0.5
-    #   Rufus::Scheduler.parse_duration "500"    # => 0.5
-    #   Rufus::Scheduler.parse_duration "1000"   # => 1.0
-    #   Rufus::Scheduler.parse_duration "1h"     # => 3600.0
-    #   Rufus::Scheduler.parse_duration "1h10s"  # => 3610.0
-    #   Rufus::Scheduler.parse_duration "1w2d"   # => 777600.0
-    #
-    # Negative time strings are OK (Thanks Danny Fullerton):
-    #
-    #   Rufus::Scheduler.parse_duration "-0.5"   # => -0.5
-    #   Rufus::Scheduler.parse_duration "-1h"    # => -3600.0
-    #
-    def self.parse_duration(string, opts={})
+        #o.is_a?(String) ? parse_duration(o, opts) : o
 
-      s = string.to_s.strip
-      mod = s[0, 1] == '-' ? -1 : 1
-      s = s[1..-1] if mod == -1
+        return parse_duration(o, opts) if o.is_a?(String)
+        return o if o.is_a?(Numeric)
 
-      ss = mod < 0 ? '-' : ''
-      r = 0.0
+        fail ArgumentError.new("couldn't parse time point in #{o.inspect}")
 
-      s.scan(/(\d*\.\d+|\d+\.?)([#{DURATION_LETTERS}]?)/) do |f, d|
-        ss += "#{f}#{d}"
-        r += f.to_f * (DURATIONS[d] || 1.0)
-      end
+      rescue ArgumentError => ae
 
-      if ss == '-' || ss != string.to_s.strip
         return nil if opts[:no_error]
-        fail ArgumentError.new("invalid time duration #{string.inspect}")
+        fail ae
       end
 
-      mod * r
-    end
+      def parse_at(o, opts={})
 
-    class << self
-      #-
-      # for compatibility with rufus-scheduler 2.x
-      #+
-      alias parse_duration_string parse_duration
-      alias parse_time_string parse_duration
-    end
+        return o if o.is_a?(EoTime)
+        return EoTime.make(o) if o.is_a?(Time)
+        EoTime.parse(o, opts)
 
+      rescue StandardError => se
 
-    # Turns a number of seconds into a a time string
-    #
-    #   Rufus.to_duration 0                    # => '0s'
-    #   Rufus.to_duration 60                   # => '1m'
-    #   Rufus.to_duration 3661                 # => '1h1m1s'
-    #   Rufus.to_duration 7 * 24 * 3600        # => '1w'
-    #   Rufus.to_duration 30 * 24 * 3600 + 1   # => "4w2d1s"
-    #
-    # It goes from seconds to the year. Months are not counted (as they
-    # are of variable length). Weeks are counted.
-    #
-    # For 30 days months to be counted, the second parameter of this
-    # method can be set to true.
-    #
-    #   Rufus.to_duration 30 * 24 * 3600 + 1, true   # => "1M1s"
-    #
-    # If a Float value is passed, milliseconds will be displayed without
-    # 'marker'
-    #
-    #   Rufus.to_duration 0.051                       # => "51"
-    #   Rufus.to_duration 7.051                       # => "7s51"
-    #   Rufus.to_duration 0.120 + 30 * 24 * 3600 + 1  # => "4w2d1s120"
-    #
-    # (this behaviour mirrors the one found for parse_time_string()).
-    #
-    # Options are :
-    #
-    # * :months, if set to true, months (M) of 30 days will be taken into
-    #   account when building up the result
-    # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
-    #   from the result
-    #
-    def self.to_duration(seconds, options={})
-
-      h = to_duration_hash(seconds, options)
-
-      return (options[:drop_seconds] ? '0m' : '0s') if h.empty?
-
-      s =
-        DU_KEYS.inject('') { |r, key|
-          count = h[key]
-          count = nil if count == 0
-          r << "#{count}#{key}" if count
-          r
-        }
-
-      ms = h[:ms]
-      s << ms.to_s if ms
-
-      s
-    end
-
-    class << self
-      #-
-      # for compatibility with rufus-scheduler 2.x
-      #+
-      alias to_duration_string to_duration
-      alias to_time_string to_duration
-    end
-
-    # Turns a number of seconds (integer or Float) into a hash like in :
-    #
-    #   Rufus.to_duration_hash 0.051
-    #     # => { :ms => "51" }
-    #   Rufus.to_duration_hash 7.051
-    #     # => { :s => 7, :ms => "51" }
-    #   Rufus.to_duration_hash 0.120 + 30 * 24 * 3600 + 1
-    #     # => { :w => 4, :d => 2, :s => 1, :ms => "120" }
-    #
-    # This method is used by to_duration behind the scenes.
-    #
-    # Options are :
-    #
-    # * :months, if set to true, months (M) of 30 days will be taken into
-    #   account when building up the result
-    # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
-    #   from the result
-    #
-    def self.to_duration_hash(seconds, options={})
+        return nil if opts[:no_error]
+        fail se
+      end
 
-      h = {}
+      # Turns a string like '1m10s' into a float like '70.0', more formally,
+      # turns a time duration expressed as a string into a Float instance
+      # (millisecond count).
+      #
+      # w -> week
+      # d -> day
+      # h -> hour
+      # m -> minute
+      # s -> second
+      # M -> month
+      # y -> year
+      # 'nada' -> millisecond
+      #
+      # Some examples:
+      #
+      #   Rufus::Scheduler.parse_duration "0.5"    # => 0.5
+      #   Rufus::Scheduler.parse_duration "500"    # => 0.5
+      #   Rufus::Scheduler.parse_duration "1000"   # => 1.0
+      #   Rufus::Scheduler.parse_duration "1h"     # => 3600.0
+      #   Rufus::Scheduler.parse_duration "1h10s"  # => 3610.0
+      #   Rufus::Scheduler.parse_duration "1w2d"   # => 777600.0
+      #
+      # Negative time strings are OK (Thanks Danny Fullerton):
+      #
+      #   Rufus::Scheduler.parse_duration "-0.5"   # => -0.5
+      #   Rufus::Scheduler.parse_duration "-1h"    # => -3600.0
+      #
+      def parse_duration(str, opts={})
+
+        d =
+          opts[:no_error] ?
+          Fugit::Duration.parse(str, opts) :
+          Fugit::Duration.do_parse(str, opts)
+        d ?
+          d.to_sec :
+          nil
+      end
 
-      if seconds.is_a?(Float)
-        h[:ms] = (seconds % 1 * 1000).to_i
-        seconds = seconds.to_i
+      # Turns a number of seconds into a a time string
+      #
+      #   Rufus.to_duration 0                    # => '0s'
+      #   Rufus.to_duration 60                   # => '1m'
+      #   Rufus.to_duration 3661                 # => '1h1m1s'
+      #   Rufus.to_duration 7 * 24 * 3600        # => '1w'
+      #   Rufus.to_duration 30 * 24 * 3600 + 1   # => "4w2d1s"
+      #
+      # It goes from seconds to the year. Months are not counted (as they
+      # are of variable length). Weeks are counted.
+      #
+      # For 30 days months to be counted, the second parameter of this
+      # method can be set to true.
+      #
+      #   Rufus.to_duration 30 * 24 * 3600 + 1, true   # => "1M1s"
+      #
+      # If a Float value is passed, milliseconds will be displayed without
+      # 'marker'
+      #
+      #   Rufus.to_duration 0.051                       # => "51"
+      #   Rufus.to_duration 7.051                       # => "7s51"
+      #   Rufus.to_duration 0.120 + 30 * 24 * 3600 + 1  # => "4w2d1s120"
+      #
+      # (this behaviour mirrors the one found for parse_time_string()).
+      #
+      # Options are :
+      #
+      # * :months, if set to true, months (M) of 30 days will be taken into
+      #   account when building up the result
+      # * :drop_seconds, if set to true, seconds and milliseconds will be
+      #   trimmed from the result
+      #
+      def to_duration(seconds, options={})
+
+        #d = Fugit::Duration.parse(seconds, options).deflate
+        #d = d.drop_seconds if options[:drop_seconds]
+        #d = d.deflate(:month => options[:months]) if options[:months]
+        #d.to_rufus_s
+
+        to_fugit_duration(seconds, options).to_rufus_s
       end
 
-      if options[:drop_seconds]
-        h.delete(:ms)
-        seconds = (seconds - seconds % 60)
+      # Turns a number of seconds (integer or Float) into a hash like in :
+      #
+      #   Rufus.to_duration_hash 0.051
+      #     # => { :s => 0.051 }
+      #   Rufus.to_duration_hash 7.051
+      #     # => { :s => 7.051 }
+      #   Rufus.to_duration_hash 0.120 + 30 * 24 * 3600 + 1
+      #     # => { :w => 4, :d => 2, :s => 1.120 }
+      #
+      # This method is used by to_duration behind the scenes.
+      #
+      # Options are :
+      #
+      # * :months, if set to true, months (M) of 30 days will be taken into
+      #   account when building up the result
+      # * :drop_seconds, if set to true, seconds and milliseconds will be
+      #   trimmed from the result
+      #
+      def to_duration_hash(seconds, options={})
+
+        to_fugit_duration(seconds, options).to_rufus_h
       end
 
-      durations = options[:months] ? DURATIONS2M : DURATIONS2
+      # Used by both .to_duration and .to_duration_hash
+      #
+      def to_fugit_duration(seconds, options={})
 
-      durations.each do |key, duration|
+        d = Fugit::Duration
+          .parse(seconds, options)
+          .deflate
 
-        count = seconds / duration
-        seconds = seconds % duration
+        d = d.drop_seconds if options[:drop_seconds]
+        d = d.deflate(:month => options[:months]) if options[:months]
 
-        h[key.to_sym] = count if count > 0
+        d
       end
 
-      h
-    end
+      #--
+      # misc
+      #++
 
-    #--
-    # misc
-    #++
+      # Produces the UTC string representation of a Time instance
+      #
+      # like "2009/11/23 11:11:50.947109 UTC"
+      #
+      def utc_to_s(t=Time.now)
 
-    # Produces the UTC string representation of a Time instance
-    #
-    # like "2009/11/23 11:11:50.947109 UTC"
-    #
-    def self.utc_to_s(t=Time.now)
-
-      "#{t.utc.strftime('%Y-%m-%d %H:%M:%S')}.#{sprintf('%06d', t.usec)} UTC"
-    end
+        "#{t.utc.strftime('%Y-%m-%d %H:%M:%S')}.#{sprintf('%06d', t.usec)} UTC"
+      end
 
-    # Produces a hour/min/sec/milli string representation of Time instance
-    #
-    def self.h_to_s(t=Time.now)
+      # Produces a hour/min/sec/milli string representation of Time instance
+      #
+      def h_to_s(t=Time.now)
 
-      "#{t.strftime('%H:%M:%S')}.#{sprintf('%06d', t.usec)}"
+        "#{t.strftime('%H:%M:%S')}.#{sprintf('%06d', t.usec)}"
+      end
     end
 
     # Debugging tools...