rubocop-gusto 10.10.0 → 11.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9326f07188d8534d2cad736cf8d79c3e9a40d0296ef6630dd6d88cf859851df2
-  data.tar.gz: '05178b0a1c63907c768878e893529eb3c095fb1a89f88b0810d58a5ae9a91f0b'
+  metadata.gz: 5814e91aac6e402768ff64bd32f0c196838e20d90cbd927286238f68bb9d25b9
+  data.tar.gz: d4e988b9973101b7ea9a683900ae7489cbfe128b681d4137c7317f06a45cc247
 SHA512:
-  metadata.gz: f78012905401ef80f171d1f05d50d85e4fa897225f3c36bca1f1cb508dd147b2b1809074c1fdef29ccb590c0b41f1d3b47453e6b02afab4c1be87bb6f5e7b65c
-  data.tar.gz: 25e25916a6a0e3096a5f64678d991674f4d6734abaac9dbb10956d825cb4189dd8f00cac23c9f0f9c28fc43efbbd638b0d48db8044dc60b159e738e09ec873ce
+  metadata.gz: 82385ed24fdf344897513f4f034e1f8ae662a5d41b62ccc8dc2c14e735d479deb31acf4c28047fbad1f59d828485798a4677148ca203989f15489d768cb88995
+  data.tar.gz: 403192785be424b372d709d2c7d9bac18491603c2a9449a2edeb5b35c981652e7ee87c307265a381b51d5285134fda5a0178adb04087bb6d2db7c10b51d41ae9

data/CHANGELOG.md

