Merge pull request #9178 from dvandersluis/issue/9174

[Fix #9174] Handle send nodes with unparenthesized arguments in `Style/SoleNestedConditional`

changelog/fix_handle_send_nodes_with_unparenthesized.md

@@ -0,0 +1 @@
+* [#9174](https://github.com/rubocop-hq/rubocop/issues/9174): Handle send nodes with unparenthesized arguments in `Style/SoleNestedConditional`. ([@dvandersluis][])

lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -72,15 +72,15 @@ def autocorrect(corrector, node, if_branch)
 
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_gurad_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           else
             correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
           end
 
           correct_for_comment(corrector, node, if_branch)
         end
 
-        def correct_for_gurad_condition_style(corrector, node, if_branch, and_operator)
+        def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           condition = if_branch.condition
           corrector.insert_after(node.condition, replacement_condition(and_operator, condition))
 
@@ -95,7 +95,7 @@ def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
           )
           corrector.replace(range, and_operator)
           corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-          corrector.wrap(if_branch.condition, '(', ')') if if_branch.condition.or_type?
+          corrector.wrap(if_branch.condition, '(', ')') if wrap_condition?(if_branch.condition)
         end
 
         def correct_for_comment(corrector, node, if_branch)
@@ -105,8 +105,13 @@ def correct_for_comment(corrector, node, if_branch)
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
         end
 
+        def wrap_condition?(node)
+          node.or_type? ||
+            (node.send_type? && node.arguments.any? && !node.parenthesized?)
+        end
+
         def replacement_condition(and_operator, condition)
-          if condition.or_type?
+          if wrap_condition?(condition)
             "#{and_operator}(#{condition.source})"
           else
             "#{and_operator}#{condition.source}"

spec/rubocop/cop/style/sole_nested_conditional_spec.rb

@@ -266,6 +266,82 @@
     RUBY
   end
 
+  context 'when the inner condition has a send node without parens' do
+    context 'in guard style' do
+      it 'registers an offense and corrects' do
+        expect_offense(<<~RUBY)
+          if foo
+            do_something if ok? bar
+                         ^^ Consider merging nested conditions into outer `if` conditions.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          if foo && (ok? bar)
+            do_something
+          end
+        RUBY
+      end
+    end
+
+    context 'in modifier style' do
+      it 'registers an offense and corrects' do
+        expect_offense(<<~RUBY)
+          if foo
+            if ok? bar
+            ^^ Consider merging nested conditions into outer `if` conditions.
+              do_something
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          if foo && (ok? bar)
+              do_something
+            end
+        RUBY
+      end
+    end
+  end
+
+  context 'when the inner condition has a send node with parens' do
+    context 'in guard style' do
+      it 'registers an offense and corrects' do
+        expect_offense(<<~RUBY)
+          if foo
+            do_something if ok?(bar)
+                         ^^ Consider merging nested conditions into outer `if` conditions.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          if foo && ok?(bar)
+            do_something
+          end
+        RUBY
+      end
+    end
+
+    context 'in modifier style' do
+      it 'registers an offense and corrects' do
+        expect_offense(<<~RUBY)
+          if foo
+            if ok?(bar)
+            ^^ Consider merging nested conditions into outer `if` conditions.
+              do_something
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          if foo && ok?(bar)
+              do_something
+            end
+        RUBY
+      end
+    end
+  end
+
   context 'when AllowModifier is true' do
     let(:cop_config) do
       { 'AllowModifier' => true }