rubocop-rspec 2.26.1 → 2.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bf3d2ebea2c15361963f61079a377b069b01ed6ebb4979b0229471b38866098
-  data.tar.gz: 1910cd808996e04802802dd138e297c98191fd9e8a5bf0c35644ebf589e7bf2e
+  metadata.gz: 66ac0fecdd858c4b85a06c9e32bdb680d2dd92aa98100740302702a1737a3a9c
+  data.tar.gz: 5f688cf15390149d3a7dc6e2d3f67e041248ee43a3dce5e47d2370d2813f86d7
 SHA512:
-  metadata.gz: 1b94923f79321f29b16c763f995a36c547068a8f69b52e1a5dbe99999f38052f609743fd7132aa672aea7a57726a135d99c171406774a0cc05c30114602dd3d7
-  data.tar.gz: 0fffcfe3e0f089c416bf6fa61dfd89217ccfe7203f0c7bbf4185a30d94a08a7146848ffb592f374f0aa100067d8ca7eec80986310069b9d6c9b16f73c2f72e29
+  metadata.gz: 9fc186d4d8191c461dee977e64a2f0a295389be99a8054bb7ba75258e429c5c3dc624b3d6da0a19b65a024648f1922ef9646af5bac44d0b7c3255a99ac8e14bc
+  data.tar.gz: 1d603f51d43de587cd17939252604f1d86d371e0e6883a4289c219eed97d0862bd4ba29d2c3ba205ceed3c4157692d4fbbf52b63d020facfd0d2798bef284e55

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Master (Unreleased)
 
+## 2.27.0 (2024-03-01)
+
+- Add new `RSpec/IsExpectedSpecify` cop. ([@ydah])
+- Add new `RSpec/RepeatedSubjectCall` cop. ([@drcapulet])
+- Add support for `assert_true`, `assert_false`, `assert_not_equal`, `assert_not_nil`, `*_empty`, `*_predicate`, `*_kind_of`, `*_in_delta`, `*_match`, `*_instance_of` and `*_includes` assertions in `RSpec/Rails/MinitestAssertions`. ([@ydah], [@G-Rath])
+- Support asserts with messages in `Rspec/BeEmpty`. ([@G-Rath])
+- Fix a false positive for `RSpec/ExpectActual` when used with rspec-rails routing matchers. ([@naveg])
+- Add configuration option `ResponseMethods` to `RSpec/Rails/HaveHttpStatus`. ([@ydah])
+- Fix a false negative for `RSpec/DescribedClass` when class with constant. ([@ydah])
+- Fix a false positive for `RSpec/ExampleWithoutDescription` when `specify` with multi-line block and missing description. ([@ydah])
+- Fix an incorrect autocorrect for `RSpec/ChangeByZero` when compound expectations with line break before `.by(0)`. ([@ydah])
+
 ## 2.26.1 (2024-01-05)
 
 - Fix an error for `RSpec/SharedExamples` when using examples without argument. ([@ydah])
@@ -845,6 +857,7 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@deivid-rodriguez]: https://github.com/deivid-rodriguez
 [@dgollahon]: https://github.com/dgollahon
 [@dmitrytsepelev]: https://github.com/dmitrytsepelev
+[@drcapulet]: https://github.com/drcapulet
 [@drowze]: https://github.com/Drowze
 [@dswij]: https://github.com/dswij
 [@dvandersluis]: https://github.com/dvandersluis
@@ -892,6 +905,7 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@mockdeep]: https://github.com/mockdeep
 [@mothonmars]: https://github.com/MothOnMars
 [@mvz]: https://github.com/mvz
+[@naveg]: https://github.com/naveg
 [@nc-holodakg]: https://github.com/nc-holodakg
 [@nevir]: https://github.com/nevir
 [@ngouy]: https://github.com/ngouy

data/config/default.yml

@@ -548,6 +548,13 @@ RSpec/InstanceVariable:
   StyleGuide: https://rspec.rubystyle.guide/#instance-variables
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable
 