@@ -3,6 +3,26 @@
 - Remove redundant `Rails: Enabled: true` from `config/rails.yml` (already set by rubocop-rails' own defaults)
 - Enable `Rails/DefaultScope` cop (disabled by default in rubocop-rails)
 
+## [11.1.0](https://github.com/Gusto/rubocop-gusto/compare/v11.0.0...v11.1.0) (2026-06-17)
+
+
+### Features
+
+* add `Sidekiq/PerformAsyncStub` in a separate config ([#131](https://github.com/Gusto/rubocop-gusto/issues/131)) ([22670d4](https://github.com/Gusto/rubocop-gusto/commit/22670d4a34487417bdb50b8be25e82fb0cac3614))
+* add cops-only entrypoints for selective adoption ([#132](https://github.com/Gusto/rubocop-gusto/issues/132)) ([f0911c2](https://github.com/Gusto/rubocop-gusto/commit/f0911c2f9fc6d272bc8ccb5af830daf659c6ba62))
+
+## [11.0.0](https://github.com/Gusto/rubocop-gusto/compare/v10.10.0...v11.0.0) (2026-06-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* rubocop-gusto now requires Ruby >= 3.4.
+
+### Features
+
+* add Gusto/DescribedClassConstantReference cop ([#127](https://github.com/Gusto/rubocop-gusto/issues/127)) ([f7cf636](https://github.com/Gusto/rubocop-gusto/commit/f7cf6362f3f522f322251da0fdf5c8affa35bc0f))
+* add Gusto/UnreferencedLet cop (requires Ruby >= 3.4) ([#128](https://github.com/Gusto/rubocop-gusto/issues/128)) ([99a2df7](https://github.com/Gusto/rubocop-gusto/commit/99a2df761b52ce11f4f6bf65a5c8e414153efa53))
+
 ## [10.10.0](https://github.com/Gusto/rubocop-gusto/compare/v10.9.4...v10.10.0) (2026-06-01)
 
 

data/README.md

@@ -28,15 +28,31 @@ $ bundle
 bundle exec rubocop-gusto init
 ```
 
-This adds `rubocop-gusto` to your `.rubocop.yml` `plugins:` list and includes any relevant configuration (e.g. Rails-specific rules when Rails is detected).
+This adds `rubocop-gusto` to your `.rubocop.yml` `plugins:` list and includes any relevant configuration (e.g. Rails-specific rules when Rails is detected, Sidekiq-specific rules when the Sidekiq gem is present).
 
 If this is an existing project, it is recommended to run the autocorrector (`bundle exec rubocop -a`) and then to regenerate the `.rubocop_todo.yml` (`bundle exec rubocop --auto-gen-config`), so issues can be dealt with piecemeal.
 
+#### Sidekiq configuration
+
+Sidekiq-specific cops live in `config/sidekiq.yml` and are **not** included in `config/default.yml`, so projects without Sidekiq are not linted for those patterns. Running `bundle exec rubocop-gusto init` adds `config/sidekiq.yml` to your `inherit_gem` list automatically when Sidekiq is listed in your `Gemfile` or `Gemfile.lock`.
+
+For an existing project that already uses Sidekiq, add the Sidekiq config to your `.rubocop.yml`:
+
+```yaml
+inherit_gem:
+  rubocop-gusto:
+    - config/default.yml
+    - config/sidekiq.yml
+```
+
+If your project also uses Rails, include `config/rails.yml` as well (order does not matter). Re-run `bundle exec rubocop-gusto init` to merge this in automatically.
+
 ### Available cops
 
 Custom cops live under the following namespaces:
 
 - `Gusto/` — general Gusto-specific cops (see [`lib/rubocop/cop/gusto/`](lib/rubocop/cop/gusto/))
+- `Sidekiq/` — cops scoped to Sidekiq patterns (see [`lib/rubocop/cop/sidekiq/`](lib/rubocop/cop/sidekiq/)); configured in [`config/sidekiq.yml`](config/sidekiq.yml)
 - `Rack/` — cops scoped to Rack middleware patterns (see [`lib/rubocop/cop/rack/`](lib/rubocop/cop/rack/))
 
 ## Publishing New Versions
@@ -66,7 +82,7 @@ PR titles must use [Conventional Commits](https://www.conventionalcommits.org/)
 
 ### Adding a new cop
 
-1. Create `lib/rubocop/cop/gusto/<cop_name>.rb`
+1. Create `lib/rubocop/cop/gusto/<cop_name>.rb`, see [how to create a new cop](https://docs.rubocop.org/rubocop/latest/development.html#create-a-new-cop) and [how to choose a name](https://docs.rubocop.org/rubocop-rspec/development.html#choose-a-name)
 2. Add an entry to `config/default.yml`, then sort it:
    ```sh
    bundle exec rubocop-gusto sort config/default.yml

data/config/default.yml

@@ -1,3 +1,5 @@
+inherit_from: gusto_cops.yml
+
 plugins:
   - rubocop-rspec
   - rubocop-performance
@@ -30,119 +32,6 @@ Gemspec/RequiredRubyVersion:
   # We manage our Ruby version in our version file and import that to our Gemfile.
   Enabled: false
 
-Gusto/BootsnapLoadFile:
-  Description: 'Do not use Bootsnap to load files. Use `require` instead.'
-
-Gusto/DatadogConstant:
-  Exclude:
-    # calling DataDog directly only allowed in initializers, its library, and tests
-    - 'config/application.rb'
-    - 'config/initializers/datadog.rb'
-    - 'lib/datadog/**/*'
-    - '**/spec/**/*'
-  Description: 'Do not call Datadog directly, use an appropriate wrapper library.'
-
-Gusto/DiscouragedGem:
-  Description: 'Flags installation of discouraged gems in Gemfiles and gemspecs.'
-  Enabled: false
-  Gems: {}
-
-Gusto/ExecuteMigration:
-  Description: "Don't use `execute` in migrations. Use a backfill rake task instead."
-  Include:
-    - 'db/migrate/*.rb'
-
-Gusto/FactoryClassesOrModules:
-  Description: 'Do not define modules or classes in factory directories - they break reloading.'
-  Include:
-    - 'spec/**/factories/*.rb'
-
-Gusto/MinByMaxBy:
-  Description: 'Checks for the use of `min` or `max` with a proc. Corrects to `min_by` or `max_by`.'
-  Safe: false
-  Severity: error
-
-Gusto/NoMetaprogramming:
-  Description: 'Avoid using metaprogramming techniques like define_method and instance_eval which make code harder to understand and debug.'
-
-Gusto/NoRescueErrorMessageChecking:
-  Description: 'Checks for the presence of error message checking within rescue blocks.'
-
-Gusto/NoSend:
-  Description: 'Do not call a private method via `__send__`.'
-  Exclude:
-    - '**/spec/**/*'
-
-Gusto/PaperclipOrAttachable:
-  Description: 'No more new paperclip or Attachable are allowed. Use ActiveStorage instead.'
-
-Gusto/PerformClassMethod:
-  Description: 'Prevents accidental definition of `perform` class methods (should be instance methods instead).'
-  # List of modules that include Sidekiq::Worker.
-  # Add your other base modules here if they include Sidekiq::Worker too.
-  WorkerModules:
-    - Sidekiq::Worker
-
-Gusto/PolymorphicTypeValidation:
-  Description: 'Ensures that polymorphic relations include a type validation, which is necessary for generating Sorbet types.'
-  Include:
-    - '**/models/**/*.rb'
-
-Gusto/PreferProcessLastStatus:
-  Description: 'Prefer using `Process.last_status` instead of the global variables: `$?` and `$CHILD_STATUS`.'
-
-Gusto/RablExtends:
-  Description: 'Disallows the use of `extends` in Rabl templates due to poor caching performance. Inline the templating to generate your JSON instead.'
-  Include:
-    - '**/*.json.rabl'
-
-Gusto/RailsEnv:
-  Description: 'Use Feature Flags or config instead of `Rails.env`.'
-
-Gusto/RakeConstants:
-  Description: 'Do not define a constant in rake file, because they are sometimes `load`ed, instead of `require`d which can lead to warnings about redefining constants.'
-  Include:
-    - '**/*.rake'
-    - 'Rakefile'
-
-Gusto/RegexpBypass:
-  Description: 'Ensures regular expressions use \A and \z anchors instead of ^ and $ for security validation.'
-  Exclude:
-    - '**/spec/**/*'
-  Safe: false
-
-Gusto/RspecDateTimeMock:
-  Description: "Don't mock Date/Time/DateTime directly. Use Rails Testing Time Helpers (eg `freeze_time` and `travel_to`) instead."
-  Include:
-    - '**/spec/**/*'
-  Safe: false
-
-Gusto/SidekiqParams:
-  Description: 'Sidekiq perform methods cannot take keyword arguments.'
-
-Gusto/ToplevelConstants:
-  Description: 'Prevents top-level constants from being defined outside of initializers.'
-  Include:
-    - '**/*.rb'
-  Exclude:
-    - '**/bin/*'
-    - 'bin/*'
-    - 'config/**/*'
-    - 'lib/*.rb'
-    - 'packs/**/{db/seeds,lib,config/initializers}/**/*'
-    - 'script/**/*'
-    - 'spec/rails_helper.rb'
-    - '**/spec/support/**/*'
-    - '**/*/spec_helper.rb'
-    - 'spec/support/**/*.rb'
-
-Gusto/UsePaintNotColorize:
-  Description: 'Use Paint instead of colorize for terminal colors.'
-  SafeAutoCorrect: false
-
-Gusto/VcrRecordings:
-  Description: 'VCR should be set to not record in tests. Use vcr: {record: :none}.'
-
 Layout/BlockAlignment:
   EnforcedStyleAlignWith: start_of_block
 
@@ -373,6 +262,13 @@ Rack/LowercaseHeaderKeys:
 Rake/ClassDefinitionInTask:
   Enabled: false
 
+Sidekiq/PerformAsyncStub:
+  Description: 'Prefer checking enqueued jobs over stubbing `perform_async`.'
+  Enabled: false
+  SafeAutoCorrect: false # Autocorrect appends `.and_call_original`, which runs real `perform_async` during the example
+  Include:
+    - '**/spec/**/*_spec.rb'
+
 Sorbet/ForbidTUnsafe:
   # T.unsafe completely disables typechecking. Prefer T.cast, shims, or
   # reorganizing the code over silently turning off the type checker.

data/config/gusto_cops.yml

@@ -0,0 +1,135 @@
+# Gusto cop defaults only — no built-in cop overrides.
+# Use this with `inherit_gem` when you want Gusto cop scoping (Include/Exclude/Severity)
+# without inheriting rubocop-gusto's full configuration layer.
+#
+# In your .rubocop.yml:
+#   require:
+#     - rubocop/cop/gusto/all
+#   inherit_gem:
+#     rubocop-gusto:
+#       - config/gusto_cops.yml
+
+Gusto/BootsnapLoadFile:
+  Description: 'Do not use Bootsnap to load files. Use `require` instead.'
+
+Gusto/DatadogConstant:
+  Exclude:
+    # calling DataDog directly only allowed in initializers, its library, and tests
+    - 'config/application.rb'
+    - 'config/initializers/datadog.rb'
+    - 'lib/datadog/**/*'
+    - '**/spec/**/*'
+  Description: 'Do not call Datadog directly, use an appropriate wrapper library.'
+
+Gusto/DescribedClassConstantReference:
+  Description: 'Flags constants scoped through `described_class` (e.g. `described_class::Foo`), which Sorbet cannot resolve statically.'
+  Enabled: true
+  SafeAutoCorrect: false
+  Include:
+    - '**/spec/**/*'
+
+Gusto/DiscouragedGem:
+  Description: 'Flags installation of discouraged gems in Gemfiles and gemspecs.'
+  Enabled: false
+  Gems: {}
+
+Gusto/ExecuteMigration:
+  Description: "Don't use `execute` in migrations. Use a backfill rake task instead."
+  Include:
+    - 'db/migrate/*.rb'
+
+Gusto/FactoryClassesOrModules:
+  Description: 'Do not define modules or classes in factory directories - they break reloading.'
+  Include:
+    - 'spec/**/factories/*.rb'
+
+Gusto/MinByMaxBy:
+  Description: 'Checks for the use of `min` or `max` with a proc. Corrects to `min_by` or `max_by`.'
+  Safe: false
+  Severity: error
+
+Gusto/NoMetaprogramming:
+  Description: 'Avoid using metaprogramming techniques like define_method and instance_eval which make code harder to understand and debug.'
+
+Gusto/NoRescueErrorMessageChecking:
+  Description: 'Checks for the presence of error message checking within rescue blocks.'
+
+Gusto/NoSend:
+  Description: 'Do not call a private method via `__send__`.'
+  Exclude:
+    - '**/spec/**/*'
+
+Gusto/PaperclipOrAttachable:
+  Description: 'No more new paperclip or Attachable are allowed. Use ActiveStorage instead.'
+
+Gusto/PerformClassMethod:
+  Description: 'Prevents accidental definition of `perform` class methods (should be instance methods instead).'
+  WorkerModules:
+    - Sidekiq::Worker
+
+Gusto/PolymorphicTypeValidation:
+  Description: 'Ensures that polymorphic relations include a type validation, which is necessary for generating Sorbet types.'
+  Include:
+    - '**/models/**/*.rb'
+
+Gusto/PreferProcessLastStatus:
+  Description: 'Prefer using `Process.last_status` instead of the global variables: `$?` and `$CHILD_STATUS`.'
+
+Gusto/RablExtends:
+  Description: 'Disallows the use of `extends` in Rabl templates due to poor caching performance. Inline the templating to generate your JSON instead.'
+  Include:
+    - '**/*.json.rabl'
+
+Gusto/RailsEnv:
+  Description: 'Use Feature Flags or config instead of `Rails.env`.'
+
+Gusto/RakeConstants:
+  Description: 'Do not define a constant in rake file, because they are sometimes `load`ed, instead of `require`d which can lead to warnings about redefining constants.'
+  Include:
+    - '**/*.rake'
+    - 'Rakefile'
+
+Gusto/RegexpBypass:
+  Description: 'Ensures regular expressions use \A and \z anchors instead of ^ and $ for security validation.'
+  Exclude:
+    - '**/spec/**/*'
+  Safe: false
+
+Gusto/RspecDateTimeMock:
+  Description: "Don't mock Date/Time/DateTime directly. Use Rails Testing Time Helpers (eg `freeze_time` and `travel_to`) instead."
+  Include:
+    - '**/spec/**/*'
+  Safe: false
+
+Gusto/SidekiqParams:
+  Description: 'Sidekiq perform methods cannot take keyword arguments.'
+
+Gusto/ToplevelConstants:
+  Description: 'Prevents top-level constants from being defined outside of initializers.'
+  Include:
+    - '**/*.rb'
+  Exclude:
+    - '**/bin/*'
+    - 'bin/*'
+    - 'config/**/*'
+    - 'lib/*.rb'
+    - 'packs/**/{db/seeds,lib,config/initializers}/**/*'
+    - 'script/**/*'
+    - 'spec/rails_helper.rb'
+    - '**/spec/support/**/*'
+    - '**/*/spec_helper.rb'
+    - 'spec/support/**/*.rb'
+
+Gusto/UnreferencedLet:
+  Description: 'Removes a lazy let whose name is never referenced (its block never runs).'
+  Enabled: true
+  Include:
+    - '**/spec/**/*_spec.rb'
+  SafeAutoCorrect: false
+
+Gusto/UsePaintNotColorize:
+  Description: 'Use Paint instead of colorize for terminal colors.'
+  SafeAutoCorrect: false
+
+Gusto/VcrRecordings:
+  Description: 'VCR should be set to not record in tests. Use vcr: {record: :none}.'

data/config/sidekiq.yml

@@ -0,0 +1,7 @@
+#
+# This file should be inherited alongside default.yml for projects using Sidekiq
+#
+# After you add a rule, sort this file with `bundle exec rubocop-gusto sort config/sidekiq.yml`
+
+Sidekiq/PerformAsyncStub:
+  Enabled: true

data/lib/rubocop/cop/gusto/all.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "../../gusto"
+require_relative "../../gusto/version"
+
+Dir.glob("#{__dir__}/*.rb").each { |f| require f unless f == __FILE__ }

data/lib/rubocop/cop/gusto/bootsnap_load_file.rb

@@ -3,7 +3,17 @@
 module RuboCop
   module Cop
     module Gusto
-      # Do not use Bootsnap to load files. Use `require` instead.
+      # Prefer `YAML.load_file`/`JSON.load_file` over reading a file and then
+      # parsing its contents. Bootsnap caches the parsed result of `load_file`,
+      # so this improves load time.
+      #
+      # @example
+      #   # bad
+      #   YAML.load(File.read("config.yml"))
+      #   File.open("config.yml") { |f| YAML.load(f) }
+      #
+      #   # good
+      #   YAML.load_file("config.yml")
       class BootsnapLoadFile < Base
         PROHIBITED_CONSTANTS = Set[:YAML, :JSON].freeze
         RESTRICT_ON_SEND = %i(load).freeze

data/lib/rubocop/cop/gusto/datadog_constant.rb

@@ -3,6 +3,16 @@
 module RuboCop
   module Cop
     module Gusto
+      # Disallow referencing the `Datadog` constant directly. Calls should go
+      # through an approved wrapper library so instrumentation stays consistent
+      # and swappable.
+      #
+      # @example
+      #   # bad
+      #   Datadog::Tracing.active_trace
+      #
+      #   # good
+      #   Observability.active_trace
       class DatadogConstant < Base
         MSG = "Do not call Datadog directly, use an appropriate wrapper library."
         NAMESPACE = "Datadog"

data/lib/rubocop/cop/gusto/described_class_constant_reference.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Flags constants that are scoped through `described_class`, e.g.
+      # `described_class::Worker`.
+      #
+      # `described_class` is an RSpec helper method resolved at runtime, so
+      # Sorbet's static analysis treats `described_class::Worker` as a dynamic
+      # constant reference and cannot resolve it (`Dynamic constant references
+      # are unsupported`, https://srb.help/5001). Reference the constant by its
+      # fully-qualified name instead. A bare `described_class` (with no `::`
+      # constant lookup) is an ordinary method call and is left alone.
+      #
+      # Autocorrection replaces `described_class` with the constant that the
+      # enclosing example group describes. It is marked unsafe
+      # (`SafeAutoCorrect: false`) because the rewrite relies on the described
+      # constant being a statically-written name; review the result before
+      # committing. In particular, a constant defined on an *ancestor* of the
+      # described class is qualified against the described class itself, which
+      # is correct at runtime but which Sorbet cannot resolve through the
+      # inheritance chain -- re-point those to the defining ancestor by hand.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Payments::Processor do
+      #     describe described_class::Worker do
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Payments::Processor do
+      #     describe Payments::Processor::Worker do
+      #     end
+      #   end
+      #
+      #   # good - `RSpec.describe self` resolves to the enclosing namespace
+      #   module Payments
+      #     RSpec.describe self do
+      #       it { expect(Payments::TIMEOUT).to eq(5) }
+      #     end
+      #   end
+      #
+      #   # good - a bare `described_class` is not a constant reference
+      #   RSpec.describe Payments::Processor do
+      #     subject { described_class.new }
+      #   end
+      class DescribedClassConstantReference < Base
+        extend AutoCorrector
+
+        MSG = "Use the fully-qualified constant name instead of scoping it through " \
+              "`described_class`, which Sorbet cannot resolve statically."
+
+        # A constant whose scope is a no-receiver `described_class`, e.g.
+        # `described_class::Worker`.
+        # @!method const_scoped_on_described_class?(node)
+        def_node_matcher :const_scoped_on_described_class?, <<~PATTERN
+          (const (send nil? :described_class) _)
+        PATTERN
+
+        # An example group, capturing its first argument: a constant
+        # (`RSpec.describe Foo do`, `context Foo do`), `self`
+        # (`RSpec.describe self do`), and so on.
+        # @!method example_group_described_argument(node)
+        def_node_matcher :example_group_described_argument, <<~PATTERN
+          (block
+            (send {(const nil? :RSpec) nil?}
+              {:describe :xdescribe :fdescribe :context :xcontext :fcontext :feature :example_group}
+              $_ ...)
+            ...)
+        PATTERN
+
+        # Whether a node routes through a no-receiver `described_class`.
+        # @!method scoped_through_described_class?(node)
+        def_node_search :scoped_through_described_class?, <<~PATTERN
+          (send nil? :described_class)
+        PATTERN
+
+        def on_const(node)
+          return unless const_scoped_on_described_class?(node)
+
+          scope = node.children[0]
+          add_offense(scope) do |corrector|
+            replacement = described_class_replacement(node)
+            corrector.replace(scope, replacement) if replacement
+          end
+        end
+
+        private
+
+        # The fully-qualified name (as a String) that `described_class` resolves
+        # to lexically, from the nearest enclosing example group, or nil if it
+        # cannot be determined statically.
+        #
+        # - `describe SomeClass` resolves to that constant's written name.
+        # - `describe self` resolves to the enclosing module/class namespace.
+        # - `describe described_class::X` qualifies the describe argument itself
+        #   against the outer group; a reference in such a group's *body* resolves
+        #   at runtime to the scoped (statically unknown) class, so we decline to
+        #   autocorrect it. Once the enclosing `described_class::X` is rewritten,
+        #   a later pass resolves the body reference correctly.
+        # - Any other describe argument (e.g. a string) is skipped, and the
+        #   search continues at the next enclosing example group.
+        def described_class_replacement(node)
+          node.each_ancestor(:block) do |block_node|
+            described_argument = example_group_described_argument(block_node)
+            next if described_argument.nil?
+
+            if described_argument.self_type?
+              namespace = enclosing_namespace(block_node)
+              return namespace if namespace
+            elsif described_argument.const_type?
+              return described_argument.source unless scoped_through_described_class?(described_argument)
+              return nil unless reference_within_described_constant?(described_argument, node)
+            end
+          end
+          nil
+        end
+
+        # The fully-qualified name of the module/class lexically enclosing the
+        # example group, which is what `self` refers to in `RSpec.describe self`.
+        def enclosing_namespace(block_node)
+          names = block_node.each_ancestor(:class, :module).map { |mod| mod.children.first.source }
+          return if names.empty?
+
+          names.reverse.join("::")
+        end
+
+        # Whether the offending constant is the described constant itself (the
+        # describe argument) rather than a reference inside the group's body.
+        def reference_within_described_constant?(described_constant, node)
+          node.equal?(described_constant) ||
+            described_constant.each_descendant(:const).any? { |const_node| const_node.equal?(node) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/discouraged_gem.rb

@@ -3,13 +3,16 @@
 module RuboCop
   module Cop
     module Gusto
-      # Flags installation of discouraged gems (e.g., timecop) in Gemfiles and gemspecs.
+      # Flag installation of discouraged gems (e.g. timecop) in Gemfiles and
+      # gemspecs. The discouraged gems an advice about alternatives are configured under
+      # `Gems:`; intended to be enabled in Rails projects via config/rails.yml.
       #
-      # Configuration:
-      #   Gems:
-      #     timecop: "Use Rails' time helpers (e.g., freeze_time, travel_to) instead of Timecop."
+      # @example Gems: { timecop: "Use Rails' time helpers instead of Timecop." }
+      #   # bad
+      #   gem "timecop"
       #
-      # This cop is intended to be enabled in Rails projects via config/rails.yml.
+      #   # good
+      #   # Use Rails' time helpers (freeze_time, travel_to) instead.
       class DiscouragedGem < Base
         MSG = "Avoid using the '%{gem}' gem. %{advice}"
 

data/lib/rubocop/cop/gusto/execute_migration.rb

@@ -3,6 +3,20 @@
 module RuboCop
   module Cop
     module Gusto
+      # Disallow `execute` (raw SQL) in migrations. Run raw SQL from a backfill
+      # rake task, or pass SQL options to `add_column`/`change_column` instead,
+      # so migrations stay reversible and schema-focused.
+      #
+      # @example
+      #   # bad
+      #   def up
+      #     execute("UPDATE users SET active = true")
+      #   end
+      #
+      #   # good
+      #   def up
+      #     add_column :users, :active, :boolean, default: true
+      #   end
       class ExecuteMigration < Base
         MSG = "Do not use `execute` to run raw SQL in a migration. Run the query from a backfill rake task or pass the SQL options to the `add_column`/`change_column` method."
         RESTRICT_ON_SEND = [:execute].freeze

data/lib/rubocop/cop/gusto/factory_classes_or_modules.rb

@@ -3,6 +3,24 @@
 module RuboCop
   module Cop
     module Gusto
+      # Disallow defining classes or modules in factory directories. They break
+      # Rails autoloading/reloading; define shared helpers outside the factories.
+      #
+      # @example
+      #   # bad
+      #   # spec/factories/users.rb
+      #   class UserHelper
+      #   end
+      #
+      #   FactoryBot.define do
+      #     factory :user
+      #   end
+      #
+      #   # good
+      #   # spec/factories/users.rb
+      #   FactoryBot.define do
+      #     factory :user
+      #   end
       class FactoryClassesOrModules < Base
         MSG = "Do not define modules or classes in factory directories - they break reloading"
 

data/lib/rubocop/cop/gusto/paperclip_or_attachable.rb

@@ -4,6 +4,15 @@
 module RuboCop
   module Cop
     module Gusto
+      # Disallow new Paperclip / Attachable attachments. New attachments should
+      # use ActiveStorage instead.
+      #
+      # @example
+      #   # bad
+      #   has_attached_file :avatar
+      #
+      #   # good
+      #   has_one_attached :avatar
       class PaperclipOrAttachable < Base
         MSG = "No more new paperclip or Attachable are allowed. New attachments should use ActiveStorage instead"
         RESTRICT_ON_SEND = %i(has_attached_file has_pdf_attachment has_attachment).freeze

data/lib/rubocop/cop/gusto/polymorphic_type_validation.rb

@@ -1,11 +1,26 @@
 # frozen_string_literal: true
 
-# This cop enforces that polymorphic relations have a corresponding validation
-# for their type field with an inclusion validation. This is required in order for Tapioca
-# to generate correct Sorbet types
 module RuboCop
   module Cop
     module Gusto
+      # Require polymorphic relations to validate their `*_type` field with an
+      # inclusion validation (or `polymorphic_methods_for`). This is needed for
+      # Tapioca to generate correct Sorbet types.
+      #
+      # @example
+      #   # bad
+      #   belongs_to :subscription_detail, polymorphic: true
+      #
+      #   # good
+      #   VALID_TYPES = T.let([Foo.polymorphic_name, Bar.polymorphic_name].freeze, T::Array[String])
+      #   belongs_to :subscription_detail, polymorphic: true
+      #   validates :subscription_detail_type, presence: true, inclusion: { in: VALID_TYPES }
+      #
+      #   # also good
+      #   include PolymorphicCallable
+      #   VALID_TYPES = T.let([Foo.polymorphic_name, Bar.polymorphic_name].freeze, T::Array[String])
+      #   belongs_to :subscription_detail, polymorphic: true
+      #   polymorphic_methods_for :subscription_detail, VALID_TYPES
       class PolymorphicTypeValidation < Base
         RESTRICT_ON_SEND = %i(belongs_to validates polymorphic_methods_for).freeze
 

data/lib/rubocop/cop/gusto/sidekiq_params.rb

@@ -3,6 +3,18 @@
 module RuboCop
   module Cop
     module Gusto
+      # Disallow keyword arguments on Sidekiq `perform` methods. Sidekiq
+      # serializes job arguments as JSON and replays them positionally, so
+      # keyword arguments are not preserved.
+      #
+      # @example
+      #   # bad
+      #   def perform(user_id:, force: false)
+      #   end
+      #
+      #   # good
+      #   def perform(user_id, force = false)
+      #   end
       class SidekiqParams < Base
         MSG = "Sidekiq perform methods cannot take keyword arguments"
 

data/lib/rubocop/cop/gusto/unreferenced_let.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rubocop-rspec"
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Flags lazy `let` declarations whose name is never referenced. A lazy `let(:name) { ... }`
+      # is only evaluated when `name` is called, so an unreferenced one is dead code -- its block
+      # never runs -- and is deleted.
+      #
+      # Eager `let!` is intentionally out of scope: it runs its block before every example for its
+      # side effect even when unreferenced, so it cannot simply be deleted. Only plain `let` is
+      # handled here.
+      #
+      # Detection is file-scoped: a `let` referenced only from another file (through a shared
+      # example or an included test harness) cannot be seen, so the cop stays conservative and
+      # prefers false negatives over false positives:
+      # - a name defined more than once in the file by `let`/`let!`/`subject` (an override /
+      #   `super` chain, including a `subject` that overrides a `let` of the same name) is never
+      #   flagged;
+      # - a `let` declared lexically inside a `shared_examples` / `shared_examples_for` /
+      #   `shared_context` block is skipped (its consumers live in other files);
+      # - every `let` in a file that uses `it_behaves_like` / `it_should_behave_like` /
+      #   `include_examples` / `include_context` is skipped, because an included shared block may
+      #   reference the binding by a name we cannot follow statically;
+      # - any `let` whose name is also defined as a `let`/`subject` in a `spec/support/**` helper is
+      #   skipped, because it is almost certainly overriding a contract an included harness consumes;
+      # - `let(:cop_config)` is skipped: it is a rubocop-rspec contract consumed by the `:config`
+      #   shared context, not by a reference in the spec file; and
+      # - every `let` in a file that reflectively dispatches through a name we cannot resolve
+      #   statically (e.g. `send("expected_#{type}")`) is skipped, since any `let` could be the
+      #   target.
+      # A name counts as referenced if it is called bare (`foo`), appears as a symbol (`:foo`)
+      # anywhere but the let's own name argument, or appears as an identifier-shaped token inside
+      # any string/heredoc literal -- covering dynamic dispatch, `:foo` entries in data tables the
+      # spec later dispatches on, and bindings named only inside raw SQL/GraphQL text.
+      #
+      # Because a bare `:foo` symbol anywhere counts as a reference, commonly-named lets
+      # (`let(:user)`, `let(:company)`, `let(:id)`) are essentially never flagged -- `create(:user)`,
+      # `:name` hash keys, and the like saturate the file. This conservative bias means the cop
+      # realistically only deletes distinctively-named dead lets; it is not a complete dead-`let`
+      # finder.
+      #
+      # @example
+      #   # bad (name never referenced -- deleted, the block never runs)
+      #   let(:unused) { create(:thing) }
+      #
+      #   # good
+      #   let(:thing) { create(:thing) }
+      #   it { expect(thing).to be_present }
+      #
+      class UnreferencedLet < ::RuboCop::Cop::RSpec::Base
+        extend AutoCorrector
+        include RangeHelp
+
+        DEFINITION_METHODS = Set[:let, :let!, :subject].freeze
+        # `let`s consumed by a test framework rather than by a reference in the spec file. The
+        # rubocop-rspec `:config` shared context reads `cop_config`, so it is live even though the
+        # spec never names it.
+        FRAMEWORK_RESERVED_NAMES = %i(cop_config).freeze
+        # Reflective dispatch methods whose target is the first argument. When that argument is not
+        # a statically-resolvable name (a `sym` or plain `str`) -- e.g. `send("expected_#{type}")` --
+        # the called name cannot be known, so the whole file is left untouched.
+        DYNAMIC_DISPATCH_METHODS = %i(send public_send __send__ try try! method public_method respond_to?).freeze
+        FRAMEWORK_LET_PATTERN = /\b(?:let!?|subject)\s*\(?\s*:([A-Za-z_]\w*[!?]?)/
+        # Identifier-shaped tokens inside a string/heredoc literal. A `let` whose name appears only
+        # inside string text -- e.g. a binding or column referenced in raw SQL/GraphQL the spec
+        # later executes -- counts as referenced, so it is not deleted.
+        IDENTIFIER_IN_STRING = /[A-Za-z_]\w*[!?]?/
+        MSG = "Remove unreferenced `let(:%{name})` -- its name is never used, so the block never runs."
+        RESTRICT_ON_SEND = %i(let).freeze
+        # The glob and the pathspec encode the SAME set of files two ways: `Dir.glob` (fallback) and
+        # a regexp filter over `git ls-files` output. Keep them in sync if either changes.
+        SUPPORT_FILES_GLOB = "**/spec/support/**/*.rb"
+        SUPPORT_FILES_PATHSPEC = %r{(?:\A|/)spec/support/.+\.rb\z}
+
+        # The name symbol of any definition (`let`/`let!`/`subject`) in any block form -- used to
+        # count how many times a name is defined, so override / `super` chains (including a
+        # `subject` that overrides a `let` of the same name) are never flagged.
+        # @!method definition_name(node)
+        def_node_matcher :definition_name, <<~PATTERN
+          (any_block (send nil? %DEFINITION_METHODS (sym $_) ...) ...)
+        PATTERN
+
+        class << self
+          # Names defined as `let`/`subject` anywhere under `spec/support/**`. Computed once per
+          # process (lazily, after boot) and shared across every file the cop inspects.
+          def framework_let_names
+            @framework_let_names ||= scan_framework_let_names(support_file_paths)
+          end
+
+          # Enumerate `spec/support/**/*.rb`. Prefer `git ls-files` (reads the git index, skipping
+          # untracked trees like `node_modules`): a leading-`**` `Dir.glob` walks the entire
+          # repository and costs seconds, while reading the index costs tens of milliseconds. Fall
+          # back to `Dir.glob` when not in a git work tree or `git` is unavailable.
+          #
+          # Tradeoff: an untracked (brand-new, uncommitted) `spec/support/*.rb` override is invisible
+          # to `git ls-files`. In that narrow window its contract names are not exempted; once
+          # committed it is seen like any other support file.
+          def support_file_paths
+            git_tracked_support_files || ::Dir.glob(SUPPORT_FILES_GLOB)
+          end
+
+          def git_tracked_support_files
+            output, status = ::Open3.capture2("git", "ls-files", "-z")
+            return nil unless status.success?
+
+            output.split("\x0").grep(SUPPORT_FILES_PATHSPEC)
+          rescue ::SystemCallError
+            nil
+          end
+
+          def scan_framework_let_names(paths)
+            paths.each_with_object(Set.new) do |path, names|
+              extract_let_names(read_source(path), names)
+            end
+          end
+
+          def extract_let_names(source, names)
+            source.scan(FRAMEWORK_LET_PATTERN) { |(captured)| names << captured.to_sym }
+            names
+          end
+
+          def read_source(path)
+            return "" unless ::File.file?(path)
+
+            ::File.read(path)
+          end
+        end
+
+        def on_send(node)
+          return unless node.receiver.nil?
+
+          name_argument = node.first_argument
+          return unless name_argument&.sym_type?
+
+          block = node.block_node
+          return unless block
+
+          name = name_argument.value
+          return if exempt_from_deletion?(name, block)
+
+          add_offense(node.loc.selector, message: format(MSG, name:)) do |corrector|
+            corrector.remove(removal_range(block))
+          end
+        end
+
+        private
+
+        # A lazy `let` is exempt from deletion whenever file-scoped analysis cannot prove its name
+        # is dead: its name is a framework-reserved contract (e.g. `cop_config`), the file
+        # dispatches through a name we cannot resolve statically, it consumes shared examples, the
+        # `let` is lexically inside a shared-example definition, its name is a `spec/support/**`
+        # framework contract, it is overridden by another definition of the same name, or it is
+        # referenced somewhere in the file.
+        def exempt_from_deletion?(name, block)
+          FRAMEWORK_RESERVED_NAMES.include?(name) ||
+            dynamic_dispatch? ||
+            consumes_shared_examples? ||
+            within_shared_definition?(block) ||
+            self.class.framework_let_names.include?(name) ||
+            overridden?(name) ||
+            referenced?(name)
+        end
+
+        # Delete the `let` block, plus:
+        # - an immediately-preceding `sig { ... }` (so a Sorbet signature is not left dangling),
+        # - explanatory comment lines attached directly above it (so they are not orphaned), and
+        # - a single trailing blank line where removal would otherwise leave a stray/duplicate
+        #   blank -- unless the line above is a `let`/`subject`, where that blank is the required
+        #   separator after the now-final let and must stay.
+        def removal_range(node)
+          lines = processed_source.lines
+          start_line = node.source_range.first_line
+          end_line = node.source_range.last_line
+
+          sig = preceding_sig(node)
+          start_line = sig.source_range.first_line if sig
+
+          start_line -= 1 while start_line > 1 && absorbable_comment?(lines[start_line - 2])
+
+          if end_line < lines.size && blank_line?(lines[end_line]) &&
+              !(start_line > 1 && let_or_subject_line?(lines[start_line - 2]))
+            end_line += 1
+          end
+
+          buffer = processed_source.buffer
+          range_by_whole_lines(buffer.line_range(start_line).join(buffer.line_range(end_line)), include_final_newline: true)
+        end
+
+        def absorbable_comment?(source_line)
+          stripped = source_line.strip
+          stripped.start_with?("#") && !stripped.start_with?("# rubocop:")
+        end
+
+        def blank_line?(source_line)
+          source_line.strip.empty?
+        end
+
+        def let_or_subject_line?(source_line)
+          source_line.match?(/\A\s*(?:let!?|subject)\b/)
+        end
+
+        def preceding_sig(node)
+          sibling = node.left_sibling
+          return unless sibling.is_a?(::RuboCop::AST::BlockNode)
+          return unless sibling.method?(:sig)
+
+          sibling
+        end
+
+        def within_shared_definition?(node)
+          node.each_ancestor(:any_block).any? { |ancestor| shared_group?(ancestor) }
+        end
+
+        def consumes_shared_examples?
+          return @consumes_shared_examples unless @consumes_shared_examples.nil?
+
+          @consumes_shared_examples = processed_source.ast.each_node(:call).any? { |send_node| include?(send_node) }
+        end
+
+        # True when the file reflectively dispatches through a name we cannot resolve statically --
+        # `send`/`public_send`/`method`/etc. called with anything other than a `sym` or plain `str`
+        # first argument (most commonly an interpolated string, `send("expected_#{type}")`). In
+        # that case any `let` in the file could be the dispatch target, so none are deleted.
+        def dynamic_dispatch?
+          return @dynamic_dispatch unless @dynamic_dispatch.nil?
+
+          @dynamic_dispatch = processed_source.ast.each_node(:call).any? do |send_node|
+            next false unless DYNAMIC_DISPATCH_METHODS.include?(send_node.method_name)
+
+            target = send_node.first_argument
+            target && !target.sym_type? && !target.str_type?
+          end
+        end
+
+        def overridden?(name)
+          definitions_by_name.fetch(name, 0) > 1
+        end
+
+        def definitions_by_name
+          @definitions_by_name ||= processed_source.ast.each_node(:any_block).each_with_object(Hash.new(0)) do |node, counts|
+            name = definition_name(node)
+            counts[name] += 1 if name
+          end
+        end
+
+        def referenced?(name)
+          referenced_names.include?(name)
+        end
+
+        # A name is "referenced" if it is called as a bare method (`foo`), appears as a symbol
+        # literal (`:foo`) other than the let/subject's own name argument, or appears as an
+        # identifier-shaped token inside any string/heredoc literal. The symbol and string cases
+        # cover indirect invocation -- `send(:foo)` / `send("foo")`, a `:foo`/`"foo"` listed in a
+        # data table the spec later dispatches on, or a binding named only inside raw SQL/GraphQL
+        # text the spec executes -- which file-scoped analysis cannot otherwise follow. (Tokenizing
+        # string bodies, rather than matching the whole string, keeps a `let` referenced only from
+        # inside a multi-word heredoc from being deleted.) Interpolated-string *dispatch* is handled
+        # separately by `dynamic_dispatch?`, which exempts the whole file.
+        def referenced_names
+          @referenced_names ||= processed_source.ast.each_node(:sym, :str, :call).each_with_object(Set.new) do |node, names|
+            if node.sym_type?
+              names << node.value unless definition_name_argument?(node)
+            elsif node.str_type?
+              # A string with invalid encoding (e.g. a deliberate bad-UTF-8 test fixture) cannot
+              # contain an identifier-shaped reference and would raise on `scan`, so skip it.
+              node.value.scan(IDENTIFIER_IN_STRING) { |token| names << token.to_sym } if node.value.valid_encoding?
+            elsif node.receiver.nil? && node.arguments.empty?
+              names << node.method_name
+            end
+          end
+        end
+
+        def definition_name_argument?(sym_node)
+          parent = sym_node.parent
+          parent.send_type? && parent.receiver.nil? && DEFINITION_METHODS.include?(parent.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sidekiq
+      # Checks that `perform_async` calls to enqueue Sidekiq jobs are not stubbed
+      #
+      # @example
+      #   # bad
+      #   allow(Foo).to receive(:perform_async)
+      #   expect(Foo).to receive(:perform_async)
+      #   expect(Foo).not_to receive(:perform_async)
+      #
+      #   # good (still invokes the real method)
+      #   allow(Foo).to receive(:perform_async).and_call_original
+      #   expect(Foo).to receive(:perform_async).with(arg).and_call_original
+      #   allow(Foo).to receive(:perform_async).and_wrap_original { |m, *args| m.call(*args) }
+      #
+      #   # good (checking enqueued jobs)
+      #   expect { subject }.to change(Foo.jobs, :count).by(n)
+      #   expect { subject }.not_to change(Foo.jobs, :count)
+      #   expect(Foo.jobs.count).to eq(n)
+      #
+      #   # good (only checks previously pre-stubbed objects)
+      #   expect(Foo).to have_received(:perform_async)
+      #
+      # @safety
+      #   Autocorrect is unsafe: it appends `.and_call_original` on positive `receive` only, which runs
+      #   the real `perform_async` during the example (may enqueue jobs, hit external code, or
+      #   change expectations vs a pure stub). There is no autocorrect for `not_to` / `to_not receive`,
+      #   since `.and_call_original` would not apply to a negative expectation. Autocorrect is also
+      #   suppressed when the expectation uses a block, since appending `.and_call_original` would
+      #   rebind the block to the wrong method.
+      class PerformAsyncStub < Base
+        extend AutoCorrector
+
+        MSG = "Prefer checking enqueued jobs over stubbing `perform_async`."
+        MSG_RECEIVE = "Prefer checking enqueued jobs over stubbing `perform_async` or add `.and_call_original`."
+        RESTRICT_ON_SEND = %i(receive).freeze
+
+        # TODO: this should match on perform_async, not on receive, requires pattern update
+        # @!method stub_perform_async?(node)
+        def_node_matcher :stub_perform_async?, <<~PATTERN
+          (send nil? :receive (sym :perform_async))
+        PATTERN
+
+        def on_send(node)
+          return unless stub_perform_async?(node)
+
+          negative_expectation = false
+          calls_original = false
+
+          current = node.parent
+          while current&.call_type?
+            negative_expectation = true if current.method?(:not_to) || current.method?(:to_not)
+            calls_original = true if current.method?(:and_call_original) || current.method?(:and_wrap_original)
+
+            current = current.parent
+          end
+
+          return add_offense(node) if negative_expectation
+          return if calls_original # already have .and_call_original, not an offense
+
+          tail = message_expectation_chain_tail(node)
+          return add_offense(node, message: MSG_RECEIVE) if tail.parent&.block_type?
+
+          add_offense(node, message: MSG_RECEIVE) do |corrector|
+            corrector.insert_after(tail, ".and_call_original")
+          end
+        end
+
+        alias_method :on_csend, :on_send
+
+        private
+
+        def message_expectation_chain_tail(node)
+          tail = node
+          loop do
+            parent = tail.parent
+            break unless parent&.call_type?
+            break unless parent.receiver.equal?(tail)
+
+            tail = parent
+          end
+          tail
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/gusto/init.rb

@@ -10,6 +10,8 @@ module RuboCop
       include Thor::Actions
 
       PLUGINS = %w(rubocop-gusto rubocop-rspec rubocop-performance rubocop-rake rubocop-rails).freeze
+      SIDEKIQ_GEM_PATTERN = /\A\s*gem\s+['"]sidekiq['"]/
+      SIDEKIQ_LOCKFILE_PATTERN = /\A\s+sidekiq\s+\(/
 
       class_option :rubocop_yml, type: :string, default: ".rubocop.yml"
 
@@ -34,13 +36,8 @@ module RuboCop
           config = ConfigYml.load_file(options[:rubocop_yml])
         end
 
-        if rails?
-          config.add_inherit_gem("rubocop-gusto", "config/default.yml", "config/rails.yml")
-          config.add_plugin(PLUGINS)
-        else
-          config.add_inherit_gem("rubocop-gusto", "config/default.yml")
-          config.add_plugin(PLUGINS - %w(rubocop-rails))
-        end
+        config.add_inherit_gem("rubocop-gusto", *inherit_gem_configs)
+        config.add_plugin(rails? ? PLUGINS : PLUGINS - %w(rubocop-rails))
 
         config.sort!
         config.write(options[:rubocop_yml])
@@ -51,9 +48,25 @@ module RuboCop
 
       private
 
+      def inherit_gem_configs
+        configs = ["config/default.yml"]
+        configs << "config/rails.yml" if rails?
+        configs << "config/sidekiq.yml" if sidekiq?
+        configs
+      end
+
       def rails?
         File.exist?("config/application.rb")
       end
+
+      def sidekiq?
+        gem_referenced?("Gemfile", SIDEKIQ_GEM_PATTERN) ||
+          gem_referenced?("Gemfile.lock", SIDEKIQ_LOCKFILE_PATTERN)
+      end
+
+      def gem_referenced?(path, pattern)
+        File.exist?(path) && File.foreach(path).any? { |line| line.match?(pattern) }
+      end
     end
   end
 end

data/lib/rubocop/gusto/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Gusto
-    VERSION = "10.10.0"
+    VERSION = "11.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-gusto
 version: !ruby/object:Gem::Version
-  version: 10.10.0
+  version: 11.1.0
 platform: ruby
 authors:
 - Gusto Engineering
@@ -119,12 +119,16 @@ files:
 - LICENSE
 - README.md
 - config/default.yml
+- config/gusto_cops.yml
 - config/rails.yml
+- config/sidekiq.yml
 - exe/gusto-rubocop
 - exe/rubocop-gusto
 - lib/rubocop-gusto.rb
+- lib/rubocop/cop/gusto/all.rb
 - lib/rubocop/cop/gusto/bootsnap_load_file.rb
 - lib/rubocop/cop/gusto/datadog_constant.rb
+- lib/rubocop/cop/gusto/described_class_constant_reference.rb
 - lib/rubocop/cop/gusto/discouraged_gem.rb
 - lib/rubocop/cop/gusto/execute_migration.rb
 - lib/rubocop/cop/gusto/factory_classes_or_modules.rb
@@ -143,12 +147,14 @@ files:
 - lib/rubocop/cop/gusto/rspec_date_time_mock.rb
 - lib/rubocop/cop/gusto/sidekiq_params.rb
 - lib/rubocop/cop/gusto/toplevel_constants.rb
+- lib/rubocop/cop/gusto/unreferenced_let.rb
 - lib/rubocop/cop/gusto/use_paint_not_colorize.rb
 - lib/rubocop/cop/gusto/vcr_recordings.rb
 - lib/rubocop/cop/internal_affairs/assignment_first.rb
 - lib/rubocop/cop/internal_affairs/require_restrict_on_send.rb
 - lib/rubocop/cop/rack/lowercase_header_keys.rb
 - lib/rubocop/cop/rspec/scattered_let.rb
+- lib/rubocop/cop/sidekiq/perform_async_stub.rb
 - lib/rubocop/gusto.rb
 - lib/rubocop/gusto/cli.rb
 - lib/rubocop/gusto/config_yml.rb
@@ -169,7 +175,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="