rufus-scheduler 3.6.0 → 3.7.0

data/lib/rufus/scheduler/util.rb

@@ -1,200 +1,216 @@
 
-module Rufus
+class Rufus::Scheduler
 
-  class Scheduler
+  class << self
 
-    class << self
+    #--
+    # time and string methods
+    #++
 
-      #--
-      # time and string methods
-      #++
+    def parse(o, opts={})
 
-      def parse(o, opts={})
+      opts[:no_error] = true
 
-        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
 
-        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 parse_cron(o, opts={})
 
-      def parse_cron(o, opts)
+      opts[:no_error] ?
+        Fugit.parse_cron(o) :
+        Fugit.do_parse_cron(o)
+    end
 
-        Fugit.parse_cron(o)
-      end
+    def parse_in(o, opts={})
 
-      def parse_in(o, opts={})
+      #o.is_a?(String) ? parse_duration(o, opts) : o
 
-        #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)
 
-        return parse_duration(o, opts) if o.is_a?(String)
-        return o if o.is_a?(Numeric)
+      fail ArgumentError.new("couldn't parse time point in #{o.inspect}")
 
-        fail ArgumentError.new("couldn't parse time point in #{o.inspect}")
+    rescue ArgumentError => ae
 
-      rescue ArgumentError => ae
+      return nil if opts[:no_error]
+      fail ae
+    end
 
-        return nil if opts[:no_error]
-        fail ae
-      end
+    def parse_at(o, opts={})
 
-      def parse_at(o, opts={})
+      return o if o.is_a?(EoTime)
+      return EoTime.make(o) if o.is_a?(Time)
+      EoTime.parse(o, opts)
 
-        return o if o.is_a?(EoTime)
-        return EoTime.make(o) if o.is_a?(Time)
-        EoTime.parse(o, opts)
+    rescue StandardError => se
 
-      rescue StandardError => se
+      return nil if opts[:no_error]
+      fail se
+    end
 
-        return nil if opts[:no_error]
-        fail se
-      end
+    # 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
 
-      # 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
+    # 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={})
 
-      # 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
 
-        #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
 
-        to_fugit_duration(seconds, options).to_rufus_s
-      end
+    # 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={})
 
-      # 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
 
-        to_fugit_duration(seconds, options).to_rufus_h
-      end
+    # Used by both .to_duration and .to_duration_hash
+    #
+    def to_fugit_duration(seconds, options={})
 
-      # Used by both .to_duration and .to_duration_hash
-      #
-      def to_fugit_duration(seconds, options={})
+      d = Fugit::Duration
+        .parse(seconds, options)
+        .deflate
 
-        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 = d.drop_seconds if options[:drop_seconds]
-        d = d.deflate(:month => options[:months]) if options[:months]
+      d
+    end
 
-        d
-      end
+    #--
+    # misc
+    #++
 
-      #--
-      # misc
-      #++
+    if RUBY_VERSION > '1.9.9'
 
       # 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)
-
-        "#{t.utc.strftime('%Y-%m-%d %H:%M:%S')}.#{sprintf('%06d', t.usec)} UTC"
+        "#{t.dup.utc.strftime('%F %T.%6N')} UTC"
       end
 
       # Produces a hour/min/sec/milli string representation of Time instance
       #
       def h_to_s(t=Time.now)
+        t.strftime('%T.%6N')
+      end
+    else
 
+      def utc_to_s(t=Time.now)
+        "#{t.utc.strftime('%Y-%m-%d %H:%M:%S')}.#{sprintf('%06d', t.usec)} UTC"
+      end
+      def h_to_s(t=Time.now)
         "#{t.strftime('%H:%M:%S')}.#{sprintf('%06d', t.usec)}"
       end
     end
 
-    # Debugging tools...
-    #
-    class D
-
-      def self.h_to_s(t=Time.now); Rufus::Scheduler.h_to_s(t); end
+    if defined?(Process::CLOCK_MONOTONIC)
+      def monow; Process.clock_gettime(Process::CLOCK_MONOTONIC); end
+    else
+      def monow; Time.now.to_f; end
     end
+
+    def ltstamp; Time.now.strftime('%FT%T.%3N'); end
+  end
+
+  # Debugging tools...
+  #
+  class D
+
+    def self.h_to_s(t=Time.now); Rufus::Scheduler.h_to_s(t); end
   end
 end
 

data/rufus-scheduler.gemspec