+RSpec/IsExpectedSpecify:
+  Description: Check for `specify` with `is_expected` and one-liner expectations.
+  Enabled: pending
+  VersionAdded: '2.27'
+  StyleGuide: https://rspec.rubystyle.guide/#it-and-specify
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IsExpectedSpecify
+
 RSpec/ItBehavesLike:
   Description: Checks that only one `it_behaves_like` style is used.
   Enabled: true
@@ -813,6 +820,12 @@ RSpec/RepeatedIncludeExample:
   VersionAdded: '1.44'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedIncludeExample
 
+RSpec/RepeatedSubjectCall:
+  Description: Checks for repeated calls to subject missing that it is memoized.
+  Enabled: pending
+  VersionAdded: '2.27'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedSubjectCall
+
 RSpec/ReturnFromStub:
   Description: Checks for consistent style of stub's return setting.
   Enabled: true
@@ -1126,8 +1139,12 @@ RSpec/Rails/AvoidSetupHook:
 RSpec/Rails/HaveHttpStatus:
   Description: Checks that tests use `have_http_status` instead of equality matchers.
   Enabled: pending
+  ResponseMethods:
+    - response
+    - last_response
   SafeAutoCorrect: false
   VersionAdded: '2.12'
+  VersionChanged: '2.27'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HaveHttpStatus
 
 RSpec/Rails/HttpStatus:
@@ -1166,7 +1183,7 @@ RSpec/Rails/InferredSpecType:
     views: view
 
 RSpec/Rails/MinitestAssertions:
-  Description: Check if using Minitest matchers.
+  Description: Check if using Minitest-like matchers.
   Enabled: pending
   VersionAdded: '2.17'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/MinitestAssertions

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

@@ -28,6 +28,7 @@ module RuboCop
               (send nil? :match_array (array))
               (send nil? :contain_exactly)
             }
+            _?
           )
         PATTERN
 

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

@@ -59,6 +59,8 @@ module RuboCop
       #
       class ChangeByZero < Base
         extend AutoCorrector
+        include RangeHelp
+
         MSG = 'Prefer `not_to change` over `to %<method>s.by(0)`.'
         MSG_COMPOUND = 'Prefer %<preferred>s with compound expectations ' \
                        'over `%<method>s.by(0)`.'
@@ -140,8 +142,32 @@ module RuboCop
 
           change_nodes(node) do |change_node|
             corrector.replace(change_node.loc.selector, negated_matcher)
-            range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+            insert_operator(corrector, node, change_node)
+            remove_by_zero(corrector, node, change_node)
+          end
+        end
+
+        def insert_operator(corrector, node, change_node)
+          operator = node.right_siblings.first
+          return unless %i[& |].include?(operator)
+
+          corrector.insert_after(
+            replace_node(node, change_node), " #{operator}"
+          )
+        end
+
+        def replace_node(node, change_node)
+          expect_change_with_arguments(node) ? change_node : change_node.parent
+        end
+
+        def remove_by_zero(corrector, node, change_node)
+          range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+          if change_node.loc.line == range.line
             corrector.remove(range)
+          else
+            corrector.remove(
+              range_by_whole_lines(range, include_final_newline: true)
+            )
           end
         end
 

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

@@ -113,7 +113,7 @@ module RuboCop
         def find_usage(node, &block)
           yield(node) if offensive?(node)
 
-          return if scope_change?(node) || node.const_type?
+          return if scope_change?(node)
 
           node.each_child_node do |child|
             find_usage(child, &block)
@@ -194,7 +194,8 @@ module RuboCop
         #   const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C]
         #   const_name(s(:const, s(:cbase), :C))          # => [nil, :C]
         def const_name(node)
-          namespace, name = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          namespace = node.namespace
+          name = node.short_name
           if !namespace
             [name]
           elsif namespace.const_type?

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

@@ -7,6 +7,7 @@ module RuboCop
       #
       # RSpec allows for auto-generated example descriptions when there is no
       # description provided or the description is an empty one.
+      # It is acceptable to use `specify` without a description
       #
       # This cop removes empty descriptions.
       # It also defines whether auto-generated description is allowed, based
