rubocop-sidekiq_plus 0.1.0

data/lib/rubocop/cop/sidekiq/date_time_argument.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for Date/Time/DateTime objects passed to Sidekiq job methods.
+      #
+      # Date and Time objects should be converted to strings or timestamps
+      # before being passed to Sidekiq jobs to ensure proper serialization.
+      #
+      # @example
+      #   # bad
+      #   MyJob.perform_async(Time.current)
+      #   MyJob.perform_async(Date.today)
+      #   MyJob.perform_async(DateTime.now)
+      #
+      #   # good
+      #   MyJob.perform_async(Time.current.iso8601)
+      #   MyJob.perform_async(Date.today.to_s)
+      #   MyJob.perform_async(Time.current.to_i)
+      #
+      class DateTimeArgument < Base
+        include ArgumentTraversal
+
+        MSG = 'Do not pass Date/Time objects to Sidekiq jobs. ' \
+              'Convert to a string or timestamp first.'
+
+        RESTRICT_ON_SEND = PerformMethods.all
+
+        TIME_METHODS = %i[now current zone].freeze
+        DATE_METHODS = %i[today yesterday tomorrow current].freeze
+
+        # @!method sidekiq_perform_call?(node)
+        def_node_matcher :sidekiq_perform_call?, <<~PATTERN
+          (send _ {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} $...)
+        PATTERN
+
+        # @!method time_constructor?(node)
+        def_node_matcher :time_constructor?, <<~PATTERN
+          (send (const {nil? cbase} :Time) {#{TIME_METHODS.map(&:inspect).join(' ')}} ...)
+        PATTERN
+
+        # @!method date_constructor?(node)
+        def_node_matcher :date_constructor?, <<~PATTERN
+          (send (const {nil? cbase} :Date) {#{DATE_METHODS.map(&:inspect).join(' ')}} ...)
+        PATTERN
+
+        # @!method datetime_constructor?(node)
+        def_node_matcher :datetime_constructor?, <<~PATTERN
+          (send (const {nil? cbase} :DateTime) {:now :current :parse} ...)
+        PATTERN
+
+        def on_send(node)
+          sidekiq_perform_call?(node) do |args|
+            check_arguments(args)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_argument(arg)
+          if datetime_object?(arg)
+            add_offense(arg)
+          elsif arg.hash_type?
+            check_hash_values(arg)
+          elsif arg.array_type?
+            check_array_elements(arg)
+          end
+        end
+
+        def datetime_object?(node)
+          return false unless node.send_type?
+
+          time_constructor?(node) || date_constructor?(node) || datetime_constructor?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/deprecated_default_worker_options.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for deprecated Sidekiq.default_worker_options usage.
+      #
+      # @example
+      #   # bad
+      #   Sidekiq.default_worker_options = { retry: 5 }
+      #
+      #   # good
+      #   Sidekiq.default_job_options = { retry: 5 }
+      #
+      class DeprecatedDefaultWorkerOptions < Base
+        extend AutoCorrector
+
+        MSG = 'Sidekiq.default_worker_options is deprecated. Use Sidekiq.default_job_options instead.'
+
+        RESTRICT_ON_SEND = %i[default_worker_options default_worker_options=].freeze
+
+        def on_send(node)
+          return unless sidekiq_receiver?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, replacement_selector(node))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def sidekiq_receiver?(node)
+          receiver = node.receiver
+          receiver&.const_type? && receiver.const_name == 'Sidekiq'
+        end
+
+        def replacement_selector(_node)
+          'default_job_options'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/deprecated_delay_extension.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for deprecated delay extension usage.
+      #
+      # @example
+      #   # bad
+      #   UserMailer.delay.welcome_email(user)
+      #
+      #   # good
+      #   UserMailer.welcome_email(user).deliver_later
+      #
+      class DeprecatedDelayExtension < Base
+        MSG = 'Avoid using the delay extension. Use `deliver_later` or enqueue a Sidekiq job instead.'
+
+        RESTRICT_ON_SEND = %i[delay].freeze
+
+        def on_send(node)
+          return unless node.arguments.empty?
+
+          add_offense(node.loc.selector)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/deprecated_worker_module.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for Sidekiq::Worker usage and recommends Sidekiq::Job.
+      #
+      # @example
+      #   # bad
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      class DeprecatedWorkerModule < Base
+        extend AutoCorrector
+
+        MSG = 'Sidekiq::Worker is deprecated. Use Sidekiq::Job instead.'
+
+        # @!method sidekiq_worker_include?(node)
+        def_node_matcher :sidekiq_worker_include?, <<~PATTERN
+          (send nil? :include (const (const {nil? cbase} :Sidekiq) :Worker))
+        PATTERN
+
+        def on_send(node)
+          sidekiq_worker_include?(node) do
+            add_offense(node) do |corrector|
+              corrector.replace(node, 'include Sidekiq::Job')
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/enqueue_inefficiency.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for perform_async calls inside loops and recommends perform_bulk.
+      #
+      # @example
+      #   # bad
+      #   users.each do |user|
+      #     NotifyJob.perform_async(user.id)
+      #   end
+      #
+      #   # good
+      #   user_ids = users.map { |user| [user.id] }
+      #   NotifyJob.perform_bulk(user_ids)
+      #
+      class EnqueueInefficiency < Base
+        MSG = 'Prefer `perform_bulk` over `perform_async` inside loops to reduce Redis round trips.'
+
+        DEFAULT_ALLOWED_METHODS = %w[each find_each find_in_batches].freeze
+
+        def on_block(node)
+          send_node = node.send_node
+          return unless allowed_method?(send_node)
+          return unless meets_minimum_iterations?(send_node)
+
+          check_send(node.body)
+        end
+
+        def on_numblock(node)
+          on_block(node)
+        end
+
+        private
+
+        def check_send(body_node)
+          return unless body_node
+
+          add_offense(body_node) if body_node.send_type? && body_node.method?(:perform_async)
+
+          body_node.each_descendant(:send) do |send|
+            next unless send.method?(:perform_async)
+
+            add_offense(send)
+          end
+        end
+
+        def allowed_method?(send_node)
+          allowed_methods = cop_config.fetch('AllowedMethods', DEFAULT_ALLOWED_METHODS)
+          allowed_methods.include?(send_node.method_name.to_s)
+        end
+
+        def meets_minimum_iterations?(send_node)
+          minimum = cop_config['MinimumIterations']
+          return true unless minimum
+
+          iteration_count = iteration_count(send_node)
+          return true unless iteration_count
+
+          iteration_count >= minimum
+        end
+
+        def iteration_count(send_node)
+          return unless send_node.method?(:times)
+
+          receiver = send_node.receiver
+          return unless receiver&.int_type?
+
+          receiver.value
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/excessive_retry.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for excessive retry counts in sidekiq_options.
+      #
+      # @example MaxRetries: 25 (default)
+      #   # bad
+      #   sidekiq_options retry: 100
+      #
+      class ExcessiveRetry < Base
+        MSG = 'Retry count exceeds the maximum allowed (%<max>d).'
+
+        def on_send(node)
+          sidekiq_options_call?(node) do |args|
+            args.each { |arg| check_hash(arg) }
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_hash(arg)
+          return unless arg.hash_type?
+
+          arg.pairs.each do |pair|
+            check_pair(pair)
+          end
+        end
+
+        def check_pair(pair)
+          return unless retry_key?(pair.key)
+
+          value = pair.value
+          return unless value&.int_type?
+          return unless value.value > max_retries
+
+          add_offense(value, message: format(MSG, max: max_retries))
+        end
+
+        def retry_key?(node)
+          node&.sym_type? && node.value == :retry
+        end
+
+        def max_retries
+          cop_config.fetch('MaxRetries', 25)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/find_each_in_job.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for find_each/find_in_batches usage inside Sidekiq job perform methods.
+      #
+      # @example
+      #   # bad
+      #   class ProcessAllUsersJob
+      #     include Sidekiq::Job
+      #
+      #     def perform
+      #       User.find_each { |user| process(user) }
+      #     end
+      #   end
+      #
+      #   # good
+      #   class ProcessUserJob
+      #     include Sidekiq::Job
+      #
+      #     def perform(user_id)
+      #       user = User.find(user_id)
+      #       process(user)
+      #     end
+      #   end
+      #
+      class FindEachInJob < Base
+        MSG = 'Avoid processing large datasets in a single Sidekiq job. Split into smaller jobs instead.'
+
+        DEFAULT_ALLOWED_METHODS = [].freeze
+        RESTRICT_ON_SEND = %i[find_each find_in_batches].freeze
+
+        def on_send(node)
+          return unless in_sidekiq_job?(node)
+          return unless in_perform_method?(node)
+          return if allowed_method?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def in_perform_method?(node)
+          node.each_ancestor(:any_def).any? do |def_node|
+            def_node.method?(:perform)
+          end
+        end
+
+        def allowed_method?(node)
+          allowed_methods = cop_config.fetch('AllowedMethods', DEFAULT_ALLOWED_METHODS)
+          allowed_methods.include?(node.method_name.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/huge_job_arguments.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for potentially huge arguments passed to Sidekiq jobs.
+      #
+      # @example
+      #   # bad
+      #   MyJob.perform_async(users.pluck(:id, :name, :email))
+      #   MyJob.perform_async([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+      #
+      #   # good
+      #   MyJob.perform_async(user_ids)
+      #
+      class HugeJobArguments < Base
+        MSG = 'Avoid passing large arguments to Sidekiq jobs. Pass IDs and load records in the job instead.'
+
+        DEFAULT_MAX_ARRAY_SIZE = 10
+        DEFAULT_MAX_HASH_SIZE = 10
+        DEFAULT_MAX_PLUCK_COLUMNS = 3
+
+        def on_send(node)
+          perform_call?(node) do
+            node.arguments.each do |arg|
+              check_argument(arg)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def check_argument(arg)
+          return unless large_pluck?(arg) || large_array?(arg) || large_hash?(arg)
+
+          add_offense(arg)
+        end
+
+        def large_pluck?(arg)
+          return false unless arg.send_type?
+          return false unless arg.method?(:pluck)
+
+          arg.arguments.size >= max_pluck_columns
+        end
+
+        def large_array?(arg)
+          return false unless arg.array_type?
+
+          arg.values.size > max_array_size
+        end
+
+        def large_hash?(arg)
+          return false unless arg.hash_type?
+
+          arg.pairs.size > max_hash_size
+        end
+
+        def max_array_size
+          cop_config.fetch('MaxArraySize', DEFAULT_MAX_ARRAY_SIZE)
+        end
+
+        def max_hash_size
+          cop_config.fetch('MaxHashSize', DEFAULT_MAX_HASH_SIZE)
+        end
+
+        def max_pluck_columns
+          cop_config.fetch('MaxPluckColumns', DEFAULT_MAX_PLUCK_COLUMNS)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/job_dependency.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for implicit job dependencies (enqueuing other jobs inside jobs).
+      #
+      # @example
+      #   # bad
+      #   def perform
+      #     SecondJob.perform_async
+      #   end
+      #
+      class JobDependency < Base
+        MSG = 'Avoid implicit job dependencies. Use Sidekiq Batches instead.'
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+
+          node.each_descendant(:send) do |send|
+            next unless perform_call?(send)
+
+            add_offense(send)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/job_file_location.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that Sidekiq job classes are located in allowed directories.
+      #
+      # @example
+      #   # bad - app/models/send_email_job.rb
+      #   class SendEmailJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good - app/jobs/send_email_job.rb
+      #   class SendEmailJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      class JobFileLocation < Base
+        include ProcessedSourcePath
+
+        MSG = 'Place Sidekiq job classes under %<dirs>s.'
+
+        DEFAULT_DIRECTORIES = ['app/jobs', 'app/workers'].freeze
+
+        def on_class(node)
+          return unless sidekiq_job_class?(node)
+
+          file_path = processed_file_path
+          return unless file_path
+
+          return if in_allowed_directory?(file_path)
+
+          add_offense(node.loc.keyword, message: format(MSG, dirs: allowed_directories.join(' or ')))
+        end
+
+        private
+
+        def allowed_directories
+          cop_config.fetch('AllowedDirectories', DEFAULT_DIRECTORIES)
+        end
+
+        def in_allowed_directory?(file_path)
+          allowed_directories.any? do |dir|
+            file_path.include?("/#{dir}/") || file_path.include?("#{dir}/") ||
+              file_path.end_with?("/#{dir}") || file_path.end_with?(dir)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/job_file_naming.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that job file names match the class name.
+      #
+      # @example
+      #   # bad - file: send_email_worker.rb
+      #   class SendEmailJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      class JobFileNaming < Base
+        include ClassNameHelper
+        include ProcessedSourcePath
+
+        MSG = 'Job file name should match the class name.'
+
+        def on_class(node)
+          return unless sidekiq_job_class?(node)
+
+          file_path = processed_file_path
+          return unless file_path
+
+          class_name = class_name(node)
+          return unless class_name
+
+          expected = underscore(class_name)
+          actual = File.basename(file_path, '.rb')
+          return if expected == actual
+
+          add_offense(node.loc.keyword)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/job_include.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that Sidekiq jobs include the preferred module.
+      #
+      # Sidekiq::Worker was renamed to Sidekiq::Job in Sidekiq 6.3.
+      # Sidekiq::Job is the preferred module name.
+      #
+      # @example PreferredModule: Job (default)
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Worker
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      # @example PreferredModule: Worker
+      #   # bad
+      #   class MyJob
+      #     include Sidekiq::Job
+      #   end
+      #
+      #   # good
+      #   class MyJob
+      #     include Sidekiq::Worker
+      #   end
+      #
+      class JobInclude < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Sidekiq::%<preferred>s` instead of `Sidekiq::%<deprecated>s`.'
+
+        MODULES = %w[Job Worker].freeze
+
+        # @!method sidekiq_include(node)
+        def_node_matcher :sidekiq_include, <<~PATTERN
+          (send nil? :include (const (const {nil? cbase} :Sidekiq) ${:Job :Worker}))
+        PATTERN
+
+        def on_send(node)
+          sidekiq_include(node) do |module_name|
+            return if module_name.to_s == preferred_module
+
+            deprecated = module_name.to_s
+            message = format(MSG, preferred: preferred_module, deprecated: deprecated)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, "include Sidekiq::#{preferred_module}")
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def preferred_module
+          cop_config.fetch('PreferredModule', 'Job')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sidekiq/missing_logging.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks for missing logging in Sidekiq job perform methods.
+      #
+      # @example
+      #   # bad
+      #   def perform(user_id)
+      #     do_work(user_id)
+      #   end
+      #
+      #   # good
+      #   def perform(user_id)
+      #     logger.info "Starting job for #{user_id}"
+      #     do_work(user_id)
+      #   end
+      #
+      class MissingLogging < Base
+        MSG = 'Add logging to Sidekiq job perform methods.'
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless in_sidekiq_job?(node)
+          return if logger_call?(node)
+
+          add_offense(node.loc.keyword)
+        end
+
+        private
+
+        def logger_call?(def_node)
+          def_node.each_descendant(:send).any? { |send| logger_call_send?(send) }
+        end
+
+        def logger_call_send?(send)
+          receiver = send.receiver
+          return false unless receiver&.send_type?
+
+          receiver_name = receiver.method_name
+          return false unless %i[logger].include?(receiver_name)
+
+          %i[debug info warn error fatal].include?(send.method_name)
+        end
+      end
+    end
+  end
+end