que-scheduler 5.1.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8e6eface6f64e6dd63dfcd340528a0624e13fc0dc5d38e7c0aeaf9a233bf870
-  data.tar.gz: b89fe9c4ed0bf5e0897307b695e7ff614df9b4a3cd8187e78038ff50a7bab22b
+  metadata.gz: 6e3f6c1fe44aef0d369e7d6dc56a55ed53669e8946cf21204ca763224ecb83fc
+  data.tar.gz: 5595afbfb978657ab535b8b80cebbec532c2cff72abfa235718778a883d65ef3
 SHA512:
-  metadata.gz: 33d83f27fdf2f22beabcea208bb6f19dce018c8b60b9f29a82771a4e7b2fbd5ad25abd9e42559c2967db6bec26d89b67464a3f59ff4fa806685549ca45d4d5d5
-  data.tar.gz: 2b0239e99adac86c1dd5d2324e9bd120ecb36a46b35b7411682c40c57a5e8767d2aff44e1ecbe32cdf613b064b5f14455bf786343ca3969f1fadb2b54bae3896
+  metadata.gz: c4fcfc3d2835cbf22f9f6b8f9f98f5d2efa9d721687161fd5cffc482601eca4622051999d9fb280427fd8f1fa6a979273ff15448e5c78024b76bb1771c98327c
+  data.tar.gz: 2b122ec009cbb79325bd791fec250010f4e5f0d5daac9d50b327403267d36d9041d6a0eadb70ebae120b8bea48373a80b02969f0bbe0d852dcf607ab93a3020c

data/README.md

@@ -23,13 +23,14 @@ needs to be run, enqueueing those jobs, then enqueueing itself to check again la
 que-scheduler will look for it is `config/que_schedule.yml`. The format is essentially the same as
 resque-scheduler files, but with additional features.
 
-1. Add a migration to start the job scheduler and prepare the audit table. Note that this migration 
+1. Add a migration to prepare the audit table and start the job scheduler. Note that this migration 
    will fail if Que is set to execute jobs synchronously, i.e. `Que::Job.run_synchronously = true`.
 
     ```ruby
     class CreateQueSchedulerSchema < ActiveRecord::Migration[6.0]
       def change
         Que::Scheduler::Migrations.migrate!(version: 8)
+        Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
       end
     end
     ```
@@ -215,6 +216,7 @@ performed.
 class CreateQueSchedulerSchema < ActiveRecord::Migration[6.0]
   def change
     Que::Scheduler::Migrations.migrate!(version: 8)
