rubocop-rspec 3.9.0 → 3.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9159cd716027712a72b3a3e675f83a92c55070200ae0f628a8b00c7333bc99f0
-  data.tar.gz: 5e84a7c7108c0f745cfa3e32ab75fd9fe50a1b0f2dae4ba6e0433d6cf5cd30dc
+  metadata.gz: 61b047dc2dcdafc0499a7df00f8689fa68090a92b3a9897d37fee92a88655523
+  data.tar.gz: 52f2bd8775f31951731ca043c75297722f40d6fe943f5b8d9fadc9f54b6dfc66
 SHA512:
-  metadata.gz: bc41fe5a7eccbb4452fd4bc6459d03ceb5dcd8a13316245b223db3088ea25e38bfa029e834f527dbb511b80ce5b553c83673a6e6f957c974f599d7140d4f7d40
-  data.tar.gz: 0c6a077dd4b221d68524ed4b2734727000efb97c5fb553c31016aab51f57e0049f67c701727f6d7eeb04c42ad2866b96592793bc768bac7361ca4e7ca0d81248
+  metadata.gz: 5f68a310bb36188a5bc1d0114c8c31606d3e7f280607f26a032177dd42c7fdf88b283166b8f41d3968559527985b9c3ea10f0da036b09945c3696c8632bab3a5
+  data.tar.gz: 37d2040cb0b7d48fed88ba954a4ec0601d9ba11c6a1b3547ef553e3b35f509b9dc89b23820635ed9e7048da6a7fe4611dc5167b679a3e26336b2f940c6858e73

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## Master (Unreleased)
 
+## 3.10.2 (2026-06-06)
+
+- Fix false positives for `RSpec/SpecFilePathFormat` when `CustomTransform` maps a namespace to an empty string. ([@sakuro])
+- Fix `RSpec/MatchWithSimpleRegex` to ignore regular expressions with options. ([@bquorning])
+
+## 3.10.1 (2026-06-05)
+
+- Add `Strict` option to `RSpec/SharedContext` to flag `shared_context` whenever it contains examples, even alongside setup code. ([@Darhazer])
+- Add `NegatedMatcher` configuration option `RSpec/ExpectChange`. ([@Darhazer])
+- Fix `RSpec/MatchWithSimpleRegex` to ignore regular expressions with interpolations. ([@bquorning])
+
+## 3.10.0 (2026-06-05)
+
+- Add new cop `RSpec/MatchWithSimpleRegex` to suggest `include` matcher when `match` is used with simple string literals without regex-specific features. ([@bquorning])
+- Add new cop `RSpec/DiscardedMatcher` to detect matchers in void context (e.g. missing `.and` between compound matchers). ([@ydakuka])
+- Add support for `itblock` nodes. ([@Darhazer])
+- `RSpec/ScatteredLet` now preserves the order of `let`s during auto-correction. ([@Darhazer])
+- Fix a false negative for `RSpec/EmptyLineAfterFinalLet` inside `shared_examples` / `include_examples` / `it_behaves_like` blocks. ([@Darhazer])
+- Fix a false positive for `RSpec/ContainExactly` when `contain_exactly` has multiple splat arguments. ([@ydah])
+- Add autocorrect support for `RSpec/SubjectDeclaration`. ([@eugeneius])
+- Fix false negatives for `RSpec/SpecFilePathFormat` when the expected class path only partially matches a path segment. ([@ydah])
+- Fix a false negative for `RSpec/ExpectActual` when the matcher takes no arguments (e.g. `expect("foo").to be_present`, `expect(1).to be`). ([@cvx])
+
 ## 3.9.0 (2026-01-07)
 
 - Fix a false positive for `RSpec/LeakyLocalVariable` when variables are used only in example metadata (e.g., skip messages). ([@ydah])
@@ -988,6 +1011,7 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@composerinteralia]: https://github.com/composerinteralia
 [@corsonknowles]: https://github.com/corsonknowles
 [@corydiamand]: https://github.com/corydiamand
+[@cvx]: https://github.com/cvx
 [@d4rky-pl]: https://github.com/d4rky-pl
 [@darhazer]: https://github.com/Darhazer
 [@daveworth]: https://github.com/daveworth
@@ -1006,6 +1030,7 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@elebow]: https://github.com/elebow
 [@elisefitz15]: https://github.com/EliseFitz15
 [@elliterate]: https://github.com/elliterate
+[@eugeneius]: https://github.com/eugeneius
 [@faucct]: https://github.com/faucct
 [@foton]: https://github.com/foton
 [@francois-ferrandis]: https://github.com/francois-ferrandis
