delayed_cron_job 0.7.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2b6628291d42c1bc4beef0cb884fb06474d5fea7
-  data.tar.gz: 3676a138edd3bece7b144579d4c013e0311b40bb
+SHA256:
+  metadata.gz: 678fe7b8dadfd92bc13dcdf8913dbf3cf462293153c036da1dab058c5a940537
+  data.tar.gz: c4ea2f8dd94350eb91ae845c6932085f4b976bd87bb4911f613172c65ac75115
 SHA512:
-  metadata.gz: 3b4856da97ea1a3f57d085f4df9bace1322d6d02ebb7835a50ddf64c469bbcd30c15a93f80d906a78955b6e6e743f5ccf2b02f3f7628245e410e5b377f8c33d9
-  data.tar.gz: a8fb3f19c7096e2d800bef4a7824e6f8d7e28ea420eae2764664ca28f2c6c7b9729d1bbaa7957740a7277373a43d546f244d42d871041e4103c57dbe6ecf06dd
+  metadata.gz: 5264e1c600025fe86b3b5d57f61e274f90b149646470d86cfe628f5ef685a3ef42440a804f4c60fcb2d63c01e4ea954a0a511bd1227511b77fb428bc4551b3fc
+  data.tar.gz: c8de49f94c73b0edf6abb45e32c39c7d175994676a9144ae39c05ce45e7ed87a0d53d3d51501f2e52d991abe2bf7949bfa429accec35456449f4f5e4364970d6

data/.gitignore

@@ -20,4 +20,5 @@ tmp
 *.o
 *.a
 mkmf.log
-.project
+.project
+file::memory:*

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
 
 rvm:
- - "2.3.0"
+ - "2.5.8"
+ - "2.7.2"
+ - "3.0.0"
 
 sudo: false
 

data/README.md

@@ -1,6 +1,6 @@
 # Delayed::Cron::Job
 