@@ -14,17 +15,24 @@ module RuboCop
       #
       # This cop can be configured using the `EnforcedStyle` option
       #
+      # @example
+      #   # always good
+      #   specify do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
       # @example `EnforcedStyle: always_allow` (default)
       #   # bad
       #   it('') { is_expected.to be_good }
-      #   it '' do
+      #   specify '' do
       #     result = service.call
       #     expect(result).to be(true)
       #   end
       #
       #   # good
       #   it { is_expected.to be_good }
-      #   it do
+      #   specify do
       #     result = service.call
       #     expect(result).to be(true)
       #   end
@@ -75,6 +83,7 @@ module RuboCop
         def check_example_without_description(node)
           return if node.arguments?
           return unless disallow_empty_description?(node)
+          return if node.method?(:specify) && node.parent.multiline?
 
           add_offense(node, message: MSG_ADD_DESCRIPTION)
         end

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

@@ -50,7 +50,8 @@ module RuboCop
           regexp
         ].freeze
 
-        SUPPORTED_MATCHERS = %i[eq eql equal be].freeze
+        SKIPPED_MATCHERS = %i[route_to be_routable].freeze
+        CORRECTABLE_MATCHERS = %i[eq eql equal be].freeze
 
         # @!method expect_literal(node)
         def_node_matcher :expect_literal, <<~PATTERN
@@ -66,8 +67,10 @@ module RuboCop
 
         def on_send(node)
           expect_literal(node) do |actual, matcher, expected|
+            next if SKIPPED_MATCHERS.include?(matcher)
+
             add_offense(actual.source_range) do |corrector|
-              next unless SUPPORTED_MATCHERS.include?(matcher)
+              next unless CORRECTABLE_MATCHERS.include?(matcher)
               next if literal?(expected)
 
               swap(corrector, actual, expected)

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

@@ -22,10 +22,7 @@ module RuboCop
         def on_gvasgn(node)
           return unless inside_example_scope?(node)
 
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          variable_name, _rhs = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
-          name = variable_name[1..]
+          name = node.name[1..]
           return unless name.eql?('stdout') || name.eql?('stderr')
 
           add_offense(node.loc.name, message: format(MSG, name: name))

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `specify` with `is_expected` and one-liner expectations.
+      #
+      # @example
+      #   # bad
+      #   specify { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   specify do
+      #     # ...
+      #   end
+      #   specify { expect(sqrt(4)).to eq(2) }
+      #
+      class IsExpectedSpecify < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[specify].freeze
+        IS_EXPECTED_METHODS = ::Set[:is_expected, :are_expected].freeze
+        MSG = 'Use `it` instead of `specify`.'
+
+        # @!method offense?(node)
+        def_node_matcher :offense?, <<~PATTERN
+          (block (send _ :specify) _ (send (send _ IS_EXPECTED_METHODS) ...))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.single_line? && offense?(block_node)
+
+          selector = node.loc.selector
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,6 @@ module RuboCop
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'
 
-        SUPPORTED_STYLES = %w[allow expect].freeze
         RESTRICT_ON_SEND = %i[to].freeze
 
         # @!method message_expectation(node)

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

@@ -39,8 +39,6 @@ module RuboCop
                             'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
-        SUPPORTED_STYLES = %w[have_received receive].freeze
-
         RESTRICT_ON_SEND = Runners.all
 
         # @!method message_expectation(node)

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

@@ -48,12 +48,17 @@ module RuboCop
       #     end
       #   end
       #
-      # @example configuration
-      #   # .rubocop.yml
-      #   # RSpec/MultipleExpectations:
-      #   #   Max: 2
+      # @example `Max: 1` (default)
+      #   # bad
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # not flagged by rubocop
+      # @example `Max: 2`
+      #   # good
       #   describe UserCreator do
       #     it 'builds a user' do
       #       expect(user.name).to eq("John")

data/lib/rubocop/cop/rspec/rails/have_http_status.rb

@@ -6,20 +6,32 @@ module RuboCop
       module Rails
         # Checks that tests use `have_http_status` instead of equality matchers.
         #