@@ -1103,6 +1128,7 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@yasu551]: https://github.com/yasu551
 [@ybiquitous]: https://github.com/ybiquitous
 [@ydah]: https://github.com/ydah
+[@ydakuka]: https://github.com/ydakuka
 [@yevhene]: https://github.com/yevhene
 [@ypresto]: https://github.com/ypresto
 [@yujideveloper]: https://github.com/yujideveloper

data/config/default.yml

@@ -311,6 +311,13 @@ RSpec/Dialect:
   VersionAdded: '1.33'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect
 
+RSpec/DiscardedMatcher:
+  Description: Checks for matchers that are used in void context.
+  Enabled: pending
+  VersionAdded: '3.10'
+  CustomMatcherMethods: []
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DiscardedMatcher
+
 RSpec/DuplicatedMetadata:
   Description: Avoid duplicated metadata.
   Enabled: true
@@ -453,7 +460,8 @@ RSpec/ExpectChange:
     - block
   SafeAutoCorrect: false
   VersionAdded: '1.22'
-  VersionChanged: '2.5'
+  VersionChanged: '3.10'
+  NegatedMatcher: ~
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange
 
 RSpec/ExpectInHook:
@@ -636,6 +644,13 @@ RSpec/MatchArray:
   VersionAdded: '2.19'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MatchArray
 
+RSpec/MatchWithSimpleRegex:
+  Description: Enforces the use of `include` matcher instead of `match` when the matcher
+    is a simple string literal without regex-specific features.
+  Enabled: pending
+  VersionAdded: '3.10'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MatchWithSimpleRegex
+
 RSpec/MessageChain:
   Description: Check that chains of messages are not being stubbed.
   Enabled: true
@@ -901,7 +916,9 @@ RSpec/ScatteredSetup:
 RSpec/SharedContext:
   Description: Checks for proper shared_context and shared_examples usage.
   Enabled: true
+  Strict: false
   VersionAdded: '1.13'
+  VersionChanged: '3.10'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext
 
 RSpec/SharedExamples:

data/lib/rubocop/cop/rspec/around_block.rb

@@ -41,6 +41,11 @@ module RuboCop
           (numblock (send nil? :around sym ?) ...)
         PATTERN
 
+        # @!method hook_itblock(node)
+        def_node_matcher :hook_itblock, <<~PATTERN
+          (itblock (send nil? :around sym ?) ...)
+        PATTERN
+
         # @!method find_arg_usage(node)
         def_node_search :find_arg_usage, <<~PATTERN
           {(send $... {:call :run}) (send _ _ $...) (yield $...) (block-pass $...)}
@@ -62,6 +67,12 @@ module RuboCop
           end
         end
 
+        def on_itblock(node)
+          hook_itblock(node) do
+            check_for_itblock(node)
+          end
+        end
+
         private
 
         def add_no_arg_offense(node)
@@ -89,6 +100,17 @@ module RuboCop
             message: format(MSG_UNUSED_ARG, arg: :_1)
           )
         end
+
+        def check_for_itblock(block)
+          find_arg_usage(block) do |usage|
+            return if usage.include?(s(:lvar, :it))
+          end
+
+          add_offense(
+            block.children.last,
+            message: format(MSG_UNUSED_ARG, arg: :it)
+          )
+        end
       end
     end
   end

data/lib/rubocop/cop/rspec/contain_exactly.rb

@@ -12,10 +12,13 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   it { is_expected.to contain_exactly(*array1, *array2) }
+      #   it { is_expected.to contain_exactly(*array) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(array) }
       #
       #   # good
-      #   it { is_expected.to match_array(array1 + array2) }
+      #   it { is_expected.to contain_exactly(*array1, *array2) }
       #
       #   # good
       #   it { is_expected.to contain_exactly(content, *array) }
@@ -27,29 +30,12 @@ module RuboCop
         RESTRICT_ON_SEND = %i[contain_exactly].freeze
 
         def on_send(node)
-          return if node.arguments.empty?
-
-          check_populated_collection(node)
-        end
-
-        private
-
-        def check_populated_collection(node)
-          return unless node.each_child_node.all?(&:splat_type?)
+          return unless node.arguments.one? && node.first_argument.splat_type?
 
           add_offense(node) do |corrector|
-            autocorrect_for_populated_array(node, corrector)
-          end
-        end
-
-        def autocorrect_for_populated_array(node, corrector)
-          arrays = node.arguments.map do |splat_node|
-            splat_node.children.first
+            array = node.first_argument.children.first
+            corrector.replace(node, "match_array(#{array.source})")
           end
