Removed Sorbet for release

app/models/disqualified/base_record.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 class Disqualified::BaseRecord < ActiveRecord::Base
   self.abstract_class = true
 end

app/models/disqualified/record.rb

@@ -1,8 +1,4 @@
-# typed: strict
-
 class Disqualified::Record < Disqualified::BaseRecord
-  extend T::Sig
-
   self.table_name = "disqualified_jobs"
 
   belongs_to :disqualified_sequence,
@@ -18,9 +14,6 @@ class Disqualified::Record < Disqualified::BaseRecord
   scope :pending, -> { where(finished_at: nil, run_at: (..Time.now), locked_by: nil) }
   scope :runnable, -> { with_sequence.pending }
 
-  sig do
-    params(id: T.nilable(T.any(Integer, String))).returns(Disqualified::Record)
-  end
   def self.claim_one!(id: nil)
     run_id = SecureRandom.uuid
     association =
@@ -47,7 +40,6 @@ def self.claim_one!(id: nil)
     raise Disqualified::Error::NoClaimableJob
   end
 
-  sig { returns(Disqualified::Record) }
   def run!
     record = self.class.claim_one!(id:)
     begin
@@ -61,29 +53,26 @@ def run!
     record
   end
 
-  sig { void }
   def finish
     transaction do
       update!(locked_by: nil, locked_at: nil, finished_at: Time.now)
       if sequence_uuid && sequence_step
         Disqualified::SequenceRecord
           .where(uuid: sequence_uuid, current_step: sequence_step)
           .update_all(
-            current_step: T.must(sequence_step) + 1,
+            current_step: sequence_step + 1,
             updated_at: Time.now
           )
       end
     end
   end
 
-  sig { void }
   def requeue
     retry_count = attempts - 1
     sleep = (retry_count**4) + 15 + (rand(10) * (retry_count + 1))
     unclaim(next_run_at: Time.now + sleep)
   end
 
-  sig { params(next_run_at: T.nilable(Time)).void }
   def unclaim(next_run_at: nil)
     if next_run_at
       update!(locked_by: nil, locked_at: nil, run_at: next_run_at)
@@ -92,7 +81,6 @@ def unclaim(next_run_at: nil)
     end
   end
 
-  sig { void }
   private def instantiate_handler_and_perform_with_args
     raise Disqualified::Error::JobAlreadyFinished if !finished_at.nil?
     raise Disqualified::Error::JobNotClaimed if locked_by.nil?

app/models/disqualified/sequence_record.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 class Disqualified::SequenceRecord < Disqualified::BaseRecord
   self.table_name = "disqualified_sequences"
 end

lib/disqualified.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module Disqualified
 end
 

lib/disqualified/active_job.rb

@@ -1,13 +1,9 @@
-# typed: strict
-
 require "active_job"
 require "disqualified"
 
 class Disqualified::ActiveJobAdapter
-  extend T::Sig
   include Disqualified::Job
 
-  sig { params(serialized_job_data: T::Hash[String, T.untyped]).void }
   def perform(serialized_job_data)
     ::ActiveJob::Base.execute(serialized_job_data)
   end
@@ -16,19 +12,14 @@ def perform(serialized_job_data)
 module ActiveJob
   module QueueAdapters
     class DisqualifiedAdapter
-      extend T::Sig
-
-      sig { returns(T::Boolean) }
       def enqueue_after_transaction_commit?
         Disqualified.client_options.enqueue_after_transaction_commit
       end
 
-      sig { params(job_data: ActiveJob::Base).void }
       def enqueue(job_data)
         Disqualified::ActiveJobAdapter.perform_async(job_data.serialize)
       end
 
-      sig { params(job_data: ActiveJob::Base, timestamp: Numeric).void }
       def enqueue_at(job_data, timestamp)
         timestamp = Time.at(timestamp)
         Disqualified::ActiveJobAdapter.perform_at(timestamp, job_data.serialize)

lib/disqualified/cli.rb

@@ -1,10 +1,6 @@
-# typed: strict
-
 class Disqualified::CLI
