Merge pull request #1555 from ydah/fix-incorrect-autocorrect-rspec-Pr…

…edicateMatcher

Fix an incorrect autocorrect for `RSpec/PredicateMatcher` when multiline expect and predicate method with heredoc

CHANGELOG.md

@@ -5,6 +5,7 @@
 - Fix a false negative for `RSpec/Pending` when using skipped in metadata is multiline string. ([@ydah])
 - Fix a false positive for `RSpec/NoExpectationExample` when using skipped in metadata is multiline string. ([@ydah])
 - Fix a false positive for `RSpec/ContextMethod` when multi-line context with `#` at the beginning. ([@ydah])
+- Fix an incorrect autocorrect for `RSpec/PredicateMatcher` when multiline expect and predicate method with heredoc. ([@ydah])
 
 ## 2.17.0 (2023-01-13)
 

docs/modules/ROOT/pages/cops_rspec.adoc

@@ -3968,6 +3968,17 @@ expect(foo).to be_something
 
 # good - the above code is rewritten to it by this cop
 expect(foo.something?).to be(true)
+
+# bad - no autocorrect
+expect(foo)
+  .to be_something(<<~TEXT)
+    bar
+  TEXT
+
+# good
+expect(foo.something?(<<~TEXT)).to be(true)
+  bar
+TEXT
 ----
 
 ==== Strict: false, EnforcedStyle: explicit

lib/rubocop/cop/rspec/predicate_matcher.rb

@@ -118,7 +118,7 @@ def true?(to_symbol, matcher)
       end
 
       # A helper for `explicit` style
-      module ExplicitHelper
+      module ExplicitHelper # rubocop:disable Metrics/ModuleLength
         include RuboCop::RSpec::Language
         extend NodePattern::Macros
 
@@ -150,11 +150,23 @@ def check_explicit(node) # rubocop:disable Metrics/MethodLength
 
           predicate_matcher?(node) do |actual, matcher|
             add_offense(node, message: message_explicit(matcher)) do |corrector|
+              next if uncorrectable_matcher?(node, matcher)
+
               corrector_explicit(corrector, node, actual, matcher, matcher)
             end
           end
         end
 
+        def uncorrectable_matcher?(node, matcher)
+          heredoc_argument?(matcher) && !same_line?(node, matcher)
+        end
+
+        def heredoc_argument?(matcher)
+          matcher.arguments.select do |arg|
+            %i[str dstr xstr].include?(arg.type)
+          end.any?(&:heredoc?)
+        end
+
         # @!method predicate_matcher?(node)
         def_node_matcher :predicate_matcher?, <<-PATTERN
           (send
@@ -271,6 +283,17 @@ def replacement_matcher(node)
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be(true)
       #
+      #   # bad - no autocorrect
+      #   expect(foo)
+      #     .to be_something(<<~TEXT)
+      #       bar
+      #     TEXT
+      #
+      #   # good
+      #   expect(foo.something?(<<~TEXT)).to be(true)
+      #     bar
+      #   TEXT
+      #
       # @example Strict: false, EnforcedStyle: explicit
       #   # bad
       #   expect(foo).to be_something

spec/rubocop/cop/rspec/predicate_matcher_spec.rb

@@ -93,6 +93,21 @@
         RUBY
       end
 
+      it 'registers an offense for a predicate method with heredoc' do
+        expect_offense(<<~RUBY)
+          expect(foo.include?(<<~TEXT)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include` matcher over `include?`.
+            bar
+          TEXT
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to include(<<~TEXT)
+            bar
+          TEXT
+        RUBY
+      end
+
       it 'registers an offense for a predicate method with a block' do
         expect_offense(<<~RUBY)
           expect(foo.all?(&:present?)).to be_truthy
@@ -312,6 +327,78 @@
         RUBY
       end
 
+      it 'registers an offense for a predicate method with heredoc' do
+        expect_offense(<<~RUBY)
+          expect(foo).to include(<<~TEXT)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            bar
+          TEXT
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.include?(<<~TEXT)).to #{matcher_true}
+            bar
+          TEXT
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc and multiline expect' do
+        expect_offense(<<~RUBY)
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(<<~TEXT)
+              bar
+            TEXT
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(bar, <<~TEXT, 'baz')
+              bar
+            TEXT
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc include #{} and multiline expect' do
+        expect_offense(<<~'RUBY')
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(<<~TEXT)
+              #{bar}
+            TEXT
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(bar, <<~TEXT, 'baz')
+              #{bar}
+            TEXT
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc surrounded by back ticks and multiline expect' do
+        expect_offense(<<~'RUBY')
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(<<~`COMMAND`)
+              pwd
+            COMMAND
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            .to include(bar, <<~COMMAND, 'baz')
+              pwd
+            COMMAND
+        RUBY
+
+        expect_no_corrections
+      end
+
       it 'registers an offense for a predicate method with a block' do
         expect_offense(<<~RUBY)
           expect(foo).to be_all { |x| x.present? }