-        # @example
+        # @example ResponseMethods: ['response', 'last_response'] (default)
         #   # bad
         #   expect(response.status).to be(200)
-        #   expect(response.code).to eq("200")
+        #   expect(last_response.code).to eq("200")
         #
         #   # good
         #   expect(response).to have_http_status(200)
+        #   expect(last_response).to have_http_status(200)
+        #
+        # @example ResponseMethods: ['foo_response']
+        #   # bad
+        #   expect(foo_response.status).to be(200)
+        #
+        #   # good
+        #   expect(foo_response).to have_http_status(200)
+        #
+        #   # also good
+        #   expect(response).to have_http_status(200)
+        #   expect(last_response).to have_http_status(200)
         #
         class HaveHttpStatus < ::RuboCop::Cop::Base
           extend AutoCorrector
 
           MSG =
-            'Prefer `expect(response).%<to>s have_http_status(%<status>s)` ' \
-            'over `%<bad_code>s`.'
+            'Prefer `expect(%<response>s).%<to>s ' \
+            'have_http_status(%<status>s)` over `%<bad_code>s`.'
 
           RUNNERS = %i[to to_not not_to].to_set
           RESTRICT_ON_SEND = RUNNERS
@@ -28,26 +40,38 @@ module RuboCop
           def_node_matcher :match_status, <<~PATTERN
             (send
               (send nil? :expect
-                $(send (send nil? :response) {:status :code})
+                $(send $(send nil? #response_methods?) {:status :code})
               )
               $RUNNERS
               $(send nil? {:be :eq :eql :equal} ({int str} $_))
             )
           PATTERN
 
-          def on_send(node)
-            match_status(node) do |response_status, to, match, status|
+          def on_send(node) # rubocop:disable Metrics/MethodLength
+            match_status(node) do
+              |response_status, response_method, to, match, status|
               return unless status.to_s.match?(/\A\d+\z/)
 
-              message = format(MSG, to: to, status: status,
+              message = format(MSG, response: response_method.method_name,
+                                    to: to, status: status,
                                     bad_code: node.source)
               add_offense(node, message: message) do |corrector|
-                corrector.replace(response_status, 'response')
+                corrector.replace(response_status, response_method.method_name)
                 corrector.replace(match.loc.selector, 'have_http_status')
                 corrector.replace(match.first_argument, status.to_s)
               end
             end
           end
+
+          private
+
+          def response_methods?(name)
+            response_methods.include?(name.to_s)
+          end
+
+          def response_methods
+            cop_config.fetch('ResponseMethods', [])
+          end
         end
       end
     end

data/lib/rubocop/cop/rspec/rails/minitest_assertions.rb

@@ -4,54 +4,346 @@ module RuboCop
   module Cop
     module RSpec
       module Rails
-        # Check if using Minitest matchers.
+        # Check if using Minitest-like matchers.
+        #
+        # Check the use of minitest-like matchers
+        # starting with `assert_` or `refute_`.
         #
         # @example
         #   # bad
         #   assert_equal(a, b)
         #   assert_equal a, b, "must be equal"
+        #   assert_not_includes a, b
         #   refute_equal(a, b)
+        #   assert_nil a
+        #   refute_empty(b)
+        #   assert_true(a)
+        #   assert_false(a)
         #
         #   # good
         #   expect(b).to eq(a)
         #   expect(b).to(eq(a), "must be equal")
+        #   expect(a).not_to include(b)
         #   expect(b).not_to eq(a)
+        #   expect(a).to eq(nil)
+        #   expect(a).not_to be_empty
+        #   expect(a).to be(true)
+        #   expect(a).to be(false)
         #
         class MinitestAssertions < Base
           extend AutoCorrector
 
+          # :nodoc:
+          class BasicAssertion
+            extend NodePattern::Macros
+
+            attr_reader :expected, :actual, :failure_message
+
+            def self.minitest_assertion
+              raise NotImplementedError
+            end
+
+            def initialize(expected, actual, failure_message)
+              @expected = expected&.source
+              @actual = actual.source
+              @failure_message = failure_message&.source
+            end
+
+            def replaced(node)
+              runner = negated?(node) ? 'not_to' : 'to'
+              if failure_message.nil?
+                "expect(#{actual}).#{runner} #{assertion}"
+              else
+                "expect(#{actual}).#{runner}(#{assertion}, #{failure_message})"
+              end
+            end
+
+            def negated?(node)
+              node.method_name.start_with?('assert_not_', 'refute_')
+            end
+
+            def assertion
+              raise NotImplementedError
+            end
+          end
+
+          # :nodoc:
+          class EqualAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_equal
+              assert_not_equal
+              refute_equal
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_equal :assert_not_equal :refute_equal} $_ $_ $_?)
+            PATTERN
+
+            def self.match(expected, actual, failure_message)
+              new(expected, actual, failure_message.first)
+            end
+
+            def assertion
+              "eq(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class KindOfAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_kind_of
+              assert_not_kind_of
+              refute_kind_of
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_kind_of :assert_not_kind_of :refute_kind_of} $_ $_ $_?)
+            PATTERN
+
+            def self.match(expected, actual, failure_message)
+              new(expected, actual, failure_message.first)
+            end
+
+            def assertion
+              "be_a_kind_of(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class InstanceOfAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_instance_of
+              assert_not_instance_of
+              refute_instance_of
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_instance_of :assert_not_instance_of :refute_instance_of} $_ $_ $_?)
+            PATTERN
+
+            def self.match(expected, actual, failure_message)
+              new(expected, actual, failure_message.first)
+            end
+
+            def assertion
+              "be_an_instance_of(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class IncludesAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_includes
+              assert_not_includes
+              refute_includes
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_includes :assert_not_includes :refute_includes} $_ $_ $_?)
+            PATTERN
+
+            def self.match(collection, expected, failure_message)
+              new(expected, collection, failure_message.first)
+            end
+
+            def assertion
+              "include(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class InDeltaAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_in_delta
+              assert_not_in_delta
+              refute_in_delta
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_in_delta :assert_not_in_delta :refute_in_delta} $_ $_ $_? $_?)
+            PATTERN
+
+            def self.match(expected, actual, delta, failure_message)
+              new(expected, actual, delta.first, failure_message.first)
+            end
+
+            def initialize(expected, actual, delta, fail_message)
+              super(expected, actual, fail_message)
+
+              @delta = delta&.source || '0.001'
+            end
+
+            def assertion
+              "be_within(#{@delta}).of(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class PredicateAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_predicate
+              assert_not_predicate
+              refute_predicate
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_predicate :assert_not_predicate :refute_predicate} $_ ${sym} $_?)
+            PATTERN
+
+            def self.match(subject, predicate, failure_message)
+              return nil unless predicate.value.end_with?('?')
+
+              new(predicate, subject, failure_message.first)
+            end
+
+            def assertion
+              "be_#{expected.delete_prefix(':').delete_suffix('?')}"
+            end
+          end
+
+          # :nodoc:
+          class MatchAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_match
+              refute_match
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_match :refute_match} $_ $_ $_?)
+            PATTERN
+
+            def self.match(matcher, actual, failure_message)
+              new(matcher, actual, failure_message.first)
+            end
+
+            def assertion
+              "match(#{expected})"
+            end
+          end
+
+          # :nodoc:
+          class NilAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_nil
+              assert_not_nil
+              refute_nil
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_nil :assert_not_nil :refute_nil} $_ $_?)
+            PATTERN
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'eq(nil)'
+            end
+          end
+
+          # :nodoc:
+          class EmptyAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_empty
+              assert_not_empty
+              refute_empty
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_empty :assert_not_empty :refute_empty} $_ $_?)
+            PATTERN
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be_empty'
+            end
+          end
+
+          # :nodoc:
+          class TrueAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_true
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_true} $_ $_?)
+            PATTERN
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be(true)'
+            end
+          end
+
+          # :nodoc:
+          class FalseAssertion < BasicAssertion
+            MATCHERS = %i[
+              assert_false
+            ].freeze
+
+            # @!method self.minitest_assertion(node)
+            def_node_matcher 'self.minitest_assertion', <<~PATTERN # rubocop:disable InternalAffairs/NodeMatcherDirective
+              (send nil? {:assert_false} $_ $_?)
+            PATTERN
+
+            def self.match(actual, failure_message)
+              new(nil, actual, failure_message.first)
+            end
+
+            def assertion
+              'be(false)'
+            end
+          end
+
           MSG = 'Use `%<prefer>s`.'