-  extend T::Sig
   include Disqualified::Logging
 
-  sig { void }
   def self.run
     cli = new(ARGV)
     cli.run
@@ -16,18 +12,16 @@ class ServerEngine < Rails::Engine
     end
   end
 
-  sig { params(argv: T::Array[String]).void }
   def initialize(argv)
     @original_argv = argv
   end
 
-  sig { void }
   def run
     require File.join(Dir.pwd, "config/environment")
 
     option_parser.parse(@original_argv)
 
-    server_options = T.must(Disqualified.server_options)
+    server_options = Disqualified.server_options
     delay_range = server_options.delay_range
     error_hooks = server_options.error_hooks
     logger = server_options.logger
@@ -57,14 +51,13 @@ def run
 
   private
 
-  sig { returns(OptionParser) }
   def option_parser
-    return T.must(@option_parser) if instance_variable_defined?(:@option_parser)
+    return @option_parser if instance_variable_defined?(:@option_parser)
 
     option_parser = OptionParser.new do |opts|
       opts.banner = "Usage: #{File.basename($0)} [OPTIONS]"
 
-      server_options = T.must(Disqualified.server_options)
+      server_options = Disqualified.server_options
 
       opts.on("--delay-low SECONDS", Numeric, "Default: #{server_options.delay_low}") do |value|
         server_options.delay_low = value
@@ -84,6 +77,6 @@ def option_parser
       end
     end
 
-    @option_parser ||= T.let(option_parser, T.nilable(OptionParser))
+    @option_parser ||= option_parser
   end
 end

lib/disqualified/configuration.rb

@@ -1,29 +1,20 @@
-# typed: strict
-
 module Disqualified
-  extend T::Sig
-
-  @client_options = T.let(ClientConfiguration.new, ClientConfiguration)
+  @client_options = ClientConfiguration.new
 
   class << self
-    extend T::Sig
-
-    sig { returns(Disqualified::ClientConfiguration) }
     attr_accessor :client_options
 
-    sig { returns(T.nilable(Disqualified::ServerConfiguration)) }
     attr_accessor :server_options
 
-    sig { params(block: T.proc.params(arg0: Disqualified::ClientConfiguration).void).void }
     def configure_client(&block)
       block.call(client_options)
     end
 
     # While client options are always run, server options only run in the "disqualified" process
-    sig { params(block: T.proc.params(arg0: Disqualified::ServerConfiguration).void).void }
+
     def configure_server(&block)
       if server_options
-        block.call(T.must(server_options))
+        block.call(server_options)
       end
     end
   end

lib/disqualified/configuration_structs.rb

@@ -1,56 +1,43 @@
-# typed: strict
-
 class Disqualified::ClientConfiguration
-  extend T::Sig
-
-  sig { void }
   def initialize
-    @enqueue_after_transaction_commit = T.let(false, T::Boolean)
+    @enqueue_after_transaction_commit = false
   end
 
-  sig { returns(T::Boolean) }
   attr_accessor :enqueue_after_transaction_commit
 end
 
 class Disqualified::ServerConfiguration
-  extend T::Sig
-
-  sig { void }
   def initialize
-    @delay_high = T.let(5.0, Numeric)
-    @delay_low = T.let(1.0, Numeric)
-    @logger = T.let(Rails.logger, T.untyped)
-    @pool_size = T.let(5, Integer)
-    @pwd = T.let(Dir.pwd, String)
-    @error_hooks = T.let([], T::Array[Disqualified::Logging::ERROR_HOOK_TYPE])
+    @delay_high = 5.0
+    @delay_low = 1.0
+    @logger = Rails.logger
+    @pool_size = 5
+    @pwd = Dir.pwd
+    @error_hooks = []
   end
 
-  sig { returns(Numeric) }
   attr_accessor :delay_high
-  sig { returns(Numeric) }
+
   attr_accessor :delay_low
-  sig { returns(T::Array[Disqualified::Logging::ERROR_HOOK_TYPE]) }
+
   attr_accessor :error_hooks
-  sig { returns(T.untyped) }
+
   attr_accessor :logger
