[Fix rubocop#9525] Add AllowMethodsWithArguments option to `Style/S…

…ymbolProc`

## Summary

Fixes rubocop#9525.

This PR adds `AllowMethodsWithArguments` option to `Style/SymbolProc`.

### `AllowMethodsWithArguments: false` (default)

```ruby
# bad
something.do_something(foo) { |o| o.bar }

# good
something.do_something(foo, &:bar)
```

### `AllowMethodsWithArguments: true`

```ruby
# good
something.do_something(foo) { |o| o.bar }
```

If user prefer a style that allows block for method with arguments,
the user can set `true` to `AllowMethodsWithArguments`.

## Other Information

It may be possible to consider defaulting to `AllowMethodsWithArguments: true`,
but at the time of this patch `Style/SymbolProc` cop respect keeping the existing behavior.

changelog/new_add_allow_if_method_has_arguments_option_to_style_symbol_proc.md

@@ -0,0 +1 @@
+* [#9525](https://github.com/rubocop-hq/rubocop/issues/9525): Add `AllowMethodsWithArguments` option to `Style/SymbolProc`. ([@koic][])

config/default.yml

@@ -4588,6 +4588,7 @@ Style/SymbolProc:
   Safe: false
   VersionAdded: '0.26'
   VersionChanged: '1.5'
+  AllowMethodsWithArguments: false
   # A list of method names to be ignored by the check.
   # The names should be fairly unique, otherwise you'll end up ignoring lots of code.
   IgnoredMethods:

lib/rubocop/cop/style/symbol_proc.rb

@@ -5,13 +5,27 @@ module Cop
     module Style
       # Use symbols as procs when possible.
       #
+      # If you prefer a style that allows block for method with arguments,
+      # please set `true` to `AllowMethodsWithArguments`.
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
       #   something.map { _1.upcase }
       #
       #   # good
       #   something.map(&:upcase)
+      #
+      # @example AllowMethodsWithArguments: false (default)
+      #   # bad
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      #   # good
+      #   something.do_something(foo, &:bar)
+      #
+      # @example AllowMethodsWithArguments: true
+      #   # good
+      #   something.do_something(foo) { |o| o.bar }
       class SymbolProc < Base
         include RangeHelp
         include IgnoredMethods
@@ -42,6 +56,7 @@ def on_block(node)
             return if proc_node?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
             return if ignored_method?(dispatch_node.method_name)
+            return if allow_if_method_has_argument?(node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
 
             register_offense(node, method_name, dispatch_node.method_name)
@@ -103,6 +118,10 @@ def begin_pos_for_replacement(node)
             node.loc.begin.begin_pos
           end
         end
+
+        def allow_if_method_has_argument?(node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !node.arguments.count.zero?
+        end
       end
     end
   end

spec/rubocop/cop/style/symbol_proc_spec.rb

@@ -142,16 +142,53 @@
     expect(&run).not_to raise_error
   end
 
-  context 'when `super` has arguments' do
-    it 'registers an offense' do
-      expect_offense(<<~RUBY)
-        super(one, two) { |x| x.test }
-                        ^^^^^^^^^^^^^^ Pass `&:test` as an argument to `super` instead of a block.
-      RUBY
+  context 'when `AllowMethodsWithArguments: true`' do
+    let(:cop_config) { { 'AllowMethodsWithArguments' => true } }
+
+    context 'when method has arguments' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          do_something(one, two) { |x| x.test }
+        RUBY
+      end
+    end
 
-      expect_correction(<<~RUBY)
-        super(one, two, &:test)
-      RUBY
+    context 'when `super` has arguments' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          super(one, two) { |x| x.test }
+        RUBY
+      end
+    end
+  end
+
+  context 'when `AllowMethodsWithArguments: false`' do
+    let(:cop_config) { { 'AllowMethodsWithArguments' => false } }
+
+    context 'when method has arguments' do
+      it 'registers an offense' do
+        expect_offense(<<~RUBY)
+          do_something(one, two) { |x| x.test }
+                                 ^^^^^^^^^^^^^^ Pass `&:test` as an argument to `do_something` instead of a block.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          do_something(one, two, &:test)
+        RUBY
+      end
+    end
+
+    context 'when `super` has arguments' do
+      it 'registers an offense' do
+        expect_offense(<<~RUBY)
+          super(one, two) { |x| x.test }
+                          ^^^^^^^^^^^^^^ Pass `&:test` as an argument to `super` instead of a block.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          super(one, two, &:test)
+        RUBY
+      end
     end
   end