@@ -10,8 +10,7 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.authors = [ 'John Mettraux' ]
   s.email = [ 'jmettraux@gmail.com' ]
-  s.homepage = 'http://github.com/jmettraux/rufus-scheduler'
-  s.rubyforge_project = 'rufus'
+  s.homepage = 'https://github.com/jmettraux/rufus-scheduler'
   s.license = 'MIT'
   s.summary = 'job scheduler for Ruby (at, cron, in and every jobs)'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rufus-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.7.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-22 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fugit
@@ -74,18 +74,20 @@ files:
 - lib/rufus-scheduler.rb
 - lib/rufus/scheduler.rb
 - lib/rufus/scheduler/job_array.rb
-- lib/rufus/scheduler/jobs.rb
+- lib/rufus/scheduler/jobs_core.rb
+- lib/rufus/scheduler/jobs_one_time.rb
+- lib/rufus/scheduler/jobs_repeat.rb
 - lib/rufus/scheduler/locks.rb
 - lib/rufus/scheduler/util.rb
 - rufus-scheduler.gemspec
-homepage: http://github.com/jmettraux/rufus-scheduler
+homepage: https://github.com/jmettraux/rufus-scheduler
 licenses:
 - MIT
 metadata:
-  changelog_uri: http://github.com/jmettraux/rufus-scheduler/blob/master/CHANGELOG.md
-  bug_tracker_uri: http://github.com/jmettraux/rufus-scheduler/issues
-  homepage_uri: http://github.com/jmettraux/rufus-scheduler
-  source_code_uri: http://github.com/jmettraux/rufus-scheduler
+  changelog_uri: https://github.com/jmettraux/rufus-scheduler/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/jmettraux/rufus-scheduler/issues
+  homepage_uri: https://github.com/jmettraux/rufus-scheduler
+  source_code_uri: https://github.com/jmettraux/rufus-scheduler
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -101,8 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rufus
-rubygems_version: 2.6.14.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: job scheduler for Ruby (at, cron, in and every jobs)

data/lib/rufus/scheduler/jobs.rb