-          corrector.replace(
-            node,
-            "match_array(#{arrays.map(&:source).join(' + ')})"
-          )
         end
       end
     end

data/lib/rubocop/cop/rspec/context_method.rb

@@ -38,7 +38,7 @@ module RuboCop
           ...)
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           context_method(node) do |context|
             add_offense(context) do |corrector|
               corrector.replace(node.send_node.loc.selector, 'describe')

data/lib/rubocop/cop/rspec/context_wording.rb

@@ -70,7 +70,7 @@ module RuboCop
           (block (send #rspec? { :context :shared_context } $(any_str ...) ...) ...)
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           context_wording(node) do |context|
             unless matches_allowed_pattern?(description(context))
               add_offense(context, message: message)

data/lib/rubocop/cop/rspec/described_class.rb

@@ -110,7 +110,7 @@ module RuboCop
         def_node_search :contains_described_class?,
                         '(send nil? :described_class)'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           # In case the explicit style is used, we need to remember what's
           # being described.
           @described_class, body = described_constant(node)

data/lib/rubocop/cop/rspec/discarded_matcher.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for matchers that are used in void context.
+      #
+      # Matcher calls like `change`, `receive`, etc. that appear as
+      # standalone expressions have their result silently discarded.
+      # This usually means a missing `.and` to chain compound matchers.
+      #
+      # The list of matcher methods can be configured
+      # with `CustomMatcherMethods`.
+      #
+      # @example
+      #   # bad
+      #   specify do
+      #     expect { result }
+      #       .to change { obj.foo }.from(1).to(2)
+      #       change { obj.bar }.from(3).to(4)
+      #   end
+      #
+      #   # good
+      #   specify do
+      #     expect { result }
+      #       .to change { obj.foo }.from(1).to(2)
+      #       .and change { obj.bar }.from(3).to(4)
+      #   end
+      #
+      #   # good
+      #   specify do
+      #     expect { result }.to change { obj.foo }.from(1).to(2)
+      #   end
+      #
+      class DiscardedMatcher < Base
+        include InsideExample
+
+        MSG = 'The result of `%<method>s` is not used. ' \
+              'Did you mean to chain it with `.and`?'
+
+        MATCHER_METHODS = %i[
+          change have_received output
+          receive receive_messages receive_message_chain
+        ].to_set.freeze
+
+        def on_send(node)
+          check_discarded_matcher(node, node)
+        end
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+          check_discarded_matcher(node.send_node, node)
+        end
+
+        private
+
+        def check_discarded_matcher(send_node, node)
+          return unless matcher_call?(send_node)
+          return unless inside_example?(node)
+          return unless example_with_matcher_expectation?(node)
+
+          target = find_outermost_chain(node)
+          return unless void_value?(target)
+
+          add_offense(target, message: format(MSG, method: node.method_name))
+        end
+
+        def example_with_matcher_expectation?(node)
+          example_node =
+            node.each_ancestor(:block).find { |ancestor| example?(ancestor) }
+
+          example_node.each_descendant(:send).any? do |send_node|
+            expectation_with_matcher?(send_node)
+          end
+        end
+
+        def expectation_with_matcher?(node)
+          %i[to to_not not_to].include?(node.method_name) &&
+            node.arguments.any? do |arg|
+              arg.each_node(:send).any? { |s| matcher_call?(s) }
+            end
+        end
+
+        def void_value?(node)
+          case node.parent.type
+          when :block
+            example?(node.parent)
+          when :begin, :case, :when
+            void_value?(node.parent)
+          end
+        end
+
+        def matcher_call?(node)
+          node.receiver.nil? && all_matcher_methods.include?(node.method_name)
+        end
+
+        def all_matcher_methods
+          @all_matcher_methods ||=
+            (MATCHER_METHODS + custom_matcher_methods).freeze
+        end
+
+        def custom_matcher_methods
+          cop_config.fetch('CustomMatcherMethods', []).map(&:to_sym)
+        end
+
+        def find_outermost_chain(node)
+          current = node
+          current = current.parent while current.parent.receiver == current
+          current
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/empty_example_group.rb

@@ -38,6 +38,7 @@ module RuboCop
       class EmptyExampleGroup < Base
         extend AutoCorrector
 
+        include InsideExample
         include RangeHelp
 
         MSG = 'Empty example group detected.'
@@ -136,9 +137,9 @@ module RuboCop
           }
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return if node.each_ancestor(:any_def).any?
-          return if node.each_ancestor(:block).any? { |block| example?(block) }
+          return if inside_example?(node)
 
           example_group_body(node) do |body|
             next unless offensive?(body)

data/lib/rubocop/cop/rspec/empty_hook.rb

@@ -34,7 +34,7 @@ module RuboCop
           (block $(send nil? #Hooks.all ...) _ nil?)
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           empty_hook?(node) do |hook|
             add_offense(hook) do |corrector|
               corrector.remove(

data/lib/rubocop/cop/rspec/empty_line_after_example.rb

@@ -46,7 +46,7 @@ module RuboCop
 
         MSG = 'Add an empty line after `%<example>s`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless example?(node)
           return if allowed_one_liner?(node)
 

data/lib/rubocop/cop/rspec/empty_line_after_example_group.rb

@@ -29,7 +29,7 @@ module RuboCop
 
         MSG = 'Add an empty line after `%<example_group>s`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless spec_group?(node)
 
           missing_separating_line_offense(node) do |method|

data/lib/rubocop/cop/rspec/empty_line_after_final_let.rb

@@ -23,8 +23,13 @@ module RuboCop
 
         MSG = 'Add an empty line after the last `%<let>s`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless example_group_with_body?(node)
+        # @!method example_group_or_include?(node)
+        def_node_matcher :example_group_or_include?, <<~PATTERN
+          (block (send #rspec? {#SharedGroups.all #ExampleGroups.all #Includes.all} ...) args $_)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+          return unless example_group_or_include?(node)
 
           final_let = node.body.child_nodes.reverse.find { |child| let?(child) }
 

data/lib/rubocop/cop/rspec/empty_line_after_hook.rb

@@ -68,6 +68,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/rspec/empty_line_after_subject.rb

@@ -22,7 +22,7 @@ module RuboCop
 
         MSG = 'Add an empty line after `%<subject>s`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless subject?(node)
           return unless inside_example_group?(node)
 

data/lib/rubocop/cop/rspec/example_length.rb

@@ -59,7 +59,7 @@ module RuboCop
 
         LABEL = 'Example'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless example?(node)
 
           check_code_length(node)

data/lib/rubocop/cop/rspec/example_without_description.rb

@@ -66,7 +66,7 @@ module RuboCop
         # @!method example_description(node)
         def_node_matcher :example_description, '(send nil? _ $(str $_))'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless example?(node)
 
           check_example_without_description(node.send_node)

data/lib/rubocop/cop/rspec/example_wording.rb

@@ -78,7 +78,7 @@ module RuboCop
           } ...) ...)
         PATTERN
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           it_description(node) do |description_node, message|
             if message.match?(SHOULD_PREFIX)
               add_wording_offense(description_node, MSG_SHOULD)

data/lib/rubocop/cop/rspec/expect_actual.rb

@@ -19,12 +19,15 @@ module RuboCop
       #   expect(name).to eq("John")
       #
       #   # bad (not supported autocorrection)
+      #   expect(42).to be_even
       #   expect(false).to eq(true)
+      #   expect("user").to be_present
       #
       class ExpectActual < Base
         extend AutoCorrector
 
         MSG = 'Provide the actual value you are testing to `expect(...)`.'
+        MSG_NO_ARG = 'Test a non-literal value with `expect(...)`.'
 
         RESTRICT_ON_SEND = Runners.all
 
@@ -65,26 +68,43 @@ module RuboCop
           )
         PATTERN
 
+        # @!method expect_literal_no_arg(node)
+        def_node_matcher :expect_literal_no_arg, <<~PATTERN
+          (send
+            (send nil? :expect $#literal?)
+            #Runners.all
+            $(send nil? $_)
+          )
+        PATTERN
+
         def on_send(node)
           expect_literal(node) do |actual, send_node, matcher, expected|
-            next if SKIPPED_MATCHERS.include?(matcher)
-
-            add_offense(actual) do |corrector|
-              next unless CORRECTABLE_MATCHERS.include?(matcher)
-              next if literal?(expected)
-
-              corrector.replace(actual, expected.source)
-              if matcher == :be
-                corrector.replace(expected, actual.source)
-              else
-                corrector.replace(send_node, "#{matcher}(#{actual.source})")
-              end
-            end
+            register_offense(actual, send_node, matcher, expected)
+          end
+          expect_literal_no_arg(node) do |actual, send_node, matcher|
+            register_offense(actual, send_node, matcher, nil)
           end
         end
 
         private
 
+        def register_offense(actual, send_node, matcher, expected)
+          return if SKIPPED_MATCHERS.include?(matcher)
+
+          message = expected.nil? ? MSG_NO_ARG : MSG
+          add_offense(actual, message: message) do |corrector|
+            next unless CORRECTABLE_MATCHERS.include?(matcher)
+            next if expected.nil? || literal?(expected)
+
+            corrector.replace(actual, expected.source)
+            if matcher == :be
+              corrector.replace(expected, actual.source)
+            else
+              corrector.replace(send_node, "#{matcher}(#{actual.source})")
+            end
+          end
+        end
+
         # This is not implemented using a NodePattern because it seems
         # to not be able to match against an explicit (nil) sexp
         def literal?(node)

data/lib/rubocop/cop/rspec/expect_change.rb

@@ -10,6 +10,10 @@ module RuboCop
       #
       # This cop can be configured using the `EnforcedStyle` option.
       #
+      # When using compound expectations with `change` and a negated matcher
+      # (e.g., `not_change`), you can configure the `NegatedMatcher` option
+      # to ensure consistent style enforcement across both matchers.
+      #
       # @safety
       #   Autocorrection is unsafe because `method_call` style calls the
       #   receiver *once* and sends the message to it before and after
@@ -48,23 +52,29 @@ module RuboCop
       #   # good
       #   expect { run }.to change { Foo.bar }
       #
+      # @example `NegatedMatcher: not_change` (with compound expectations)
+      #   # bad
+      #   expect { run }.to change(Foo, :bar).and not_change { Foo.baz }
+      #
+      #   # good
+      #   expect { run }.to change(Foo, :bar).and not_change(Foo, :baz)
+      #
       class ExpectChange < Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG_BLOCK = 'Prefer `change(%<obj>s, :%<attr>s)`.'
-        MSG_CALL = 'Prefer `change { %<obj>s.%<attr>s }`.'
-        RESTRICT_ON_SEND = %i[change].freeze
+        MSG_BLOCK = 'Prefer `%<matcher>s(%<obj>s, :%<attr>s)`.'
+        MSG_CALL = 'Prefer `%<matcher>s { %<obj>s.%<attr>s }`.'
 
-        # @!method expect_change_with_arguments(node)
-        def_node_matcher :expect_change_with_arguments, <<~PATTERN
-          (send nil? :change $_ ({sym str} $_))
+        # @!method expect_matcher_with_arguments(node)
+        def_node_matcher :expect_matcher_with_arguments, <<~PATTERN
+          (send nil? _ $_ ({sym str} $_))
         PATTERN
 
-        # @!method expect_change_with_block(node)
-        def_node_matcher :expect_change_with_block, <<~PATTERN
+        # @!method expect_matcher_with_block(node)
+        def_node_matcher :expect_matcher_with_block, <<~PATTERN
           (block
-            (send nil? :change)
+            (send nil? _)
             (args)
             (send
               ${
@@ -78,27 +88,47 @@ module RuboCop
 
         def on_send(node)
           return unless style == :block
+          return unless matcher_method?(node.method_name)
 
-          expect_change_with_arguments(node) do |receiver, message|
-            msg = format(MSG_CALL, obj: receiver.source, attr: message)
+          expect_matcher_with_arguments(node) do |receiver, message|
+            matcher_name = node.method_name.to_s
+            msg = format(MSG_CALL, matcher: matcher_name,
+                                   obj: receiver.source, attr: message)
             add_offense(node, message: msg) do |corrector|
-              replacement = "change { #{receiver.source}.#{message} }"
+              replacement = "#{matcher_name} { #{receiver.source}.#{message} }"
               corrector.replace(node, replacement)
             end
           end
         end
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless style == :method_call
+          return unless matcher_method?(node.method_name)
 
-          expect_change_with_block(node) do |receiver, message|
-            msg = format(MSG_BLOCK, obj: receiver.source, attr: message)
+          expect_matcher_with_block(node) do |receiver, message|
+            matcher_name = node.method_name.to_s
+            msg = format(MSG_BLOCK, matcher: matcher_name,
+                                    obj: receiver.source, attr: message)
             add_offense(node, message: msg) do |corrector|
-              replacement = "change(#{receiver.source}, :#{message})"
+              replacement = "#{matcher_name}(#{receiver.source}, :#{message})"
               corrector.replace(node, replacement)
             end
           end
         end
+
+        private
+
+        def matcher_method_names
+          [:change, negated_matcher&.to_sym].compact
+        end
+
+        def matcher_method?(method_name)
+          matcher_method_names.include?(method_name)
+        end
+
+        def negated_matcher
+          cop_config['NegatedMatcher']
+        end
       end
     end
   end

data/lib/rubocop/cop/rspec/expect_in_hook.rb

@@ -38,6 +38,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/rspec/expect_in_let.rb

@@ -22,7 +22,7 @@ module RuboCop
         # @!method expectation(node)
         def_node_search :expectation, '(send nil? #Expectations.all ...)'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless let?(node)
           return if node.body.nil?