+    Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
   end
 end
 ```
@@ -319,10 +321,6 @@ The latest version of que-scheduler supports Ruby 3.0 and above.
 que-scheduler versions below 4.4.0 work with Ruby 2.7.
 que-scheduler versions below 4.2.3 work with Ruby 2.5 and Ruby 2.6.
 
-Using que 0.x with Rails 6 needs a patch to support it. 
-See the patch and how to use it here: https://github.com/que-rb/que/issues/247#issuecomment-595258236
-If that patch is included then que-scheduler will work. This setup is tested, but is not supported.
-
 ## Inspiration
 
 This gem was inspired by the makers of the excellent [Que](https://github.com/chanks/que) job scheduler gem. 

data/lib/que/scheduler/audit.rb

@@ -24,9 +24,9 @@ module Que
 
       class << self
         def append(scheduler_job_id, executed_at, enqueued_jobs)
-          ::Que::Scheduler::VersionSupport.execute(INSERT_AUDIT, [scheduler_job_id, executed_at])
+          ::Que::Scheduler::DbSupport.execute(INSERT_AUDIT, [scheduler_job_id, executed_at])
           enqueued_jobs.each do |j|
-            inserted = ::Que::Scheduler::VersionSupport.execute(
+            inserted = ::Que::Scheduler::DbSupport.execute(
               INSERT_AUDIT_ENQUEUED,
               [scheduler_job_id] +
                 j.values_at(:job_class, :queue, :priority, :args, :job_id, :run_at)

data/lib/que/scheduler/configuration.rb

@@ -1,15 +1,17 @@
 require "que"
-require_relative "version_support"
+require_relative "db_support"
 
 module Que
   module Scheduler
+    # :reek:Attribute
     class Configuration
       attr_accessor :schedule_location, :schedule, :transaction_adapter, :que_scheduler_queue,
                     :time_zone
     end
 
     class << self
-      attr_accessor :configuration
+      # :reek:Attribute
+      attr_accessor :configuration # rubocop:disable ThreadSafety/ClassAndModuleAttributes
 
       def configure
         self.configuration ||= Configuration.new
@@ -22,7 +24,7 @@ module Que
             ENV.fetch("QUE_SCHEDULER_CONFIG_LOCATION", "config/que_schedule.yml")
           config.transaction_adapter = ::Que.method(:transaction)
           config.que_scheduler_queue =
-            ENV.fetch("QUE_SCHEDULER_QUEUE", Que::Scheduler::VersionSupport.default_scheduler_queue)
+            ENV.fetch("QUE_SCHEDULER_QUEUE", Que::DEFAULT_QUEUE)
           config.schedule = nil
           config.time_zone = nil
         end

data/lib/que/scheduler/db.rb

@@ -11,11 +11,11 @@ module Que
 
       class << self
         def count_schedulers
-          Que::Scheduler::VersionSupport.execute(SCHEDULER_COUNT_SQL).first.values.first.to_i
+          Que::Scheduler::DbSupport.execute(SCHEDULER_COUNT_SQL).first.values.first.to_i
         end
 
         def now
-          Que::Scheduler::VersionSupport.execute(NOW_SQL).first.values.first
+          Que::Scheduler::DbSupport.execute(NOW_SQL).first.values.first
         end
 
         # rubocop:disable Style/ExplicitBlockArgument

data/lib/que/scheduler/db_support.rb

@@ -0,0 +1,41 @@
+require "que"
+
+module Que
+  module Scheduler
+    module DbSupport
+      class << self
+        def job_attributes(enqueued_job)
+          enqueued_job.que_attrs.to_h.transform_keys(&:to_sym).tap do |hash|
+            hash[:job_id] = hash.delete(:id)
+          end
+        end
+
+        # Between Que versions the result of Que execute changed keys from strings to symbols.
+        # Here we wrap the concept and make sure either way produces symbols
+        def execute(str, args = [])
+          normalise_array_of_hashes(Que.execute(str, args))
+        end
+
+        def enqueue_a_job(clazz, job_options = {}, job_args = [])
+          if job_args.is_a?(Hash)
+            clazz.enqueue(job_args, job_options: job_options)
+          else
+            clazz.enqueue(*job_args, job_options: job_options)
+          end
+        end
+
+        def que_version
+          @que_version ||= que_version_object.to_s
+        end
+
+        private def que_version_object
+          @que_version_object ||= Gem.loaded_specs["que"].version
+        end
+
+        private def normalise_array_of_hashes(array)
+          array.map { |row| row.to_h.transform_keys(&:to_sym) }
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/defined_job.rb

@@ -54,7 +54,7 @@ module Que
         validate_job_class_related(options)
       end
 
-      # rubocop:disable Style/GuardClause This reads better as a conditional
+      # rubocop:disable Style/GuardClause -- This reads better as a conditional
       private def validate_fields_types(options)
         unless queue.nil? || queue.is_a?(String)
           err_field(:queue, options, "queue must be a string")

data/lib/que/scheduler/jobs/que_scheduler_audit_clear_down_job.rb

@@ -25,16 +25,16 @@ module Que
         DELETE_AUDIT_SQL = build_sql("que_scheduler_audit").freeze
 
         # Very low priority
-        Que::Scheduler::VersionSupport.set_priority(self, 100)
+        self.priority = 100
 
         def run(options)
           retain_row_count = options.symbolize_keys.fetch(:retain_row_count)
           Que::Scheduler::Db.transaction do
             # This may delete zero or more than `retain_row_count` depending on if anything was
             # scheduled in each of the past schedule runs
-            Que::Scheduler::VersionSupport.execute(DELETE_AUDIT_ENQUEUED_SQL, [retain_row_count])
+            Que::Scheduler::DbSupport.execute(DELETE_AUDIT_ENQUEUED_SQL, [retain_row_count])
             # This will delete all but `retain_row_count` oldest rows
-            count = Que::Scheduler::VersionSupport.execute(DELETE_AUDIT_SQL, [retain_row_count])
+            count = Que::Scheduler::DbSupport.execute(DELETE_AUDIT_SQL, [retain_row_count])
             log = "#{self.class} cleared down #{count.first.fetch(:count)} rows"
             ::Que.log(event: :"que-scheduler", message: log)
           end

data/lib/que/scheduler/migrations.rb

@@ -26,46 +26,59 @@ module Que
           end
         end
 
+        # rubocop:disable MagicNumbers/NoReturn
         def db_version
           if audit_table_exists?
-            return Que::Scheduler::VersionSupport.execute(TABLE_COMMENT).first[:description].to_i
+            return Que::Scheduler::DbSupport.execute(TABLE_COMMENT).first[:description].to_i
           end
 
-          Que::Scheduler::Db.count_schedulers.zero? ? 0 : 1
+          # At this point we used to be able to tell if it was 0 or 1 by the presence of the
+          # que_scheduler job, but that isn't auto enqueued anymore, so we assume it is 0.
+          0
         end
+        # rubocop:enable MagicNumbers/NoReturn
 
         def audit_table_exists?
-          result = Que::Scheduler::VersionSupport.execute(<<-SQL)
+          result = Que::Scheduler::DbSupport.execute(<<-SQL)
             SELECT * FROM information_schema.tables WHERE table_name = '#{AUDIT_TABLE_NAME}';
           SQL
           result.any?
         end
 
-        # This method is only intended for use in squashed migrations
+        # This method must be used during initial installation of que-scheduler and if the
+        # project migrations are squashed.
         def reenqueue_scheduler_if_missing
+          raise <<~MSG unless Que::Migrations.db_version >= 6
+            Cannot (re)enqueue the que-scheduler worker unless the Que migrations have been run to at least version 6.
+            This probably means you have an old migration that installed que-scheduler, and have then since
+            run in another migration that has upgraded que, and are now running the migrations from scratch into a new database.
+
+            To fix this, you should remove the "Que::Scheduler::Migrations.reenqueue_scheduler_if_missing" line from any
+            of the older migrations and add it after the last migration that updates Que to at least version 6. eg:
+
+            Que.migrate!(version: 6)
+            Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
+          MSG
           return unless Que::Scheduler::Db.count_schedulers.zero?
 
-          Que::Scheduler::VersionSupport.enqueue_a_job(Que::Scheduler::SchedulerJob)
+          Que::Scheduler::DbSupport.enqueue_a_job(Que::Scheduler::SchedulerJob)
         end
 
         private def migrate_up(current, version)
-          if current.zero? # Version 1 does not use SQL
-            Que::Scheduler::VersionSupport.enqueue_a_job(Que::Scheduler::SchedulerJob)
-          end
-          execute_step((current += 1), :up) until current == version
+          execute_step(current += 1, :up) until current == version
         end
 
         private def migrate_down(current, version)
           current += 1
-          execute_step((current -= 1), :down) until current == version + 1
+          execute_step(current -= 1, :down) until current == version + 1
         end
 
         private def execute_step(number, direction)
           sql = File.read("#{__dir__}/migrations/#{number}/#{direction}.sql")
-          Que::Scheduler::VersionSupport.execute(sql)
+          Que::Scheduler::DbSupport.execute(sql)
           return unless audit_table_exists?
 
-          Que::Scheduler::VersionSupport.execute(
+          Que::Scheduler::DbSupport.execute(
             "COMMENT ON TABLE que_scheduler_audit IS '#{direction == :up ? number : number - 1}'"
           )
         end

data/lib/que/scheduler/scheduler_job.rb

@@ -7,7 +7,7 @@ require_relative "enqueueing_calculator"
 require_relative "scheduler_job_args"
 require_relative "state_checks"
 require_relative "to_enqueue"
-require_relative "version_support"
+require_relative "db_support"
 
 # The main job that runs every minute, determining what needs to be enqueued, enqueues the required
 # jobs, then re-enqueues itself.
@@ -15,9 +15,14 @@ module Que
   module Scheduler
     class SchedulerJob < Que::Job
       SCHEDULER_FREQUENCY = 60
+      RETRY_PROC = proc { |count|
+        # Maximum one hour, otherwise use the default backoff
+        count > 7 ? (60 * 60) : ((count**4) + 3)
+      }
 
-      VersionSupport.set_priority(self, 0)
-      VersionSupport.apply_retry_semantics(self)
+      self.priority = 0 # Highest
+      self.maximum_retry_count = 1 << 128 # Heat death of universe
+      self.retry_interval = RETRY_PROC
 
       def run(options = nil)
         Que::Scheduler::Db.transaction do
@@ -59,12 +64,12 @@ module Que
       private def enqueue_self_again(scheduler_job_args, last_full_execution, job_dictionary,
                                      enqueued_jobs)
         # Log last run...
-        job_id = VersionSupport.job_attributes(self).fetch(:job_id)
+        job_id = DbSupport.job_attributes(self).fetch(:job_id)
         Audit.append(job_id, scheduler_job_args.as_time, enqueued_jobs)
 
         # And rerun...
         next_run_at = scheduler_job_args.as_time.beginning_of_minute + SCHEDULER_FREQUENCY
-        enqueued_job = Que::Scheduler::VersionSupport.enqueue_a_job(
+        enqueued_job = Que::Scheduler::DbSupport.enqueue_a_job(
           SchedulerJob,
           {
             queue: Que::Scheduler.configuration.que_scheduler_queue,
@@ -76,8 +81,8 @@ module Que
           }
         )
 
-        # rubocop:disable Style/GuardClause This reads better as a conditional
-        unless enqueued_job && VersionSupport.job_attributes(enqueued_job).fetch(:job_id)
+        # rubocop:disable Style/GuardClause -- This reads better as a conditional
+        unless enqueued_job && DbSupport.job_attributes(enqueued_job).fetch(:job_id)
           raise "SchedulerJob could not self-schedule. Has `.enqueue` been monkey patched?"
         end
         # rubocop:enable Style/GuardClause

data/lib/que/scheduler/state_checks.rb

@@ -16,8 +16,8 @@ module Que
           return if db_version == Que::Scheduler::Migrations::MAX_VERSION
 
           sync_err =
-            if Que::Scheduler::VersionSupport.running_synchronously? && db_version.zero?
-              code = Que::Scheduler::VersionSupport.running_synchronously_code?
+            if Que.run_synchronously && db_version.zero?
+              code = "Que.run_synchronously = true"
               <<~ERR_SYNC
                 You currently have Que to run in synchronous mode using
                 #{code}, so it is most likely this error
@@ -51,6 +51,7 @@ module Que
             class UpdateQueSchedulerSchema < ActiveRecord::Migration[6.0]
               def change
                 Que::Scheduler::Migrations.migrate!(version: #{Que::Scheduler::Migrations::MAX_VERSION})
+                Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
               end
             end
 

data/lib/que/scheduler/to_enqueue.rb

@@ -63,7 +63,7 @@ module Que
     class QueJobType < ToEnqueue
       def enqueue
         job_settings = to_h.slice(:queue, :priority, :run_at).compact
-        job = Que::Scheduler::VersionSupport.enqueue_a_job(
+        job = Que::Scheduler::DbSupport.enqueue_a_job(
           job_class,
           job_settings,
           args
@@ -73,7 +73,7 @@ module Que
 
         # Now read the just inserted job back out of the DB to get the actual values that will
         # be used when the job is worked.
-        values = Que::Scheduler::VersionSupport.job_attributes(job).slice(
+        values = Que::Scheduler::DbSupport.job_attributes(job).slice(
           :args, :queue, :priority, :run_at, :job_class, :job_id
         )
         EnqueuedJobType.new(values)
@@ -121,7 +121,7 @@ module Que
         job_settings = {
           priority: priority,
           wait_until: run_at,
-          queue: queue || Que::Scheduler::VersionSupport.default_scheduler_queue,
+          queue: queue || Que::DEFAULT_QUEUE,
         }.compact
 
         job_class_set = job_class.set(**job_settings)

data/lib/que/scheduler/version.rb

@@ -1,5 +1,5 @@
 module Que
   module Scheduler
-    VERSION = "5.1.1".freeze
+    VERSION = "6.0.0".freeze # New major
   end
 end

data/lib/que/scheduler.rb

@@ -1,5 +1,5 @@
 require "que/scheduler/version"
-require "que/scheduler/version_support"
+require "que/scheduler/db_support"
 require "que/scheduler/configuration"
 require "que/scheduler/time_zone"
 require "que/scheduler/scheduler_job"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que-scheduler
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Harry Lascelles
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-21 00:00:00.000000000 Z
+date: 2025-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -70,20 +70,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +118,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: climate_control
   requirement: !ruby/object:Gem::Requirement
@@ -202,6 +216,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -314,20 +342,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.5.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -383,6 +425,7 @@ files:
 - lib/que/scheduler/audit.rb
 - lib/que/scheduler/configuration.rb
 - lib/que/scheduler/db.rb
+- lib/que/scheduler/db_support.rb
 - lib/que/scheduler/defined_job.rb
 - lib/que/scheduler/enqueueing_calculator.rb
 - lib/que/scheduler/jobs/que_scheduler_audit_clear_down_job.rb
@@ -410,7 +453,6 @@ files:
 - lib/que/scheduler/time_zone.rb
 - lib/que/scheduler/to_enqueue.rb
 - lib/que/scheduler/version.rb
-- lib/que/scheduler/version_support.rb
 homepage: https://github.com/hlascelles/que-scheduler
 licenses:
 - MIT
@@ -429,14 +471,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A cron scheduler for Que

data/lib/que/scheduler/version_support.rb

@@ -1,109 +0,0 @@
-require "que"
-
-# The purpose of this module is to centralise the differences when supporting both que 0.x and
-# 1.x with the same gem.
-module Que
-  module Scheduler
-    module VersionSupport
-      RETRY_PROC = proc { |count|
-        # Maximum one hour, otherwise use the default backoff
-        count > 7 ? (60 * 60) : ((count**4) + 3)
-      }
-
-      class << self
-        # Ensure que-scheduler runs at the highest priority. This is because its priority is a
-        # the top of all jobs it enqueues.
-        def set_priority(context, priority)
-          if zero_major?
-            context.instance_variable_set(:@priority, priority)
-          else
-            context.priority = priority
-          end
-        end
-
-        # Ensure the job runs at least once an hour when it is backing off due to errors
-        def apply_retry_semantics(context)
-          if zero_major?
-            context.instance_variable_set(:@retry_interval, RETRY_PROC)
-          else
-            context.maximum_retry_count = 1 << 128 # Heat death of universe
-            context.retry_interval = RETRY_PROC
-          end
-        end
-
-        def job_attributes(enqueued_job)
-          if zero_major?
-            enqueued_job.attrs.to_h.transform_keys(&:to_sym)
-          else
-            enqueued_job.que_attrs.to_h.transform_keys(&:to_sym).tap do |hash|
-              hash[:job_id] = hash.delete(:id)
-            end
-          end
-        end
-
-        # Between Que 0.x and 1.x the result of Que execute changed keys from strings to symbols.
-        # Here we wrap the concept and make sure either way produces symbols
-        def execute(str, args = [])
-          normalise_array_of_hashes(Que.execute(str, args))
-        end
-
-        # rubocop:disable Style/IfInsideElse
-        def enqueue_a_job(clazz, job_options = {}, job_args = [])
-          if supports_job_options_keyword?
-            # More recent versions have separated the way job arguments and options are passed in
-            if job_args.is_a?(Hash)
-              clazz.enqueue(job_args, job_options: job_options)
-            else
-              clazz.enqueue(*job_args, job_options: job_options)
-            end
-          else
-            if job_args.is_a?(Hash)
-              clazz.enqueue(**job_args.merge(job_options))
-            else
-              clazz.enqueue(*job_args, **job_options)
-            end
-          end
-        end
-
-        # rubocop:enable Style/IfInsideElse
-        def default_scheduler_queue
-          zero_major? ? "" : Que::DEFAULT_QUEUE
-        end
-
-        def running_synchronously?
-          zero_major? ? (Que.mode == :sync) : Que.run_synchronously
-        end
-
-        def running_synchronously_code?
-          zero_major? ? "Que.mode == :sync" : "Que.run_synchronously = true"
-        end
-
-        def zero_major?
-          # This is the only way to handle beta releases too
-          @zero_major ||= que_version.split(".").first.to_i.zero?
-        end
-
-        def one_major?
-          # This is the only way to handle beta releases too
-          @one_major ||= que_version.split(".").first.to_i == 1
-        end
-
-        def que_version
-          @que_version ||= que_version_object.to_s
-        end
-
-        private def supports_job_options_keyword?
-          @supports_job_options_keyword ||= que_version_object >= Gem::Version.new("1.2.0")
-        end
-
-        private def que_version_object
-          @que_version_object ||= Gem.loaded_specs["que"].version
-        end
-
-        private def normalise_array_of_hashes(array)
-          array.map { |row| row.to_h.transform_keys(&:to_sym) }
-        end
-      end
-    end
-  end
-end