@@ -1,701 +0,0 @@
-
-module Rufus
-
-  class Scheduler
-
-    #--
-    # job classes
-    #++
-
-    class Job
-
-      #
-      # Used by Job#kill
-      #
-      class KillSignal < StandardError; end
-
-      attr_reader :id
-      attr_reader :opts
-      attr_reader :original
-      attr_reader :scheduled_at
-      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
-      #
-      attr_accessor :next_time
-
-      # previous "next trigger time"
-      #
-      attr_accessor :previous_time
-
-      # anything with a #call(job[, timet]) method,
-      # what gets actually triggered
-      #
-      attr_reader :callable
-
-      # a reference to the instance whose call method is the @callable
-      #
-      attr_reader :handler
-
-      def initialize(scheduler, original, opts, block)
-
-        @scheduler = scheduler
-        @original = original
-        @opts = opts
-
-        @handler = block
-
-        @callable =
-          if block.respond_to?(:arity)
-            block
-          elsif block.respond_to?(:call)
-            block.method(:call)
-          elsif block.is_a?(Class)
-            @handler = block.new
-            @handler.method(:call) rescue nil
-          else
-            nil
-          end
-
-        @scheduled_at = EoTime.now
-        @unscheduled_at = nil
-        @last_time = nil
-
-        @locals = {}
-        @local_mutex = Mutex.new
-
-        @id = determine_id
-
-        fail(
-          ArgumentError,
-          'missing block or callable to schedule',
-          caller[2..-1]
-        ) unless @callable
-
-        @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
-          @opts[:overlap] = false
-        end
-        if m = @opts[:mutex]
-          @opts[:mutex] = Array(m)
-        end
-      end
-
-      alias job_id id
-
-      # Will fail with an ArgumentError if the job frequency is higher than
-      # the scheduler frequency.
-      #
-      def check_frequency
-
-        # this parent implementation never fails
-      end
-
-      def trigger(time)
-
-        @previous_time = @next_time
-        set_next_time(time)
-
-        do_trigger(time)
-      end
-
-      # Trigger the job right now, off of its schedule.
-      #
-      # Done in collaboration with Piavka in
-      # https://github.com/jmettraux/rufus-scheduler/issues/214
-      #
-      def trigger_off_schedule(time=EoTime.now)
-
-        do_trigger(time)
-      end
-
-      def unschedule
-
-        @unscheduled_at = EoTime.now
-      end
-
-      def threads
-
-        Thread.list.select { |t| t[:rufus_scheduler_job] == self }
-      end
-
-      # Kills all the threads this Job currently has going on.
-      #
-      def kill
-
-        threads.each { |t| t.raise(KillSignal) }
-      end
-
-      def running?
-
-        threads.any?
-      end
-
-      def scheduled?
-
-        @scheduler.scheduled?(self)
-      end
-
-      def []=(key, value)
-
-        @local_mutex.synchronize { @locals[key] = value }
-      end
-
-      def [](key)
-
-        @local_mutex.synchronize { @locals[key] }
-      end
-
-      def key?(key)
-
-        @local_mutex.synchronize { @locals.key?(key) }
-      end
-
-      def keys
-
-        @local_mutex.synchronize { @locals.keys }
-      end
-
-      #def hash
-      #  self.object_id
-      #end
-      #def eql?(o)
-      #  o.class == self.class && o.hash == self.hash
-      #end
-        #
-        # might be necessary at some point
-
-      def next_times(count)
-
-        next_time ? [ next_time ] : []
-      end
-
-      # Calls the callable (usually a block) wrapped in this Job instance.
-      #
-      # Warning: error rescueing is the responsibity of the caller.
-      #
-      def call(do_rescue=false)
-
-        do_call(EoTime.now, do_rescue)
-      end
-
-      protected
-
-      def callback(meth, time)
-
-        return true unless @scheduler.respond_to?(meth)
-
-        arity = @scheduler.method(meth).arity
-        args = [ self, time ][0, (arity < 0 ? 2 : arity)]
-
-        @scheduler.send(meth, *args)
-      end
-
-      def compute_timeout
-
-        if to = @opts[:timeout]
-          Rufus::Scheduler.parse(to)
-        else
-          nil
-        end
-      end
-
-      def mutex(m)
-
-        m.is_a?(Mutex) ? m : (@scheduler.mutexes[m.to_s] ||= Mutex.new)
-      end
-
-      def do_call(time, do_rescue)
-
-        args = [ self, time ][0, @callable.arity]
-        @callable.call(*args)
-
-      rescue StandardError => se
-
-        fail se unless do_rescue
-
-        return if se.is_a?(KillSignal) # discard
-
-        @scheduler.on_error(self, se)
-
-      # exceptions above StandardError do pass through
-      end
-
-      def do_trigger(time)
-
-        return if (
-          opts[:overlap] == false &&
-          running?
-        )
-        return if (
-          callback(:confirm_lock, time) &&
-          callback(:on_pre_trigger, time)
-        ) == false
-
-        @count += 1
-
-        if opts[:blocking]
-          trigger_now(time)
-        else
-          trigger_queue(time)
-        end
-      end
-
-      def trigger_now(time)
-
-        t = EoTime.now
-          # if there are mutexes, t might be really bigger than time
-
-        Thread.current[:rufus_scheduler_job] = self
-        Thread.current[:rufus_scheduler_time] = t
-        Thread.current[:rufus_scheduler_timeout] = compute_timeout
-
-        @last_time = t
-
-        do_call(time, true)
-
-      ensure
-
-        @last_work_time =
-          EoTime.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
-        Thread.current[:rufus_scheduler_time] = nil
-        Thread.current[:rufus_scheduler_timeout] = nil
-      end
-
-      def post_trigger(time)
-
-        set_next_time(time, true)
-
-        callback(:on_post_trigger, time)
-      end
-
-      def start_work_thread
-
-        thread =
-          Thread.new do
-
-            Thread.current[:rufus_scheduler_job] = true
-              # indicates that the thread is going to be assigned immediately
-
-            Thread.current[@scheduler.thread_key] = true
-            Thread.current[:rufus_scheduler_work_thread] = true
-
-            loop do
-
-              job, time = @scheduler.work_queue.pop
-
-              break if @scheduler.started_at == nil
-
-              next if job.unscheduled_at
-
-              begin
-
-                (job.opts[:mutex] || []).reduce(
-                  lambda { job.trigger_now(time) }
-                ) do |b, m|
-                  lambda { mutex(m).synchronize { b.call } }
-                end.call
-
-              rescue KillSignal
-
-                # simply go on looping
-              end
-            end
-          end
-
-        thread[@scheduler.thread_key] = true
-        thread[:rufus_scheduler_work_thread] = true
-          #
-          # same as above (in the thead block),
-          # but since it has to be done as quickly as possible.
-          # So, whoever is running first (scheduler thread vs job thread)
-          # sets this information
-
-        thread
-      end
-
-      def trigger_queue(time)
-
-        threads = @scheduler.work_threads
-
-        vac = threads.select { |t| t[:rufus_scheduler_job] == nil }.size
-        que = @scheduler.work_queue.size
-
-        cur = threads.size
-        max = @scheduler.max_work_threads
-
-        start_work_thread if vac - que < 1 && cur < max
-
-        @scheduler.work_queue << [ self, time ]
-      end
-    end
-
-    class OneTimeJob < Job
-
-      alias time next_time
-
-      def occurrences(time0, time1)
-
-        (time >= time0 && time <= time1) ? [ time ] : []
-      end
-
-      protected
-
-      def determine_id
-
-        [
-          self.class.name.split(':').last.downcase[0..-4],
-          @scheduled_at.to_f,
-          @next_time.to_f,
-          (self.object_id < 0 ? 'm' : '') + self.object_id.to_s
-        ].map(&:to_s).join('_')
-      end
-
-      # There is no next_time for one time jobs, hence the false.
-      #
-      def set_next_time(trigger_time, is_post=false)
-
-        @next_time = is_post ? nil : false
-      end
-    end
-
-    class AtJob < OneTimeJob
-
-      def initialize(scheduler, time, opts, block)
-
-        super(scheduler, time, opts, block)
-
-        @next_time =
-          opts[:_t] || Rufus::Scheduler.parse_at(time, opts)
-      end
-    end
-
-    class InJob < OneTimeJob
-
-      def initialize(scheduler, duration, opts, block)
-
-        super(scheduler, duration, opts, block)
-
-        @next_time =
-          @scheduled_at +
-          opts[:_t] || Rufus::Scheduler.parse_in(duration, opts)
-      end
-    end
-
-    class RepeatJob < Job
-
-      attr_reader :paused_at
-
-      attr_reader :first_at
-      attr_reader :last_at
-      attr_accessor :times
-
-      def initialize(scheduler, duration, opts, block)
-
-        super
-
-        @paused_at = nil
-
-        @times = opts[:times]
-
-        fail ArgumentError.new(
-          "cannot accept :times => #{@times.inspect}, not nil or an int"
-        ) unless @times == nil || @times.is_a?(Integer)
-
-        self.first_at =
-          opts[:first] || opts[:first_time] ||
-          opts[:first_at] || opts[:first_in] ||
-          nil
-        self.last_at =
-          opts[:last] || opts[:last_at] || opts[:last_in]
-      end
-
-      def first_at=(first)
-
-        return (@first_at = nil) if first == nil
-
-        n0 = EoTime.now
-        n1 = n0 + 0.003
-
-        first = n0 if first == :now || first == :immediately || first == 0
-        fdur = Rufus::Scheduler.parse_duration(first, no_error: true)
-
-        @first_at = (fdur && (EoTime.now + fdur)) || EoTime.make(first)
-        @first_at = n1 if @first_at >= n0 && @first_at < n1
-
-        fail ArgumentError.new(
-          "cannot set first[_at|_in] in the past: " +
-          "#{first.inspect} -> #{@first_at.inspect}"
-        ) if @first_at < n0
-
-        @first_at
-      end
-
-      def last_at=(last)
-
-        @last_at =
-          if last
-            ldur = Rufus::Scheduler.parse_duration(last, no_error: true)
-            (ldur && (EoTime.now + ldur)) || EoTime.make(last)
-          else
-            nil
-          end
-
-        fail ArgumentError.new(
-          "cannot set last[_at|_in] in the past: " +
-          "#{last.inspect} -> #{@last_at.inspect}"
-        ) if last && @last_at < EoTime.now
-
-        @last_at
-      end
-
-      def trigger(time)
-
-        return if @paused_at
-
-        return (@next_time = nil) if @times && @times < 1
-        return (@next_time = nil) if @last_at && time >= @last_at
-          #
-          # It keeps jobs one step too much in @jobs, but it's OK
-
-        super
-
-        @times -= 1 if @times
-      end
-
-      def pause
-
-        @paused_at = EoTime.now
-      end
-
-      def resume
-
-        @paused_at = nil
-      end
-
-      def paused?
-
-        @paused_at != nil
-      end
-
-      def determine_id
-
-        [
-          self.class.name.split(':').last.downcase[0..-4],
-          @scheduled_at.to_f,
-          (self.object_id < 0 ? 'm' : '') + self.object_id.to_s
-        ].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
-
-      # Starting from now, returns the {count} next occurences
-      # (EtOrbi::EoTime instances) for this job.
-      #
-      # Warning, for IntervalJob, the @mean_work_time is used since
-      # "interval" works from the end of a job to its next trigger
-      # (not from one trigger to the next, as for "cron" and "every").
-      #
-      def next_times(count)
-
-        (count - 1).times.inject([ next_time ]) { |a|
-          a << next_time_from(a.last)
-          a }
-      end
-    end
-
-    #
-    # A parent class of EveryJob and IntervalJob
-    #
-    class EvInJob < RepeatJob
-
-      def first_at=(first)
-
-        @next_time = super
-      end
-    end
-
-    class EveryJob < EvInJob
-
-      attr_reader :frequency
-
-      def initialize(scheduler, duration, opts, block)
-
-        super(scheduler, duration, opts, block)
-
-        @frequency = Rufus::Scheduler.parse_in(@original)
-
-        fail ArgumentError.new(
-          "cannot schedule #{self.class} with a frequency " +
-          "of #{@frequency.inspect} (#{@original.inspect})"
-        ) if @frequency <= 0
-
-        set_next_time(nil)
-      end
-
-      def check_frequency
-
-        fail ArgumentError.new(
-         "job frequency (#{@frequency}s) is higher than " +
-         "scheduler frequency (#{@scheduler.frequency}s)"
-        ) if @frequency < @scheduler.frequency
-      end
-
-      def next_time_from(time)
-
-        time + @frequency
-      end
-
-      protected
-
-      def set_next_time(trigger_time, is_post=false)
-
-        return if is_post
-
-        n = EoTime.now
-
-        @next_time =
-          if @first_at && (trigger_time == nil || @first_at > n)
-            @first_at
-          else
-            (@next_time || n) + @frequency
-          end
-      end
-    end
-
-    class IntervalJob < EvInJob
-
-      attr_reader :interval
-
-      def initialize(scheduler, interval, opts, block)
-
-        super(scheduler, interval, opts, block)
-
-        @interval = Rufus::Scheduler.parse_in(@original)
-
-        fail ArgumentError.new(
-          "cannot schedule #{self.class} with an interval " +
-          "of #{@interval.inspect} (#{@original.inspect})"
-        ) if @interval <= 0
-
-        set_next_time(nil)
-      end
-
-      def next_time_from(time)
-
-        time + @mean_work_time + @interval
-      end
-
-      protected
-
-      def set_next_time(trigger_time, is_post=false)
-
-        @next_time =
-          if is_post
-            EoTime.now + @interval
-          elsif trigger_time.nil?
-            if @first_at == nil || @first_at < Time.now
-              EoTime.now + @interval
-            else
-              @first_at
-            end
-          else
-            false
-          end
-      end
-    end
-
-    class CronJob < RepeatJob
-
-      attr_reader :cron_line
-
-      def initialize(scheduler, cronline, opts, block)
-
-        super(scheduler, cronline, opts, block)
-
-        @cron_line = opts[:_t] || ::Fugit::Cron.do_parse(cronline)
-
-        set_next_time(nil)
-      end
-
-      def check_frequency
-
-        return if @scheduler.frequency <= 1
-          #
-          # The minimum time delta in a cron job is 1 second, so if the
-          # scheduler frequency is less than that, no worries.
-
-        f = @cron_line.rough_frequency
-
-        fail ArgumentError.new(
-         "job frequency (min ~#{f}s) is higher than " +
-         "scheduler frequency (#{@scheduler.frequency}s)"
-        ) if f < @scheduler.frequency
-      end
-
-      def brute_frequency
-
-        @cron_line.brute_frequency
-      end
-
-      def rough_frequency
-
-        @cron_line.rough_frequency
-      end
-
-      def next_time_from(time)
-
-        if @first_at == nil || @first_at <= time
-          @cron_line.next_time(time)
-        else
-          @first_at
-        end
-      end
-
-      protected
-
-      def set_next_time(trigger_time, is_post=false)
-
-        @next_time = next_time_from(trigger_time || Time.now)
-      end
-    end
-  end
-end
-