-  sig { returns(Integer) }
+
   attr_accessor :pool_size
-  sig { returns(String) }
+
   attr_accessor :pwd
 
   private :error_hooks=
 
-  sig { returns(T::Range[Float]) }
   def delay_range
     delay_low.to_f..delay_high.to_f
   end
 
-  sig { params(block: Disqualified::Logging::ERROR_HOOK_TYPE).void }
   def on_error(&block)
     error_hooks.push(block)
   end
 
-  sig { returns(String) }
   def to_s
     "{ delay: #{delay_range}, pool_size: #{pool_size}, error_hooks_size: #{error_hooks.size} }"
   end

lib/disqualified/engine.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module Disqualified
   class Engine < ::Rails::Engine
   end

lib/disqualified/error.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module Disqualified
   module Error
     class DisqualifiedError < StandardError

lib/disqualified/job.rb

@@ -1,12 +1,5 @@
-# typed: strict
-
 module Disqualified::Job
-  extend T::Helpers
-
   module ClassMethods
-    extend T::Sig
-
-    sig { params(the_time: T.any(Time, Date, ActiveSupport::TimeWithZone), args: T.untyped).void }
     def perform_at(the_time, *args)
       if Thread.current[Disqualified::Sequence::UUID]
         Thread.current[Disqualified::Sequence::COUNT] += 1
@@ -15,7 +8,7 @@ def perform_at(the_time, *args)
       end
 
       Disqualified::Record.create!(
-        handler: T.unsafe(self).name,
+        handler: name,
         arguments: JSON.dump(args),
         queue: "default",
         run_at: the_time,
@@ -24,16 +17,16 @@ def perform_at(the_time, *args)
       )
     end
 
-    sig { params(args: T.untyped).void }
     def perform_async(*args)
-      T.unsafe(self).perform_at(Time.now, *args)
+      perform_at(Time.now, *args)
     end
 
-    sig { params(delay: T.any(Numeric, ActiveSupport::Duration), args: T.untyped).void }
     def perform_in(delay, *args)
-      T.unsafe(self).perform_at(T.unsafe(Time.now) + delay, *args)
+      perform_at(Time.now + delay, *args)
     end
   end
 
-  mixes_in_class_methods(ClassMethods)
+  def self.included(other)
+    other.extend(ClassMethods)
+  end
 end

lib/disqualified/logging.rb

@@ -1,8 +1,4 @@
-# typed: strict
-
 module Disqualified::Logging
-  extend T::Sig
-
   ERROR_CONTEXT_TYPE = T.type_alias do
     T::Hash[T.untyped, T.untyped]
   end
@@ -13,7 +9,6 @@ module Disqualified::Logging
 
   module_function
 
-  sig { params(parts: T.untyped).void }
   def format_log(*parts)
     *extras, message = parts
 
@@ -24,7 +19,6 @@ def format_log(*parts)
     end
   end
 
-  sig { params(error_hooks: T::Array[ERROR_HOOK_TYPE], error: Exception, context: ERROR_CONTEXT_TYPE).void }
   def handle_error(error_hooks, error, context)
     error_hooks.each do |hook|
       hook.call(error, context)

lib/disqualified/main.rb

@@ -1,16 +1,11 @@
-# typed: strict
-
 class Disqualified::Main
-  extend T::Sig
   include Disqualified::Logging
 
-  sig { params(error_hooks: T::Array[Disqualified::Logging::ERROR_HOOK_TYPE], logger: T.untyped).void }
   def initialize(error_hooks:, logger:)
     @error_hooks = error_hooks
     @logger = logger
   end
 
-  sig { void }
   def call
     Rails.application.reloader.wrap do
       record = Disqualified::Record.claim_one!
@@ -25,7 +20,6 @@ def call
         format_log("Disqualified::Main#call", "No claimable jobs")
       end
     rescue => e
-      record = T.must(record)
       handle_error(@error_hooks, e, {record: record.attributes})
       @logger.error { format_log("Disqualified::Main#run", "Runner #{run_id}", "Rescued Record ##{record.id}") }
       record.requeue