rocketjob 5.3.0 → 5.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe39da29017eca601c104ca9d7c4fa90f903c32cbf3822e064cbd4a7f0780272
-  data.tar.gz: ce81cfb0d3a0ac4dbfe4ebe7c549077e56ca52d19ca41a2fda150561ecfeedd7
+  metadata.gz: 42be7df83c1d38b5ef3a41751e3cc6afd6fb885638a7d144bfd1f71ff5de441e
+  data.tar.gz: fd3942b7fe1aa2d76bda3395561bea56122b9eab58c0ae65d99fbea76e3d771c
 SHA512:
-  metadata.gz: fa49046d738a5064da99363e0d854253d17c375ab1e75b095c118139d9081781b9e4177bc03cf70abd4edb906b43cdc033b96234bd5864b5f9959e81f1421074
-  data.tar.gz: 5e67742618a4ec874a1c43649d8619cec007380f8db84a3a81f584ec6f9896be0e14e062e69955158732b32e419a8ac7bfab9eef394c983a9f484a9c5c04c934
+  metadata.gz: 324641130fd1bb0724058d81cdf33dad02bbdeef2047413a479dcb0bb0782be37be3e0aad9b5c57d9ea200e6cc30889ce06ce8130716f91399472bf317ed4089
+  data.tar.gz: dfe9e7f121e7fee9c4713d5fc819e3889d1e0d1d208ac14cd4678f83ce0f802f51e2067cd10d687301a9f7470a609eab6259036e191ae8e6198f7a7830cbbd82

data/lib/rocket_job/batch/throttle_windows.rb

@@ -1,4 +1,5 @@
 require "active_support/concern"
+require "fugit"
 
 module RocketJob
   module Batch
@@ -43,6 +44,10 @@ module RocketJob
         field :secondary_duration, type: Integer, class_attribute: true, user_editable: true, copy_on_restart: true
 
         define_batch_throttle :throttle_windows_exceeded?, filter: :throttle_filter_id
+
+        validates_each :primary_schedule, :secondary_schedule do |record, attr, value|
+          record.errors.add(attr, "Invalid #{attr}: #{value.inspect}") if value && !Fugit::Cron.new(value)
+        end
       end
 
       private
@@ -56,10 +61,10 @@ module RocketJob
       end
 
       def throttle_outside_window?(schedule, duration)
-        cron = Plugins::Rufus::CronLine.new(schedule)
-        time = Time.now + 1
+        cron = Fugit::Cron.new(schedule)
+        time = Time.now.utc + 1
         # Add 1 second since right now could be the very beginning of the processing window.
-        previous_time = cron.previous_time(time).to_time
+        previous_time = cron.previous_time(time).to_utc_time
         previous_time + duration < time
       end
     end

data/lib/rocket_job/batch/worker.rb

@@ -110,8 +110,6 @@ module RocketJob
         servers
       end
 
-      private
-
       def rocket_job_batch_throttled?(slice, worker)
         filter = self.class.rocket_job_batch_throttles.matching_filter(self, slice)
         return false unless filter
@@ -150,7 +148,7 @@ module RocketJob
           records = slice.records
 
           # Skip records already processed, if any.
-          #slice.processing_record_number ||= 0
+          # slice.processing_record_number ||= 0
           # TODO: Must append to existing output slices before this can be enabled.
           # if !collect_output && (slice.processing_record_number > 1)
           #   records = records[slice.processing_record_number - 1..-1]

data/lib/rocket_job/event.rb

@@ -104,8 +104,6 @@ module RocketJob
       end
     end
 
-    private
-
     @load_time   = Time.now.utc
     @subscribers = Concurrent::Map.new { Concurrent::Array.new }
 

data/lib/rocket_job/extensions/mongoid/clients/options.rb

@@ -22,8 +22,6 @@ module RocketJob
         @collection_name = collection_name&.to_sym
       end
 
-      private
-
       module ClassMethods
         def with_collection(collection_name)
           all.with_collection(collection_name)

data/lib/rocket_job/plugins/cron.rb

@@ -1,4 +1,5 @@
 require "active_support/concern"
+require "fugit"
 
 module RocketJob
   module Plugins
@@ -17,7 +18,9 @@ module RocketJob
 
         field :cron_schedule, type: String, class_attribute: true, user_editable: true, copy_on_restart: true
 