-          RESTRICT_ON_SEND = %i[assert_equal refute_equal].freeze
 
-          # @!method minitest_assertion(node)
-          def_node_matcher :minitest_assertion, <<~PATTERN
-            (send nil? {:assert_equal :refute_equal} $_ $_ $_?)
-          PATTERN
+          # TODO: replace with `BasicAssertion.subclasses` in Ruby 3.1+
+          ASSERTION_MATCHERS = constants(false).filter_map do |c|
+            const = const_get(c)
+
+            const if const.is_a?(Class) && const.superclass == BasicAssertion
+          end
+
+          RESTRICT_ON_SEND = ASSERTION_MATCHERS.flat_map { |m| m::MATCHERS }
 
           def on_send(node)
-            minitest_assertion(node) do |expected, actual, failure_message|
-              prefer = replacement(node, expected, actual,
-                                   failure_message.first)
-              add_offense(node, message: message(prefer)) do |corrector|
-                corrector.replace(node, prefer)
+            ASSERTION_MATCHERS.each do |m|
+              m.minitest_assertion(node) do |*args|
+                assertion = m.match(*args)
+
+                next if assertion.nil?
+
+                on_assertion(node, assertion)
               end
             end
           end
 
-          private
-
-          def replacement(node, expected, actual, failure_message)
-            runner = node.method?(:assert_equal) ? 'to' : 'not_to'
-            if failure_message.nil?
-              "expect(#{actual.source}).#{runner} eq(#{expected.source})"
-            else
-              "expect(#{actual.source}).#{runner}(eq(#{expected.source}), " \
-                "#{failure_message.source})"
+          def on_assertion(node, assertion)
+            preferred = assertion.replaced(node)
+            add_offense(node, message: message(preferred)) do |corrector|
+              corrector.replace(node, preferred)
             end
           end
 
