rubocop-gusto 10.9.4 → 11.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e23aac56c0e7b184c9cc631ba70e8ac0c654aa47ec6e368737c089014d28c6ed
-  data.tar.gz: 48ef7a1dd5fa1145b5617b42abde18ae11480ec1609e9f9199daebbdde952d66
+  metadata.gz: b642214b2077302ad9ab6e076c66534fe49cfcda33a411b87b9c4b34df8f8b43
+  data.tar.gz: d9a653b4e27f33467921f5a2ffb520e2cc8b3a65f58e7cb4bb888611cea3e69d
 SHA512:
-  metadata.gz: 5c7059ad1293db2d96cba104f20009a3f4cdd7c487c34808264673ac9e65abdb9a60a6859e83d817843674a854ae5423328b719b1146edb9b60aca3296e4dc05
-  data.tar.gz: f9734a51d5eb38959f52c78e1c22aa028f65789e566c6067f0f38bbef4e76938d4deb5dd727709f1d2586615b93f29bdea58e39c692d38d54a69b8c328cece2f
+  metadata.gz: 876ba0b9f58929c28d77c71a370833670b27e0d55ecf8ab937f2882824db8b0da4ba2294a0649f2e54fdf7687b393d6c79be86da874a38d555b4190291c8a36b
+  data.tar.gz: fe18184e9f77db188cbbdc77a5274fbe624d664e73ec97a2b5eec130b3753dd6323e5192e98441fe7832d166e2c8980e0d6231494f4d54b0317a9cb18aae9ee5

data/CHANGELOG.md

@@ -3,6 +3,25 @@
 - 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.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)
+
+
+### Features
+
+* Set EnforcedShorthandSyntax to 'always' ([#116](https://github.com/Gusto/rubocop-gusto/issues/116)) ([650a8aa](https://github.com/Gusto/rubocop-gusto/commit/650a8aa26ee5af6d7558976dce6df18f053e1925))
+
 ## [10.9.4](https://github.com/Gusto/rubocop-gusto/compare/v10.9.3...v10.9.4) (2026-06-01)
 
 

data/config/default.yml

@@ -42,6 +42,13 @@ Gusto/DatadogConstant:
     - '**/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
@@ -136,6 +143,15 @@ Gusto/ToplevelConstants:
     - '**/*/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'
+  # Deletion is unsafe (explicit -A required, never applied on a plain run): the cop is heuristic
+  # and cannot see references made across files via shared examples or included harnesses.
+  SafeAutoCorrect: false
+
 Gusto/UsePaintNotColorize:
   Description: 'Use Paint instead of colorize for terminal colors.'
   SafeAutoCorrect: false
@@ -462,6 +478,7 @@ Style/GuardClause:
 
 Style/HashSyntax:
   EnforcedStyle: ruby19_no_mixed_keys
+  EnforcedShorthandSyntax: always
 
 Style/HashTransformKeys:
   Enabled: false

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

@@ -34,7 +34,7 @@ module RuboCop
         end
 
         def message_for(gem)
-          format(MSG, gem: gem, advice: advice_for(gem))
+          format(MSG, gem:, advice: advice_for(gem))
         end
 
         def advice_for(gem)

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

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require "open3"
+
+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 = %i(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.map { ":#{it}" }.join(' ')}} (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/rack/lowercase_header_keys.rb

@@ -122,9 +122,9 @@ module RuboCop
 
         def add_offense_for_header(node, key_value)
           downcased = key_value.downcase
-          message = format(MSG, downcased: downcased, original: key_value)
+          message = format(MSG, downcased:, original: key_value)
 
-          add_offense(node, message: message) do |corrector|
+          add_offense(node, message:) do |corrector|
             corrector.replace(node, "'#{downcased}'")
           end
         end

data/lib/rubocop/gusto/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Gusto
-    VERSION = "10.9.4"
+    VERSION = "11.0.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-gusto
 version: !ruby/object:Gem::Version
-  version: 10.9.4
+  version: 11.0.0
 platform: ruby
 authors:
 - Gusto Engineering
@@ -125,6 +125,7 @@ files:
 - lib/rubocop-gusto.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,6 +144,7 @@ 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
@@ -169,7 +171,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="