-        validate :rocket_job_cron_valid
+        validates_each :cron_schedule do |record, attr, value|
+          record.errors.add(attr, "Invalid cron_schedule: #{value.inspect}") if value && !Fugit::Cron.new(value)
+        end
         before_save :rocket_job_cron_set_run_at
 
         private
@@ -49,24 +52,14 @@ module RocketJob
       #     The next time as of this time.
       #     Default: Time.now
       def rocket_job_cron_next_time(time = Time.now)
-        RocketJob::Plugins::Rufus::CronLine.new(cron_schedule).next_time(time)
+        Fugit::Cron.new(cron_schedule).next_time.to_utc_time
       end
 
-      private
-
       def rocket_job_cron_set_run_at
         return unless cron_schedule
 
         self.run_at = rocket_job_cron_next_time if cron_schedule_changed? && !run_at_changed?
       end
-
-      def rocket_job_cron_valid
-        return unless cron_schedule
-
-        RocketJob::Plugins::Rufus::CronLine.new(cron_schedule)
-      rescue ArgumentError => e
-        errors.add(:cron_schedule, e.message)
-      end
     end
   end
 end

data/lib/rocket_job/plugins/processing_window.rb

@@ -1,4 +1,5 @@
 require "active_support/concern"
+require "fugit"
 
 module RocketJob
   module Plugins
@@ -47,18 +48,14 @@ module RocketJob
 
         validates_presence_of :processing_schedule, :processing_duration
         validates_each :processing_schedule do |record, attr, value|
-          begin
-            RocketJob::Plugins::Rufus::CronLine.new(value)
-          rescue ArgumentError => e
-            record.errors.add(attr, e.message)
-          end
+          record.errors.add(attr, "Invalid schedule: #{value.inspect}") unless Fugit::Cron.new(value)
         end
       end
 
       # Returns [true|false] whether this job is currently inside its processing window
       def rocket_job_processing_window_active?
-        time          = Time.now
-        previous_time = rocket_job_processing_schedule.previous_time(time)
+        time          = Time.now.utc
+        previous_time = Fugit::Cron.new(processing_schedule).previous_time(time).to_utc_time
         # Inside previous processing window?
         previous_time + processing_duration > time
       end
@@ -69,17 +66,14 @@ module RocketJob
       def rocket_job_processing_window_check
         return if rocket_job_processing_window_active?
 
-        logger.warn("Processing window closed before job was processed. Job is re-scheduled to run at: #{rocket_job_processing_schedule.next_time}")
+        next_time = Fugit::Cron.new(processing_schedule).next_time.to_utc_time
+        logger.warn("Processing window closed before job was processed. Job is re-scheduled to run at: #{next_time}")
         self.worker_name ||= "inline"
         requeue!(worker_name)
       end
 
       def rocket_job_processing_window_set_run_at
-        self.run_at = rocket_job_processing_schedule.next_time unless rocket_job_processing_window_active?
-      end
-
-      def rocket_job_processing_schedule
-        RocketJob::Plugins::Rufus::CronLine.new(processing_schedule)
+        self.run_at = Fugit::Cron.new(processing_schedule).next_time.to_utc_time unless rocket_job_processing_window_active?
       end
     end
   end

data/lib/rocket_job/version.rb

@@ -1,3 +1,3 @@
 module RocketJob
-  VERSION = "5.3.0".freeze
+  VERSION = "5.3.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rocketjob
 version: !ruby/object:Gem::Version
-  version: 5.3.0
+  version: 5.3.1
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-14 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aasm
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: fugit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: 
 email: 
 executables:
@@ -163,8 +177,6 @@ files:
 - lib/rocket_job/plugins/processing_window.rb
 - lib/rocket_job/plugins/restart.rb
 - lib/rocket_job/plugins/retry.rb
-- lib/rocket_job/plugins/rufus/cron_line.rb
-- lib/rocket_job/plugins/rufus/zo_time.rb
 - lib/rocket_job/plugins/singleton.rb
 - lib/rocket_job/plugins/state_machine.rb
 - lib/rocket_job/plugins/transaction.rb
@@ -212,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Ruby's missing batch processing system.

data/lib/rocket_job/plugins/rufus/cron_line.rb