-          def message(prefer)
-            format(MSG, prefer: prefer)
+          def message(preferred)
+            format(MSG, prefer: preferred)
           end
         end
       end

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

@@ -9,10 +9,12 @@ module RuboCop
       #   # bad
       #   expect(foo).to be_exist(bar)
       #   expect(foo).not_to be_include(bar)
+      #   expect(foo).to be_all(bar)
       #
       #   # good
       #   expect(foo).to exist(bar)
       #   expect(foo).not_to include(bar)
+      #   expect(foo).to all be(bar)
       #
       class RedundantPredicateMatcher < Base
         extend AutoCorrector
@@ -25,7 +27,7 @@ module RuboCop
 
         def on_send(node)
           return if node.parent.block_type? || node.arguments.empty?
-          return unless replacable_arguments?(node)
+          return unless replaceable_arguments?(node)
 
           method_name = node.method_name.to_s
           replaced = replaced_method_name(method_name)
@@ -43,7 +45,7 @@ module RuboCop
           format(MSG, bad: bad_method, good: good_method)
         end
 
-        def replacable_arguments?(node)
+        def replaceable_arguments?(node)
           if node.method?(:be_all)
             node.first_argument.send_type?
           else

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for repeated calls to subject missing that it is memoized.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     subject
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   it do
+      #     expect { subject }.to change { A.count }
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect { my_method }.to change { A.count }
+      #     expect { my_method }.to not_change { A.count }
+      #   end
+      #
+      class RepeatedSubjectCall < Base
+        include TopLevelGroup
+
+        MSG = 'Calls to subject are memoized, this block is misleading'
+
+        # @!method subject?(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject?(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method subject_calls(node, method_name)
+        def_node_search :subject_calls, <<~PATTERN
+          (send nil? %)
+        PATTERN
+
+        def on_top_level_group(node)
+          @subjects_by_node = detect_subjects_in_scope(node)
+
+          detect_offenses_in_block(node)
+        end
+
+        private
+
+        def detect_offense(example_node, subject_node)
+          walker = subject_node
+
+          while walker.parent? && walker.parent != example_node.body
+            walker = walker.parent
+
+            if walker.block_type? && walker.method?(:expect)
+              add_offense(walker)
+              return
+            end
+          end
+        end
+
+        def detect_offenses_in_block(node, subject_names = [])
+          subject_names = [*subject_names, *@subjects_by_node[node]]
+
+          if example?(node)
+            return detect_offenses_in_example(node, subject_names)
+          end
+
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            detect_offenses_in_block(child, subject_names)
+          end
+        end
+
+        def detect_offenses_in_example(node, subject_names)
+          return unless node.body
+
+          subjects_used = Hash.new(false)
+
+          subject_calls(node.body, Set[*subject_names, :subject]).each do |call|
+            if subjects_used[call.method_name]
+              detect_offense(node, call)
+            else
+              subjects_used[call.method_name] = true
+            end
+          end
+        end
+
+        def detect_subjects_in_scope(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            subject?(child) do |name|
+              outer_example_group = child.each_ancestor(:block).find do |a|
+                example_group?(a)
+              end
+
+              (h[outer_example_group] ||= []) << name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -81,8 +81,7 @@ module RuboCop
         end
 
         def key_to_arg(node)
-          key, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          node.sym_type? ? ":#{key}" : node.source
+          node.sym_type? ? ":#{node.value}" : node.source
         end
 
         def replacement(method)

data/lib/rubocop/cop/rspec_cops.rb

@@ -78,6 +78,7 @@ require_relative 'rspec/implicit_subject'
 require_relative 'rspec/indexed_let'
 require_relative 'rspec/instance_spy'
 require_relative 'rspec/instance_variable'
+require_relative 'rspec/is_expected_specify'
 require_relative 'rspec/it_behaves_like'
 require_relative 'rspec/iterated_expectation'
 require_relative 'rspec/leading_subject'
@@ -113,6 +114,7 @@ require_relative 'rspec/repeated_example'
 require_relative 'rspec/repeated_example_group_body'
 require_relative 'rspec/repeated_example_group_description'
 require_relative 'rspec/repeated_include_example'
+require_relative 'rspec/repeated_subject_call'
 require_relative 'rspec/return_from_stub'
 require_relative 'rspec/scattered_let'
 require_relative 'rspec/scattered_setup'

data/lib/rubocop/rspec/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Version information for the RSpec RuboCop plugin.
     module Version
-      STRING = '2.26.1'
+      STRING = '2.27.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec
 version: !ruby/object:Gem::Version
-  version: 2.26.1
+  version: 2.27.0
 platform: ruby
 authors:
 - John Backus
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-05 00:00:00.000000000 Z
+date: 2024-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -139,6 +139,7 @@ files:
 - lib/rubocop/cop/rspec/indexed_let.rb
 - lib/rubocop/cop/rspec/instance_spy.rb
 - lib/rubocop/cop/rspec/instance_variable.rb
+- lib/rubocop/cop/rspec/is_expected_specify.rb
 - lib/rubocop/cop/rspec/it_behaves_like.rb
 - lib/rubocop/cop/rspec/iterated_expectation.rb
 - lib/rubocop/cop/rspec/leading_subject.rb
@@ -192,6 +193,7 @@ files:
 - lib/rubocop/cop/rspec/repeated_example_group_body.rb
 - lib/rubocop/cop/rspec/repeated_example_group_description.rb
 - lib/rubocop/cop/rspec/repeated_include_example.rb
+- lib/rubocop/cop/rspec/repeated_subject_call.rb
 - lib/rubocop/cop/rspec/return_from_stub.rb
 - lib/rubocop/cop/rspec/scattered_let.rb
 - lib/rubocop/cop/rspec/scattered_setup.rb
@@ -251,7 +253,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Code style checking for RSpec files