-{<img src="https://secure.travis-ci.org/codez/delayed_cron_job.png" />}[http://travis-ci.org/codez/delayed_cron_job]
+[![Build Status](https://app.travis-ci.com/codez/delayed_cron_job.svg?branch=master)](https://app.travis-ci.com/codez/delayed_cron_job)
 
 Delayed::Cron::Job is an extension to Delayed::Job that allows you to set
 cron expressions for your jobs to run repeatedly.
@@ -28,15 +28,121 @@ There are no additional steps for `delayed_job_mongoid`.
 
 When enqueuing a job, simply pass the `cron` option, e.g.:
 
-    Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```ruby
+Delayed::Job.enqueue(MyRepeatedJob.new, cron: '15 */6 * * 1-5')
+```
 
-Or, when using Active Job:
+Or, when using ActiveJob:
 
-    MyJob.set(cron: '*/5 * * * *').perform_later
+```ruby
+MyJob.set(cron: '*/5 * * * *').perform_later
+```
 
 Any crontab compatible cron expressions are supported (see `man 5 crontab`).
-The credits for the `Cronline` class used go to
-[rufus-scheduler](https://github.com/jmettraux/rufus-scheduler).
+Cron parsing is handled by [Fugit](https://github.com/floraison/fugit).
+
+## Scheduling
+
+Usually, you want to schedule all existing cron jobs when deploying the
+application. Using a common super class makes this simple.
+
+### Custom CronJob superclass
+
+`app/jobs/cron_job.rb`:
+
+```ruby
+# Default configuration in `app/jobs/application_job.rb`, or subclass
+# ActiveJob::Base .
+class CronJob < ApplicationJob
+
+  class_attribute :cron_expression
+
+  class << self
+
+    def schedule
+      set(cron: cron_expression).perform_later unless scheduled?
+    end
+
+    def remove
+      delayed_job.destroy if scheduled?
+    end
+
+    def scheduled?
+      delayed_job.present?
+    end
+
+    def delayed_job
+      Delayed::Job
+        .where('handler LIKE ?', "%job_class: #{name}%")
+        .first
+    end
+
+  end
+end
+```
+
+### Example Job inheriting from CronJob
+
+Then, an example job that triggers E-Mail-sending with default cron time at
+noon every day:
+
+`app/jobs/noon_job.rb`:
+
+```ruby
+
+# Note that it inherits from `CronJob`
+class NoonJob < CronJob
+  # set the (default) cron expression
+  self.cron_expression = '0 12 * * *'
+
+  # will enqueue the mailing delivery job
+  def perform
+    UserMailer.daily_notice(User.first).deliver_later
+  end
+end
+```
+
+### Automatic Scheduling after db:migrate
+
+Jobs with a `cron` definition are rescheduled automatically only when a job
+instance finished its work. So there needs to be an initial scheduling of all
+cron jobs. If you do not want to do this manually (e.g. using `rails console`)
+or with your application logic, you can e.g. hook into the `rails db:*` rake
+tasks:
+
+`lib/tasks/jobs.rake`:
+
+```ruby
+namespace :db do
+  desc 'Schedule all cron jobs'
+  task :schedule_jobs => :environment do
+    # Need to load all jobs definitions in order to find subclasses
+    glob = Rails.root.join('app', 'jobs', '**', '*_job.rb')
+    Dir.glob(glob).each { |file| require file }
+    CronJob.subclasses.each(&:schedule)
+  end
+end
+
+# invoke schedule_jobs automatically after every migration and schema load.
+%w(db:migrate db:schema:load).each do |task|
+  Rake::Task[task].enhance do
+    Rake::Task['db:schedule_jobs'].invoke
+  end
+end
+```
+
+Now, if you run `rails db:migrate`, `rails db:schema:load` or `rails
+db:schedule_jobs` all jobs inheriting from `CronJob` are scheduled.
+
+*If you are not using ActiveJob, the same approach may be used with minor
+adjustments.*
+
+### Changing the schedule
+
+Note that if you have a CronJob scheduled and change its `cron_expression` in
+its source file, you will have to remove any scheduled instances of the Job and
+reschedule it (e.g. with the snippet above: `rails db:migrate`). This is because
+the `cron_expression` is already persisted in the database (as `cron`).
 
 ## Details
 
@@ -71,4 +177,5 @@ jobs.
 ## License
 
 Delayed::Cron::Job is released under the terms of the MIT License.
-Copyright 2014-2017 Pascal Zumkehr. See LICENSE for further information.
+Copyright 2014-2021 Pascal Zumkehr. See [LICENSE](LICENSE) for further
+information.

data/delayed_cron_job.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "delayed_job", ">= 4.1"
+  spec.add_dependency "fugit", ">= 1.5"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/delayed_cron_job/backend/active_record/railtie.rb

@@ -0,0 +1,14 @@
+module DelayedCronJob
+  module Backend
+    module ActiveRecord
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do
+          Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+          if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+            Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed_cron_job/backend/updatable_cron.rb

@@ -4,14 +4,27 @@ module DelayedCronJob
 
       def self.included(klass)
         klass.send(:before_save, :set_next_run_at, :if => :cron_changed?)
+        klass.attr_accessor :schedule_instead_of_destroy
       end
 
       def set_next_run_at
         if cron.present?
-          self.run_at = Cronline.new(cron).next_time(Delayed::Job.db_time_now)
+          now = Delayed::Job.db_time_now
+          self.run_at = Fugit::Cron.do_parse(cron).next_time(now).to_local_time
         end
       end
 
+      def destroy
+        super unless schedule_instead_of_destroy
+      end
+
+      def schedule_next_run
+        self.attempts += 1
+        unlock
+        set_next_run_at
+        save!
+      end
+
     end
   end
-end
+end

data/lib/delayed_cron_job/plugin.rb

@@ -17,7 +17,6 @@ module DelayedCronJob
           worker.job_say(job,
                          "FAILED with #{$ERROR_INFO.class.name}: #{$ERROR_INFO.message}",
                          Logger::ERROR)
-          job.destroy
         else
           # No cron job - proceed as normal
           block.call(worker, job)
@@ -26,31 +25,26 @@ module DelayedCronJob
 
       # Reset the last_error to have the correct status of the last run.
       lifecycle.before(:perform) do |worker, job|
-        if cron?(job)
-          job.last_error = nil
-        end
+        job.last_error = nil if cron?(job)
       end
 
-      # Update the cron expression from the database in case it was updated.
+      # Prevent destruction of cron jobs
       lifecycle.after(:invoke_job) do |job|
-        if cron?(job)
-          job.cron = job.class.where(:id => job.id).pluck(:cron).first
-        end
+        job.schedule_instead_of_destroy = true if cron?(job)
       end
 
       # Schedule the next run based on the cron attribute.
       lifecycle.after(:perform) do |worker, job|
-        if cron?(job)
-          next_job = job.dup
-          next_job.id = job.id
-          next_job.created_at = job.created_at
-          next_job.locked_at = nil
-          next_job.locked_by = nil
-          next_job.attempts += 1
-          next_job.save!
+        if cron?(job) && !job.destroyed?
+          job.cron = job.class.where(:id => job.id).pluck(:cron).first
+          if job.cron.present?
+            job.schedule_next_run
+          else
+            job.schedule_instead_of_destroy = false
+            job.destroy
+          end
         end
       end
     end
-
   end
 end

data/lib/delayed_cron_job/version.rb

@@ -1,3 +1,3 @@
 module DelayedCronJob
-  VERSION = '0.7.2'
+  VERSION = '0.9.0'
 end

data/lib/delayed_cron_job.rb

@@ -1,6 +1,6 @@
 require 'delayed_job'
 require 'English'
-require 'delayed_cron_job/cronline'
+require 'fugit'
 require 'delayed_cron_job/plugin'
 require 'delayed_cron_job/version'
 require 'delayed_cron_job/backend/updatable_cron'
@@ -24,9 +24,15 @@ if defined?(Delayed::Backend::Mongoid)
 end
 
 if defined?(Delayed::Backend::ActiveRecord)
-  Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
-  if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
-    Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+  if defined?(Rails::Railtie)
+    # Postpone initialization to railtie for correct order
+    require 'delayed_cron_job/backend/active_record/railtie'
+  else
+    # Do the same as in the railtie
+    Delayed::Backend::ActiveRecord::Job.send(:include, DelayedCronJob::Backend::UpdatableCron)
+    if Delayed::Backend::ActiveRecord::Job.respond_to?(:attr_accessible)
+      Delayed::Backend::ActiveRecord::Job.attr_accessible(:cron)
+    end
   end
 end
 
@@ -43,4 +49,4 @@ if defined?(::ActiveJob)
     ActiveJob::QueueAdapters::DelayedJobAdapter.send(:include, DelayedCronJob::ActiveJob::QueueAdapter)
   end
 
-end
+end

data/spec/active_job_spec.rb

@@ -21,7 +21,7 @@ describe ActiveJob do
   let(:now)     { Delayed::Job.db_time_now }
   let(:next_run) do
     run = now.hour * 60 + now.min >= 65 ? now + 1.day : now
-    Time.utc(run.year, run.month, run.day, 1, 5)
+    Time.zone.local(run.year, run.month, run.day, 1, 5)
   end
 
   context 'with cron' do
@@ -66,4 +66,4 @@ describe ActiveJob do
       expect(delayed_job.cron).to eq(cron)
     end
   end
-end
+end

data/spec/delayed_cron_job_spec.rb

@@ -6,6 +6,16 @@ describe DelayedCronJob do
     def perform; end
   end
 
+  class DatabaseDisconnectPlugin < Delayed::Plugin
+
+    callbacks do |lifecycle|
+      lifecycle.after(:perform) do
+        ActiveRecord::Base.connection.disconnect!
+      end
+    end
+
+  end
+
   before { Delayed::Job.delete_all }
 
   let(:cron)    { '5 1 * * *' }
@@ -15,7 +25,7 @@ describe DelayedCronJob do
   let(:now)     { Delayed::Job.db_time_now }
   let(:next_run) do
     run = now.hour * 60 + now.min >= 65 ? now + 1.day : now
-    Time.utc(run.year, run.month, run.day, 1, 5)
+    Time.zone.local(run.year, run.month, run.day, 1, 5)
   end
 
   context 'with cron' do
@@ -25,8 +35,8 @@ describe DelayedCronJob do
     end
 
     it 'enqueue fails with invalid cron' do
-      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }.
-        to raise_error(ArgumentError)
+      expect { Delayed::Job.enqueue(handler, cron: 'no valid cron') }
+        .to raise_error(ArgumentError)
     end
 
     it 'schedules a new job after success' do
@@ -74,19 +84,16 @@ describe DelayedCronJob do
       expect(j.cron).to eq(job.cron)
       expect(j.run_at).to eq(next_run)
       expect(j.attempts).to eq(1)
-      expect(j.last_error).to match("execution expired")
+      expect(j.last_error).to match('execution expired')
     end
 
-    it 'schedules new job after deserialization error' do
-      Delayed::Worker.max_run_time = 1.second
+    it 'does not schedule new job after deserialization error' do
       job.update_column(:run_at, now)
       allow_any_instance_of(TestJob).to receive(:perform).and_raise(Delayed::DeserializationError)
 
       worker.work_off
 
-      expect(Delayed::Job.count).to eq(1)
-      j = Delayed::Job.first
-      expect(j.last_error).to match("Delayed::DeserializationError")
+      expect(Delayed::Job.count).to eq(0)
     end
 
     it 'has empty last_error after success' do
@@ -109,14 +116,20 @@ describe DelayedCronJob do
     end
 
     it 'uses correct db time for next run' do
-      if Time.now != now
-        job = Delayed::Job.enqueue(handler, cron: '* * * * *')
-        run = now.hour == 23 && now.min == 59 ? now + 1.day : now
-        hour = now.min == 59 ? (now.hour + 1) % 24 : now.hour
-        run_at = Time.utc(run.year, run.month, run.day, hour, (now.min + 1) % 60)
-        expect(job.run_at).to eq(run_at)
-      else
-        pending "This test only makes sense in non-UTC time zone"
+      local_zone = Time.zone
+      begin
+        Time.zone = nil
+        if Time.now != now
+          job = Delayed::Job.enqueue(handler, cron: '* * * * *')
+          run = now.hour == 23 && now.min == 59 ? now + 1.day : now
+          hour = now.min == 59 ? (now.hour + 1) % 24 : now.hour
+          run_at = Time.utc(run.year, run.month, run.day, hour, (now.min + 1) % 60)
+          expect(job.run_at).to eq(run_at)
+        else
+          pending 'This test only makes sense in non-UTC time zone'
+        end
+      ensure
+        Time.zone = local_zone
       end
     end
 
@@ -168,6 +181,35 @@ describe DelayedCronJob do
       expect { worker.work_off }.to change { Delayed::Job.count }.by(-1)
     end
 
+    context 'when database connection is lost' do
+      around(:each) do |example|
+        Delayed::Worker.plugins.unshift DatabaseDisconnectPlugin
+        # hold onto a connection so the in-memory database isn't lost when disconnected
+        temp_connection = ActiveRecord::Base.connection_pool.checkout
+        example.run
+        ActiveRecord::Base.connection_pool.checkin temp_connection
+        Delayed::Worker.plugins.delete DatabaseDisconnectPlugin
+      end
+
+      it 'does not lose the job if database connection is lost' do
+        job.update_column(:run_at, now)
+        job.reload # adjusts granularity of run_at datetime
+
+        begin
+          worker.work_off
+        rescue StandardError
+          # Attempting to save the clone delayed_job will raise an exception due to the database connection being closed
+        end
+
+        ActiveRecord::Base.connection.reconnect!
+
+        expect(Delayed::Job.count).to eq(1)
+        j = Delayed::Job.first
+        expect(j.id).to eq(job.id)
+        expect(j.cron).to eq(job.cron)
+        expect(j.attempts).to eq(0)
+      end
+    end
   end
 
   context 'without cron' do

data/spec/spec_helper.rb

@@ -21,9 +21,11 @@ require 'delayed_cron_job'
 Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 ENV['RAILS_ENV'] = 'test'
 
+Time.zone = EtOrbi.get_tzone(:local)
+
 ActiveJob::Base.queue_adapter = :delayed_job
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => 'file::memory:?cache=shared'
 ActiveRecord::Base.logger = Delayed::Worker.logger
 ActiveRecord::Migration.verbose = false
 

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: delayed_cron_job
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Pascal Zumkehr
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-30 00:00:00.000000000 Z
+date: 2021-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: delayed_job
+  name: fugit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,8 +129,8 @@ files:
 - lib/delayed_cron_job.rb
 - lib/delayed_cron_job/active_job/enqueuing.rb
 - lib/delayed_cron_job/active_job/queue_adapter.rb
+- lib/delayed_cron_job/backend/active_record/railtie.rb
 - lib/delayed_cron_job/backend/updatable_cron.rb
-- lib/delayed_cron_job/cronline.rb
 - lib/delayed_cron_job/plugin.rb
 - lib/delayed_cron_job/version.rb
 - lib/generators/delayed_job/cron_generator.rb
@@ -142,7 +142,7 @@ homepage: https://github.com/codez/delayed_cron_job
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -157,9 +157,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: An extension to Delayed::Job that allows you to set cron expressions for
   your jobs to run regularly.

data/lib/delayed_cron_job/cronline.rb

@@ -1,465 +0,0 @@
-#--
-# Copyright (c) 2006-2014, 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 DelayedCronJob
-
-  #
-  # A 'cron line' is a line in the sense of a crontab
-  # (man 5 crontab) file line.
-  #
-  class Cronline
-
-    # The string used for creating this cronline instance.
-    #
-    attr_reader :original
-
-    attr_reader :seconds
-    attr_reader :minutes
-    attr_reader :hours
-    attr_reader :days
-    attr_reader :months
-    attr_reader :weekdays
-    attr_reader :monthdays
-    attr_reader :timezone
-
-    def initialize(line)
-
-      raise ArgumentError.new(
-        "not a string: #{line.inspect}"
-      ) unless line.is_a?(String)
-
-      @original = line
-
-      items = line.split
-
-      @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
-      items.pop if @timezone
-
-      raise 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], 1, 31)
-      @months = parse_item(items[3 + offset], 1, 12)
-      @weekdays, @monthdays = parse_weekdays(items[4 + offset])
-
-      [ @seconds, @minutes, @hours, @months ].each do |es|
-
-        raise ArgumentError.new(
-          "invalid cronline: '#{line}'"
-        ) if es && es.find { |e| ! e.is_a?(Integer) }
-      end
-    end
-
-    # Returns true if the given time matches this cron line.
-    #
-    def matches?(time)
-
-      time = Time.at(time) unless time.kind_of?(Time)
-
-      time = @timezone.utc_to_local(time.getutc) if @timezone
-
-      return false unless sub_match?(time, :sec, @seconds)
-      return false unless sub_match?(time, :min, @minutes)
-      return false unless sub_match?(time, :hour, @hours)
-      return false unless date_match?(time)
-      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=Time.now)
-
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the next second
-      time = time + 1
-
-      loop do
-        unless date_match?(time)
-          dst = time.isdst
-          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
-          time -= 3600 if time.isdst != dst # not necessary for winter, but...
-          next
-        end
-        unless sub_match?(time, :hour, @hours)
-          time += (60 - time.min) * 60 - time.sec; next
-        end
-        unless sub_match?(time, :min, @minutes)
-          time += 60 - time.sec; next
-        end
-        unless sub_match?(time, :sec, @seconds)
-          time += 1; next
-        end
-
-        break
-      end
-
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
-
-      next_time(from + 3600)
-    end
-
-    # Returns the previous time the cronline matched. It's like next_time, but
-    # for the past.
-    #
-    def previous_time(from=Time.now)
-
-      time = local_time(from)
-      time = round_to_seconds(time)
-
-      # start at the previous second
-      time = time - 1
-
-      loop do
-        unless date_match?(time)
-          time -= time.hour * 3600 + time.min * 60 + time.sec + 1; next
-        end
-        unless sub_match?(time, :hour, @hours)
-          time -= time.min * 60 + time.sec + 1; next
-        end
-        unless sub_match?(time, :min, @minutes)
-          time -= time.sec + 1; next
-        end
-        unless sub_match?(time, :sec, @seconds)
-          time -= 1; next
-        end
-
-        break
-      end
-
-      global_time(time, from.utc?)
-
-    rescue TZInfo::PeriodNotFound
-
-      previous_time(time)
-    end
-
-    # Returns an array of 6 arrays (seconds, minutes, hours, days,
-    # months, weekdays).
-    # This method is used by the cronline unit tests.
-    #
-    def to_array
-
-      [
-        @seconds,
-        @minutes,
-        @hours,
-        @days,
-        @months,
-        @weekdays,
-        @monthdays,
-        @timezone ? @timezone.name : nil
-      ]
-    end
-
-    # 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, that can take more than seconds for a seconds
-    # level cron...
-    #
-    def frequency
-
-      return brute_frequency unless @seconds && @seconds.length > 1
-
-      delta = 60
-      prev = @seconds[0]
-
-      @seconds[1..-1].each do |sec|
-        d = sec - prev
-        delta = d if d < delta
-      end
-
-      delta
-    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...
-    #
-    # Since it's a rarely used method, I haven't taken the time to make it
-    # smarter/faster.
-    #
-    # One obvious improvement would be to cache the result once computed...
-    #
-    # See https://github.com/jmettraux/rufus-scheduler/issues/89
-    # for a discussion about this method.
-    #
-    def brute_frequency
-
-      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 t1.year == 2001
-
-        t0 = t1
-      end
-
-      delta
-    end
-
-    protected
-
-    WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
-    DAY_S = 24 * 3600
-    WEEK_S = 7 * DAY_S
-
-    def parse_weekdays(item)
-
-      return nil if item == '*'
-
-      items = item.downcase.split(',')
-
-      weekdays = nil
-      monthdays = nil
-
-      items.each do |it|
-
-        if m = it.match(/^(.+)#(l|-?[12345])$/)
-
-          raise ArgumentError.new(
-            "ranges are not supported for monthdays (#{it})"
-          ) if m[1].index('-')
-
-          expr = it.gsub(/#l/, '#-1')
-
-          (monthdays ||= []) << expr
-
-        else
-
-          expr = it.dup
-          WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
-
-          raise ArgumentError.new(
-            "invalid weekday expression (#{it})"
-          ) if expr !~ /^0*[0-7](-0*[0-7])?$/
-
-          its = expr.index('-') ? parse_range(expr, 0, 7) : [ Integer(expr) ]
-          its = its.collect { |i| i == 7 ? 0 : i }
-
-          (weekdays ||= []).concat(its)
-        end
-      end
-
-      weekdays = weekdays.uniq 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
-
-      raise ArgumentError.new(
-        "found duplicates in #{item.inspect}"
-      ) if r.uniq.size < r.size
-
-      r
-    end
-
-    RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
-
-    def parse_range(item, min, max)
-
-      return %w[ L ] if item == 'L'
-
-      item = '*' + item if item.match(/^\//)
-
-      m = item.match(RANGE_REGEX)
-
-      raise ArgumentError.new(
-        "cannot parse #{item.inspect}"
-      ) unless m
-
-      sta = m[1]
-      sta = sta == '*' ? min : 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
-
-      raise ArgumentError.new(
-        "#{item.inspect} is not in range #{min}..#{max}"
-      ) if sta < min || edn > max
-
-      r = []
-      val = sta
-
-      loop do
-        v = val
-        v = 0 if max == 24 && v == 24
-        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
-
-    def sub_match?(time, accessor, values)
-
-      value = time.send(accessor)
-
-      return true if values.nil?
-      return true if values.include?('L') && (time + DAY_S).day == 1
-
-      return true if value == 0 && accessor == :hour && values.include?(24)
-
-      values.include?(value)
-    end
-
-    def monthday_match?(date, values)
-
-      return true if values.nil?
-
-      today_values = monthdays(date)
-
-      (today_values & values).any?
-    end
-
-    def date_match?(date)
-
-      return false unless sub_match?(date, :day, @days)
-      return false unless sub_match?(date, :month, @months)
-      return false unless sub_match?(date, :wday, @weekdays)
-      return false unless monthday_match?(date, @monthdays)
-      true
-    end
-
-    def monthdays(date)
-
-      pos = 1
-      d = date.dup
-
-      loop do
-        d = d - WEEK_S
-        break if d.month != date.month
-        pos = pos + 1
-      end
-
-      neg = -1
-      d = date.dup
-
-      loop do
-        d = d + WEEK_S
-        break if d.month != date.month
-        neg = neg - 1
-      end
-
-      [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
-    end
-
-    def local_time(time)
-
-      @timezone ? @timezone.utc_to_local(time.getutc) : time
-    end
-
-    def global_time(time, from_in_utc)
-
-      if @timezone
-        time =
-          begin
-            @timezone.local_to_utc(time)
-          rescue TZInfo::AmbiguousTime
-            @timezone.local_to_utc(time, time.isdst)
-          end
-        time = time.getlocal unless from_in_utc
-      end
-
-      time
-    end
-
-    def round_to_seconds(time)
-
-      # Ruby 1.8 doesn't have #round
-      time.respond_to?(:round) ? time.round : time - time.usec * 1e-6
-    end
-  end
-end