@@ -1,520 +0,0 @@
-#--
-# 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.
-#++
-#@formatter:off
-
-require 'set'
-
-module RocketJob::Plugins::Rufus
-
-  #
-  # A 'cron line' is a line in the sense of a crontab
-  # (man 5 crontab) file line.
-  #
-  class CronLine
-
-    # The max number of years in the future or the past before giving up
-    # searching for #next_time or #previous_time respectively
-    #
-    NEXT_TIME_MAX_YEARS = 14
-
-    # The string used for creating this cronline instance.
-    #
-    attr_reader :original
-    attr_reader :original_timezone
-
-    attr_reader :seconds
-    attr_reader :minutes
-    attr_reader :hours
-    attr_reader :days
-    attr_reader :months
-    #attr_reader :monthdays # reader defined below
-    attr_reader :weekdays
-    attr_reader :timezone
-
-    def initialize(line)
-
-      fail ArgumentError.new(
-        "not a string: #{line.inspect}"
-      ) unless line.is_a?(String)
-
-      @original = line
-      @original_timezone = nil
-
-      items = line.split
-
-      if @timezone = RocketJob::Plugins::Rufus::ZoTime.get_tzone(items.last)
-        @original_timezone = items.pop
-      else
-        @timezone = RocketJob::Plugins::Rufus::ZoTime.get_tzone(:current)
-      end
-
-      fail ArgumentError.new(
-        "not a valid cronline : '#{line}'"
-      ) unless items.length == 5 or items.length == 6
-
-      offset = items.length - 5
-
-      @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
-      @minutes = parse_item(items[0 + offset], 0, 59)
-      @hours = parse_item(items[1 + offset], 0, 24)
-      @days = parse_item(items[2 + offset], -30, 31)
-      @months = parse_item(items[3 + offset], 1, 12)
-      @weekdays, @monthdays = parse_weekdays(items[4 + offset])
-
-      [ @seconds, @minutes, @hours, @months ].each do |es|
-
-        fail ArgumentError.new(
-          "invalid cronline: '#{line}'"
-        ) if es && es.find { |e| ! e.is_a?(Integer) }
-      end
-
-      if @days && @days.include?(0) # gh-221
-
-        fail ArgumentError.new('invalid day 0 in cronline')
-      end
-    end
-
-    # Returns true if the given time matches this cron line.
-    #
-    def matches?(time)
-
-      # FIXME Don't create a new ZoTime if time is already a ZoTime in same
-      #       zone ...
-      #       Wait, this seems only used in specs...
-      t = ZoTime.new(time.to_f, @timezone)
-
-      return false unless sub_match?(t, :sec, @seconds)
-      return false unless sub_match?(t, :min, @minutes)
-      return false unless sub_match?(t, :hour, @hours)
-      return false unless date_match?(t)
-      true
-    end
-
-    # Returns the next time that this cron line is supposed to 'fire'
-    #
-    # This is raw, 3 secs to iterate over 1 year on my macbook :( brutal.
-    # (Well, I was wrong, takes 0.001 sec on 1.8.7 and 1.9.1)
-    #
-    # This method accepts an optional Time parameter. It's the starting point
-    # for the 'search'. By default, it's Time.now
-    #
-    # Note that the time instance returned will be in the same time zone that
-    # the given start point Time (thus a result in the local time zone will
-    # be passed if no start time is specified (search start time set to
-    # Time.now))
-    #
-    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-    #     Time.mktime(2008, 10, 24, 7, 29))
-    #   #=> Fri Oct 24 07:30:00 -0500 2008
-    #
-    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-    #     Time.utc(2008, 10, 24, 7, 29))
-    #   #=> Fri Oct 24 07:30:00 UTC 2008
-    #
-    #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-    #     Time.utc(2008, 10, 24, 7, 29)).localtime
-    #   #=> Fri Oct 24 02:30:00 -0500 2008
-    #
-    # (Thanks to K Liu for the note and the examples)
-    #
-    def next_time(from=ZoTime.now)
-
-      nt = nil
-      zt = ZoTime.new(from.to_i + 1, @timezone)
-      maxy = from.year + NEXT_TIME_MAX_YEARS
-
-      loop do
-
-        nt = zt.dup
-
-        fail RangeError.new(
-          "failed to reach occurrence within " +
-            "#{NEXT_TIME_MAX_YEARS} years for '#{original}'"
-        ) if nt.year > maxy
-
-        unless date_match?(nt)
-          zt.add((24 - nt.hour) * 3600 - nt.min * 60 - nt.sec)
-          next
-        end
-        unless sub_match?(nt, :hour, @hours)
-          zt.add((60 - nt.min) * 60 - nt.sec)
-          next
-        end
-        unless sub_match?(nt, :min, @minutes)
-          zt.add(60 - nt.sec)
-          next
-        end
-        unless sub_match?(nt, :sec, @seconds)
-          zt.add(next_second(nt))
-          next
-        end
-
-        break
-      end
-
-      nt
-    end
-
-    # Returns the previous time the cronline matched. It's like next_time, but
-    # for the past.
-    #
-    def previous_time(from=ZoTime.now)
-
-      pt = nil
-      zt = ZoTime.new(from.to_i - 1, @timezone)
-      miny = from.year - NEXT_TIME_MAX_YEARS
-
-      loop do
-
-        pt = zt.dup
-
-        fail RangeError.new(
-          "failed to reach occurrence within " +
-            "#{NEXT_TIME_MAX_YEARS} years for '#{original}'"
-        ) if pt.year < miny
-
-        unless date_match?(pt)
-          zt.substract(pt.hour * 3600 + pt.min * 60 + pt.sec + 1)
-          next
-        end
-        unless sub_match?(pt, :hour, @hours)
-          zt.substract(pt.min * 60 + pt.sec + 1)
-          next
-        end
-        unless sub_match?(pt, :min, @minutes)
-          zt.substract(pt.sec + 1)
-          next
-        end
-        unless sub_match?(pt, :sec, @seconds)
-          zt.substract(prev_second(pt))
-          next
-        end
-
-        break
-      end
-
-      pt
-    end
-
-    # Returns an array of 6 arrays (seconds, minutes, hours, days,
-    # months, weekdays).
-    # This method is mostly used by the cronline specs.
-    #
-    def to_a
-
-      [
-        toa(@seconds),
-        toa(@minutes),
-        toa(@hours),
-        toa(@days),
-        toa(@months),
-        toa(@weekdays),
-        toa(@monthdays),
-        @timezone.name
-      ]
-    end
-    alias to_array to_a
-
-    # Returns a quickly computed approximation of the frequency for this
-    # cron line.
-    #
-    # #brute_frequency, on the other hand, will compute the frequency by
-    # examining a whole year, that can take more than seconds for a seconds
-    # level cron...
-    #
-    def frequency
-
-      return brute_frequency unless @seconds && @seconds.length > 1
-
-      secs = toa(@seconds)
-
-      secs[1..-1].inject([ secs[0], 60 ]) { |(prev, delta), sec|
-        d = sec - prev
-        [ 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.
-    #
-    # .
-    #
-    # For a simple cronline like "*/5 * * * *", obviously the frequency is
-    # five minutes. Why does this method look at a whole year of #next_time ?
-    #
-    # Consider "* * * * sun#2,sun#3", the computed frequency is 1 week
-    # (the shortest delta is the one between the second sunday and the third
-    # sunday). This method takes no chance and runs next_time for the span
-    # of a whole year and keeps the shortest.
-    #
-    # Of course, this method can get VERY slow if you call on it a second-
-    # based cronline...
-    #
-    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))
-
-      loop do
-
-        break if delta <= 1
-        break if delta <= 60 && @seconds && @seconds.size == 1
-
-        t1 = next_time(t0)
-        d = t1 - t0
-        delta = d if d < delta
-        break if @months.nil? && t1.month == 2
-        break if @months.nil? && @days.nil? && t1.day == 2
-        break if @months.nil? && @days.nil? && @hours.nil? && t1.hour == 1
-        break if @months.nil? && @days.nil? && @hours.nil? && @minutes.nil? && t1.min == 1
-        break if t1.year >= 2001
-
-        t0 = t1
-      end
-
-      self.class.cache[key] = delta
-    end
-
-    def next_second(time)
-
-      secs = toa(@seconds)
-
-      return secs.first + 60 - time.sec if time.sec > secs.last
-
-      secs.shift while secs.first < time.sec
-
-      secs.first - time.sec
-    end
-
-    def prev_second(time)
-
-      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
-
-    def parse_weekdays(item)
-
-      return nil if item == '*'
-
-      weekdays = nil
-      monthdays = nil
-
-      item.downcase.split(',').each do |it|
-
-        WEEKDAYS.each_with_index { |a, i| it.gsub!(/#{a}/, i.to_s) }
-
-        it = it.gsub(/([^#])l/, '\1#-1')
-        # "5L" == "5#-1" == the last Friday
-
-        if m = it.match(/\A(.+)#(l|-?[12345])\z/)
-
-          fail ArgumentError.new(
-            "ranges are not supported for monthdays (#{it})"
-          ) if m[1].index('-')
-
-          it = it.gsub(/#l/, '#-1')
-
-          (monthdays ||= []) << it
-
-        else
-
-          fail ArgumentError.new(
-            "invalid weekday expression (#{item})"
-          ) if it !~ /\A0*[0-7](-0*[0-7])?\z/
-
-          its = it.index('-') ? parse_range(it, 0, 7) : [ Integer(it) ]
-          its = its.collect { |i| i == 7 ? 0 : i }
-
-          (weekdays ||= []).concat(its)
-        end
-      end
-
-      weekdays = weekdays.uniq.sort if weekdays
-
-      [ weekdays, monthdays ]
-    end
-
-    def parse_item(item, min, max)
-
-      return nil if item == '*'
-
-      r = item.split(',').map { |i| parse_range(i.strip, min, max) }.flatten
-
-      fail ArgumentError.new(
-        "found duplicates in #{item.inspect}"
-      ) if r.uniq.size < r.size
-
-      r = sc_sort(r)
-
-      Set.new(r)
-    end
-
-    RANGE_REGEX = /\A(\*|-?\d{1,2})(?:-(-?\d{1,2}))?(?:\/(\d{1,2}))?\z/
-
-    def parse_range(item, min, max)
-
-      return %w[ L ] if item == 'L'
-
-      item = '*' + item if item[0, 1] == '/'
-
-      m = item.match(RANGE_REGEX)
-
-      fail ArgumentError.new(
-        "cannot parse #{item.inspect}"
-      ) unless m
-
-      mmin = min == -30 ? 1 : min # days
-
-      sta = m[1]
-      sta = sta == '*' ? mmin : sta.to_i
-
-      edn = m[2]
-      edn = edn ? edn.to_i : sta
-      edn = max if m[1] == '*'
-
-      inc = m[3]
-      inc = inc ? inc.to_i : 1
-
-      fail ArgumentError.new(
-        "#{item.inspect} positive/negative ranges not allowed"
-      ) if (sta < 0 && edn > 0) || (sta > 0 && edn < 0)
-
-      fail ArgumentError.new(
-        "#{item.inspect} descending day ranges not allowed"
-      ) if min == -30 && sta > edn
-
-      fail ArgumentError.new(
-        "#{item.inspect} is not in range #{min}..#{max}"
-      ) if sta < min || edn > max
-
-      fail ArgumentError.new(
-        "#{item.inspect} increment must be greater than zero"
-      ) if inc == 0
-
-      r = []
-      val = sta
-
-      loop do
-        v = val
-        v = 0 if max == 24 && v == 24 # hours
-        r << v
-        break if inc == 1 && val == edn
-        val += inc
-        break if inc > 1 && val > edn
-        val = min if val > max
-      end
-
-      r.uniq
-    end
-
-    # FIXME: Eventually split into day_match?, hour_match? and monthdays_match?o
-    #
-    def sub_match?(time, accessor, values)
-
-      return true if values.nil?
-
-      value = time.send(accessor)
-
-      if accessor == :day
-
-        values.each do |v|
-          return true if v == 'L' && (time + DAY_S).day == 1
-          return true if v.to_i < 0 && (time + (1 - v) * DAY_S).day == 1
-        end
-      end
-
-      if accessor == :hour
-
-        return true if value == 0 && values.include?(24)
-      end
-
-      if accessor == :monthdays
-
-        return true if (values & value).any?
-      end
-
-      values.include?(value)
-    end
-
-    #    def monthday_match?(zt, values)
-    #
-    #      return true if values.nil?
-    #
-    #      today_values = monthdays(zt)
-    #
-    #      (today_values & values).any?
-    #    end
-
-    def date_match?(zt)
-
-      return false unless sub_match?(zt, :day, @days)
-      return false unless sub_match?(zt, :month, @months)
-
-      return true if (
-      (@weekdays && @monthdays) &&
-        (sub_match?(zt, :wday, @weekdays) ||
-          sub_match?(zt, :monthdays, @monthdays)))
-
-      return false unless sub_match?(zt, :wday, @weekdays)
-      return false unless sub_match?(zt, :monthdays, @monthdays)
-
-      true
-    end
-  end
-end

data/lib/rocket_job/plugins/rufus/zo_time.rb

@@ -1,524 +0,0 @@
-#--
-# 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.
-#++
-#@formatter:off
-
-module RocketJob::Plugins::Rufus
-  #
-  # Zon{ing|ed}Time, whatever.
-  #
-  class ZoTime
-
-    attr_reader :seconds
-    attr_reader :zone
-
-    def initialize(s, zone)
-
-      @seconds = s.to_f
-      @zone = self.class.get_tzone(zone || :current)
-
-      fail ArgumentError.new(
-        "cannot determine timezone from #{zone.inspect}" +
-          " (etz:#{ENV['TZ'].inspect},tnz:#{Time.now.zone.inspect}," +
-          "tzid:#{defined?(TZInfo::Data).inspect})\n" +
-          "Try setting `ENV['TZ'] = 'Continent/City'` in your script " +
-          "(see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)" +
-          (defined?(TZInfo::Data) ? '' : " and adding 'tzinfo-data' to your gems")
-      ) unless @zone
-
-      @time = nil # cache for #to_time result
-    end
-
-    def seconds=(f)
-
-      @time = nil
-      @seconds = f
-    end
-
-    def zone=(z)
-
-      @time = nil
-      @zone = self.class.get_tzone(zone || :current)
-    end
-
-    def utc
-
-      Time.utc(1970, 1, 1) + @seconds
-    end
-
-    # Returns a Ruby Time instance.
-    #
-    # Warning: the timezone of that Time instance will be UTC.
-    #
-    def to_time
-
-      @time ||= begin; u = utc; @zone.period_for_utc(u).to_local(u); end
-    end
-
-    %w[
-      year month day wday hour min sec usec asctime
-    ].each do |m|
-      define_method(m) { to_time.send(m) }
-    end
-    def iso8601(fraction_digits=0); to_time.iso8601(fraction_digits); end
-
-    def ==(o)
-
-      o.is_a?(ZoTime) && o.seconds == @seconds && o.zone == @zone
-    end
-    #alias eq? == # FIXME see Object#== (ri)
-
-    def >(o); @seconds > _to_f(o); end
-    def >=(o); @seconds >= _to_f(o); end
-    def <(o); @seconds < _to_f(o); end
-    def <=(o); @seconds <= _to_f(o); end
-    def <=>(o); @seconds <=> _to_f(o); end
-
-    alias getutc utc
-    alias getgm utc
-
-    def to_i
-
-      @seconds.to_i
-    end
-
-    def to_f
-
-      @seconds
-    end
-
-    def is_dst?
-
-      @zone.period_for_utc(utc).std_offset != 0
-    end
-    alias isdst is_dst?
-
-    def utc_offset
-
-      #@zone.period_for_utc(utc).utc_offset
-      #@zone.period_for_utc(utc).utc_total_offset
-      #@zone.period_for_utc(utc).std_offset
-      @zone.period_for_utc(utc).utc_offset
-    end
-
-    def strftime(format)
-
-      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
-
-      to_time.strftime(format)
-    end
-
-    def add(t); @time = nil; @seconds += t.to_f; end
-    def substract(t); @time = nil; @seconds -= t.to_f; end
-
-    def +(t); inc(t, 1); end
-    def -(t); inc(t, -1); end
-
-    WEEK_S = 7 * 24 * 3600
-
-    def monthdays
-
-      date = to_time
-
-      pos = 1
-      d = self.dup
-
-      loop do
-        d.add(-WEEK_S)
-        break if d.month != date.month
-        pos = pos + 1
-      end
-
-      neg = -1
-      d = self.dup
-
-      loop do
-        d.add(WEEK_S)
-        break if d.month != date.month
-        neg = neg - 1
-      end
-
-      [ "#{date.wday}##{pos}", "#{date.wday}##{neg}" ]
-    end
-
-    def to_s
-
-      strftime('%Y-%m-%d %H:%M:%S %z')
-    end
-
-    def to_debug_s
-
-      uo = self.utc_offset
-      uos = uo < 0 ? '-' : '+'
-      uo = uo.abs
-      uoh, uom = [ uo / 3600, uo % 3600 ]
-
-      [
-        'zt',
-        self.strftime('%Y-%m-%d %H:%M:%S'),
-        "%s%02d:%02d" % [ uos, uoh, uom ],
-        "dst:#{self.isdst}"
-      ].join(' ')
-    end
-
-    # Debug current time by showing local time / delta / utc time
-    # for example: "0120-7(0820)"
-    #
-    def to_utc_comparison_s
-
-      per = @zone.period_for_utc(utc)
-      off = per.utc_total_offset
-
-      off = off / 3600
-      off = off >= 0 ? "+#{off}" : off.to_s
-
-      strftime('%H%M') + off + utc.strftime('(%H%M)')
-    end
-
-    def to_time_s
-
-      strftime("%H:%M:%S.#{'%06d' % usec}")
-    end
-
-    def self.now(zone=nil)
-
-      ZoTime.new(Time.now.to_f, zone)
-    end
-
-    # https://en.wikipedia.org/wiki/ISO_8601
-    # Postel's law applies
-    #
-    def self.extract_iso8601_zone(s)
-
-      m = s.match(
-        /[0-2]\d(?::?[0-6]\d(?::?[0-6]\d))?\s*([+-]\d\d(?::?\d\d)?)\s*\z/)
-      return nil unless m
-
-      zs = m[1].split(':')
-      zs << '00' if zs.length < 2
-
-      zh = zs[0].to_i.abs
-
-      return nil if zh > 24
-      return nil if zh == 24 && zs[1].to_i != 0
-
-      zs.join(':')
-    end
-
-    def self.parse(str, opts={})
-
-      if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-        return ZoTime.new(t, nil)
-      end
-
-      #rold = RUBY_VERSION < '1.9.0'
-      #rold = RUBY_VERSION < '2.0.0'
-
-      begin
-        DateTime.parse(str)
-      rescue
-        fail ArgumentError, "no time information in #{str.inspect}"
-      end #if rold
-      #
-      # is necessary since Time.parse('xxx') in Ruby < 1.9 yields `now`
-
-      zone = nil
-
-      s =
-        str.gsub(/\S+/) do |w|
-          if z = get_tzone(w)
-            zone ||= z
-            ''
-          else
-            w
-          end
-        end
-
-      local = Time.parse(s)
-      izone = extract_iso8601_zone(s)
-
-      zone ||=
-        if s.match(/\dZ\b/)
-          get_tzone('Zulu')
-          #elsif rold && izone
-        elsif izone
-          get_tzone(izone)
-        elsif local.zone.nil? && izone
-          get_tzone(local.strftime('%:z'))
-        else
-          get_tzone(:local)
-        end
-
-      secs =
-        #if rold && izone
-        if izone
-          local.to_f
-        else
-          zone.period_for_local(local).to_utc(local).to_f
-        end
-
-      ZoTime.new(secs, zone)
-    end
-
-    def self.get_tzone(str)
-
-      return str if str.is_a?(::TZInfo::Timezone)
-
-      # discard quickly when it's certainly not a timezone
-
-      return nil if str == nil
-      return nil if str == '*'
-
-      ostr = str
-      str = :current if str == :local
-
-      # use Rails' zone by default if Rails is present
-
-      return Time.zone.tzinfo if (
-      ENV['TZ'].nil? && str == :current &&
-        Time.respond_to?(:zone) && Time.zone.respond_to?(:tzinfo)
-      )
-
-      # ok, it's a timezone then
-
-      str = ENV['TZ'] || Time.now.zone if str == :current
-
-      # utc_offset
-
-      if str.is_a?(Numeric)
-        i = str.to_i
-        sn = i < 0 ? '-' : '+'; i = i.abs
-        hr = i / 3600; mn = i % 3600; sc = i % 60
-        str = (sc > 0 ? "%s%02d:%02d:%02d" : "%s%02d:%02d") % [ sn, hr, mn, sc ]
-      end
-
-      return nil if str.index('#')
-      # counters "sun#2", etc... On OSX would go all the way to true
-
-      # vanilla time zones
-
-      z = (::TZInfo::Timezone.get(str) rescue nil)
-      return z if z
-
-      # time zone abbreviations
-
-      if str.match(/\A[A-Z0-9-]{3,6}\z/)
-
-        toff = Time.now.utc_offset
-        toff = nil if str != Time.now.zone
-
-        twin = Time.utc(Time.now.year, 1, 1) # winter
-        tsum = Time.utc(Time.now.year, 7, 1) # summer
-
-        z =
-          ::TZInfo::Timezone.all.find do |tz|
-
-            pwin = tz.period_for_utc(twin)
-            psum = tz.period_for_utc(tsum)
-
-            if toff
-              (pwin.abbreviation.to_s == str && pwin.utc_offset == toff) ||
-                (psum.abbreviation.to_s == str && psum.utc_offset == toff)
-            else
-              # returns the first tz with the given abbreviation, almost useless
-              # favour fully named zones...
-              pwin.abbreviation.to_s == str ||
-                psum.abbreviation.to_s == str
-            end
-          end
-        return z if z
-      end
-
-      # some time zone aliases
-
-      return ::TZInfo::Timezone.get('Zulu') if %w[ Z ].include?(str)
-
-      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
-
-      tz = (@custom_tz_cache ||= {})[str]
-      return tz if tz
-
-      if m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])\z/)
-
-        hr = m[1].to_i
-        mn = m[2].to_i
-
-        hr = nil if hr.abs > 11
-        hr = nil if mn > 59
-        mn = -mn if hr && hr < 0
-
-        return (
-        @custom_tz_cache[str] =
-          begin
-            tzi = TZInfo::TransitionDataTimezoneInfo.new(str)
-            tzi.offset(str, hr * 3600 + mn * 60, 0, str)
-            tzi.create_timezone
-          end
-        ) if hr
-      end
-
-      # try with ENV['TZ']
-
-      z = ostr == :current && (::TZInfo::Timezone.get(ENV['TZ']) rescue nil)
-      return z if z
-
-      # ask the system
-
-      z = ostr == :current && (debian_tz || centos_tz || osx_tz)
-      return z if z
-
-      # so it's not a timezone.
-
-      nil
-    end
-
-    def self.debian_tz
-
-      path = '/etc/timezone'
-
-      File.exist?(path) &&
-        (::TZInfo::Timezone.get(File.read(path).strip) rescue nil)
-    end
-
-    def self.centos_tz
-
-      path = '/etc/sysconfig/clock'
-
-      File.open(path, 'rb') do |f|
-        until f.eof?
-          m = f.readline.match(/ZONE="([^"]+)"/)
-          return (::TZInfo::Timezone.get(m[1]) rescue nil) if m
-        end
-      end if File.exist?(path)
-
-      nil
-    end
-
-    def self.osx_tz
-
-      path = '/etc/localtime'
-
-      return nil unless File.exist?(path)
-
-      ::TZInfo::Timezone.get(
-        File.readlink(path).split('/')[4..-1].join('/')
-      ) rescue nil
-    end
-
-    def self.local_tzone
-
-      get_tzone(:local)
-    end
-
-    def self.make(o)
-
-      zt =
-        case o
-        when Time
-          ZoTime.new(o.to_f, o.zone)
-        when Date
-          t =
-            o.respond_to?(:to_time) ?
-              o.to_time :
-              Time.parse(o.strftime('%Y-%m-%d %H:%M:%S'))
-          ZoTime.new(t.to_f, t.zone)
-        when String
-          Rufus::Scheduler.parse_in(o, :no_error => true) || self.parse(o)
-        else
-          o
-        end
-
-      zt = ZoTime.new(Time.now.to_f + zt, nil) if zt.is_a?(Numeric)
-
-      fail ArgumentError.new(
-        "cannot turn #{o.inspect} to a ZoTime instance"
-      ) unless zt.is_a?(ZoTime)
-
-      zt
-    end
-
-    #    def in_zone(&block)
-    #
-    #      current_timezone = ENV['TZ']
-    #      ENV['TZ'] = @zone
-    #
-    #      block.call
-    #
-    #    ensure
-    #
-    #      ENV['TZ'] = current_timezone
-    #    end
-
-    protected
-
-    def inc(t, dir)
-
-      if t.is_a?(Numeric)
-        nt = self.dup
-        nt.seconds += dir * t.to_f
-        nt
-      elsif t.respond_to?(:to_f)
-        @seconds + dir * t.to_f
-      else
-        fail ArgumentError.new(
-          "cannot call ZoTime #- or #+ with arg of class #{t.class}")
-      end
-    end
-
-    def _to_f(o)
-
-      fail ArgumentError(
-        "comparison of ZoTime with #{o.inspect} failed"
-      ) unless o.is_a?(ZoTime) || o.is_a?(Time)
-
-      o.to_f
-    end
-
-    def strfz(code)
-
-      return @zone.name if code == '%/Z'
-
-      per = @zone.period_for_utc(utc)
-
-      return per.abbreviation.to_s if code == '%Z'
-
-      off = per.utc_total_offset
-      #
-      sn = off < 0 ? '-' : '+'; off = off.abs
-      hr = off / 3600
-      mn = (off % 3600) / 60
-      sc = 0
-
-      fmt =
-        if code == '%z'
-          "%s%02d%02d"
-        elsif code == '%:z'
-          "%s%02d:%02d"
-        else
-          "%s%02d:%02d:%02d"
-        end
-
-      fmt % [ sn, hr, mn, sc ]
-    end
-  end
-end