rufus-scheduler 3.3.4 → 3.5.0

data/lib/rufus/scheduler/util.rb

@@ -1,281 +1,192 @@
-#--
-# Copyright (c) 2006-2017, 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
-
 
 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)
-
-      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?(Rufus::Scheduler::ZoTime)
-      return Rufus::Scheduler::ZoTime.make(o) if o.is_a?(Time)
-      Rufus::Scheduler::ZoTime.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
-
-    class << self
-      #-
-      # for compatibility with rufus-scheduler 2.x
-      #+
-      alias parse_duration_string parse_duration
-      alias parse_time_string parse_duration
-    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 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
-        }
+      def parse_at(o, opts={})
 
-      ms = h[:ms]
-      s << ms.to_s if ms
+        return o if o.is_a?(EoTime)
+        return EoTime.make(o) if o.is_a?(Time)
+        EoTime.parse(o, opts)
 
-      s
-    end
-
-    class << self
-      #-
-      # for compatibility with rufus-scheduler 2.x
-      #+
-      alias to_duration_string to_duration
-      alias to_time_string to_duration
-    end
+      rescue StandardError => se
 
-    # 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 self.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 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...

data/lib/rufus/scheduler.rb

@@ -1,46 +1,25 @@
-#--
-# Copyright (c) 2006-2017, 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
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
 
+require 'set'
 require 'date' if RUBY_VERSION < '1.9.0'
 require 'time'
 require 'thread'
-require 'tzinfo'
+
+require 'fugit'
 
 
 module Rufus
 
   class Scheduler
 
+    VERSION = '3.5.0'
+
+    EoTime = ::EtOrbi::EoTime
+
     require 'rufus/scheduler/util'
-    require 'rufus/scheduler/zotime'
     require 'rufus/scheduler/jobs'
-    require 'rufus/scheduler/cronline'
     require 'rufus/scheduler/job_array'
     require 'rufus/scheduler/locks'
 
-    VERSION = '3.3.4'
-
     #
     # A common error class for rufus-scheduler
     #
@@ -104,7 +83,7 @@ module Rufus
       @trigger_lock = opts[:trigger_lock] || Rufus::Scheduler::NullLock.new
 
       # If we can't grab the @scheduler_lock, don't run.
-      @scheduler_lock.lock || return
+      lock || return
 
       start
     end
@@ -154,12 +133,12 @@ module Rufus
 
     def uptime
 
-      @started_at ? Rufus::Scheduler::ZoTime.now - @started_at : nil
+      @started_at ? EoTime.now - @started_at : nil
     end
 
     def uptime_s
 
-      self.class.to_duration(uptime)
+      uptime ? self.class.to_duration(uptime) : ''
     end
 
     def join
@@ -258,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
 
@@ -272,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
 
@@ -409,7 +388,7 @@ module Rufus
     # Accepts a query option, which can be set to:
     # * :all (default), returns all the threads that are work threads
     #   or are currently running a job
-    # * :active, returns all threads that are currenly running a job
+    # * :active, returns all threads that are currently running a job
     # * :vacant, returns the threads that are not running a job
     #
     # If, thanks to :blocking => true, a job is scheduled to monopolize the
@@ -478,7 +457,9 @@ module Rufus
       stderr.puts("  #{pre}   tz:")
       stderr.puts("  #{pre}     ENV['TZ']: #{ENV['TZ']}")
       stderr.puts("  #{pre}     Time.now: #{Time.now}")
-      stderr.puts("  #{pre}     local_tzone: #{Rufus::Scheduler::ZoTime.local_tzone.inspect}")
+      stderr.puts("  #{pre}     local_tzone: #{EoTime.local_tzone.inspect}")
+      stderr.puts("  #{pre}   et-orbi:")
+      stderr.puts("  #{pre}     #{EoTime.platform_info}")
       stderr.puts("  #{pre}   scheduler:")
       stderr.puts("  #{pre}     object_id: #{object_id}")
       stderr.puts("  #{pre}     opts:")
@@ -558,7 +539,7 @@ module Rufus
 
     def start
 
-      @started_at = Rufus::Scheduler::ZoTime.now
+      @started_at = EoTime.now
 
       @thread =
         Thread.new do
@@ -585,7 +566,7 @@ module Rufus
 
     def trigger_jobs
 
-      now = Rufus::Scheduler::ZoTime.now
+      now = EoTime.now
 
       @jobs.each(now) do |job|
 
@@ -604,9 +585,9 @@ module Rufus
         next unless job && to && ts
           # thread might just have become inactive (job -> nil)
 
-        to = ts + to unless to.is_a?(Rufus::Scheduler::ZoTime)
+        to = ts + to unless to.is_a?(EoTime)
 
-        next if to > Rufus::Scheduler::ZoTime.now
+        next if to > EoTime.now
 
         t.raise(Rufus::Scheduler::TimeoutError)
       end
@@ -638,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/rufus-scheduler.gemspec

@@ -16,20 +16,24 @@ Gem::Specification.new do |s|
   s.summary = 'job scheduler for Ruby (at, cron, in and every jobs)'
 
   s.description = %{
-job scheduler for Ruby (at, cron, in and every jobs).
+Job scheduler for Ruby (at, cron, in and every jobs). Not a replacement for crond.
   }.strip
 
   #s.files = `git ls-files`.split("\n")
   s.files = Dir[
+    'README.{md,txt}',
+    'CHANGELOG.{md,txt}', 'CREDITS.{md,txt}', 'LICENSE.{md,txt}',
     'Makefile',
     'lib/**/*.rb', #'spec/**/*.rb', 'test/**/*.rb',
-    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+    "#{s.name}.gemspec",
   ]
 
-  s.add_runtime_dependency 'tzinfo'
+  s.required_ruby_version = '>= 1.9'
 
-  s.add_development_dependency 'rspec', '>= 2.13.0'
-  s.add_development_dependency 'chronic'
+  s.add_runtime_dependency 'fugit', '~> 1.1', '>= 1.1.1'
+
+  s.add_development_dependency 'rspec', '~> 3.7'
+  s.add_development_dependency 'chronic', '~> 0.10'
 
   s.require_path = 'lib'
 end