rubocop 1.75.8 → 1.81.7

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -24,9 +24,6 @@ module RuboCop
           (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
         PATTERN
 
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
-
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
@@ -49,6 +46,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            in_pattern_matching_in_method_argument?(node) ||
             allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
@@ -122,6 +120,13 @@ module RuboCop
           hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
+        def in_pattern_matching_in_method_argument?(begin_node)
+          return false unless begin_node.parent&.call_type?
+          return false unless (node = begin_node.children.first)
+
+          target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
+        end
+
         def method_chain_begins_with_hash_literal(node)
           return if node.nil?
           return node if node.hash_type?
@@ -134,14 +139,14 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
-            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node)
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
               begin_node = begin_node.parent
             end
 
             return offense(begin_node, message)
           end
 
-          check_send(begin_node, node) if node.call_type?
+          check_send(begin_node, node) if call_node?(node)
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -156,8 +161,12 @@ module RuboCop
           if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
             return 'an expression'
           end
+          if disallowed_one_line_pattern_matching?(begin_node, node)
+            return 'a one-line pattern matching'
+          end
           return 'an interpolated expression' if interpolation?(begin_node)
-          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
           return if begin_node.chained?
 
@@ -180,14 +189,24 @@ module RuboCop
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
-        def argument_of_parenthesized_method_call?(begin_node)
-          node = begin_node.children.first
-          return false if node.basic_conditional? || method_call_parentheses_required?(node)
+        def argument_of_parenthesized_method_call?(begin_node, node)
+          if node.basic_conditional? || node.rescue_type? || method_call_parentheses_required?(node)
+            return false
+          end
           return false unless (parent = begin_node.parent)
 
           parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
         end
 
+        def oneline_rescue_parentheses_required?(begin_node, node)
+          return false unless node.rescue_type?
+          return false unless (parent = begin_node.parent)
+          return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
+
+          !parent.type?(:call, :array, :pair)
+        end
+
         def method_call_parentheses_required?(node)
           return false unless node.call_type?
 
@@ -198,10 +217,16 @@ module RuboCop
           !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end
 
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
         def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
           return check_unary(begin_node, node) if node.unary_operation?
 
-          return unless method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
           return if call_chain_starts_with_int?(begin_node, node) ||
                     do_end_block_in_method_chain?(begin_node, node)
 
@@ -212,8 +237,7 @@ module RuboCop
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         end
@@ -242,6 +266,15 @@ module RuboCop
           end
         end
 
+        def disallowed_one_line_pattern_matching?(begin_node, node)
+          if (parent = begin_node.parent)
+            return false if parent.any_def_type? && parent.endless?
+            return false if parent.assignment?
+          end
+
+          node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
+        end
+
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
@@ -266,13 +299,19 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
+
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
 
-          send_node, args = method_node_and_args(node)
+        def singular_parenthesized_parent?(begin_node)
+          return true unless begin_node.parent
+          return false if begin_node.parent.type?(:splat, :kwsplat)
 
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+          parentheses?(begin_node) && begin_node.parent.children.one?
         end
 
         def only_begin_arg?(args)

data/lib/rubocop/cop/style/redundant_regexp_argument.rb

@@ -66,6 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -73,6 +74,8 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?("\\'")
+            quote = "'"
           elsif new_argument.include?('\'')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
@@ -84,6 +87,7 @@ module RuboCop
 
           "#{quote}#{new_argument}#{quote}"
         end
+        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

data/lib/rubocop/cop/style/redundant_regexp_escape.rb

@@ -41,6 +41,7 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,6 +97,12 @@ module RuboCop
           delimiters.include?(char)
         end
 
+        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'.
+          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+        end
+
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
             yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape

data/lib/rubocop/cop/style/redundant_self.rb

@@ -67,6 +67,9 @@ module RuboCop
 
         def on_or_asgn(node)
           allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
         end
         alias on_and_asgn on_or_asgn
 
@@ -123,11 +126,11 @@ module RuboCop
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.
-          node.child_nodes.each do |child_node|
-            if child_node.lvasgn_type?
-              add_lhs_to_local_variables_scopes(node.condition, child_node.lhs)
-            elsif child_node.masgn_type?
-              add_masgn_lhs_variables(node.condition, child_node.lhs)
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
             end
           end
         end

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -86,6 +86,10 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
+      #
+      #   foo ? foo[index] : nil    # Ignored `foo&.[](index)` due to unclear readability benefit.
+      #   foo ? foo[idx] = v : nil  # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit.
+      #   foo ? foo * 42 : nil      # Ignored `foo&.*(42)` due to unclear readability benefit.
       class SafeNavigation < Base # rubocop:disable Metrics/ClassLength
         include NilMethods
         include RangeHelp
@@ -138,6 +142,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -146,13 +151,16 @@ module RuboCop
 
           body = extract_if_body(node)
           method_call = receiver.parent
+          return if dotless_operator_call?(method_call) || method_call.double_colon?
 
           removal_ranges = [begin_range(node, body), end_range(node, body)]
 
           report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.replace(receiver, checked_variable.source) if checked_variable.csend_type?
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
@@ -181,6 +189,8 @@ module RuboCop
           end
         end
 
+        private
+
         def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
           add_offense(offense_range) do |corrector|
             next if ignored_node?(node)
@@ -198,8 +208,6 @@ module RuboCop
           end
         end
 
-        private
-
         def find_method_chain(node)
           return node unless node&.parent&.call_type?
 
@@ -235,7 +243,7 @@ module RuboCop
           return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
           return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
           return false if chain_length(rhs, rhs_receiver) > max_chain_length
-          return false if unsafe_method_used?(rhs, rhs_receiver.parent)
+          return false if unsafe_method_used?(node, rhs, rhs_receiver.parent)
           return false if rhs.send_type? && rhs.method?(:empty?)
 
           true
@@ -253,6 +261,20 @@ module RuboCop
           end
         end
 
+        def dotless_operator_call?(method_call)
+          return true if dotless_operator_method?(method_call)
+
+          method_call = method_call.parent while method_call.parent.send_type?
+
+          dotless_operator_method?(method_call)
+        end
+
+        def dotless_operator_method?(method_call)
+          return false if method_call.loc.dot
+
+          method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -322,8 +344,16 @@ module RuboCop
 
         def matching_call_nodes?(left, right)
           return false unless left && right.respond_to?(:call_type?)
+          return false unless left.call_type? && right.call_type?
 
-          left.call_type? && right.call_type? && left.children == right.children
+          # Compare receiver and method name, but ignore the difference between
+          # safe navigation method call (`&.`) and dot method call (`.`).
+          left_receiver, left_method, *left_args = left.children
+          right_receiver, right_method, *right_args = right.children
+
+          left_method == right_method &&
+            matching_nodes?(left_receiver, right_receiver) &&
+            left_args == right_args
         end
 
         def chain_length(method_chain, method)
@@ -334,21 +364,24 @@ module RuboCop
           end
         end
 
-        def unsafe_method_used?(method_chain, method)
-          return true if unsafe_method?(method)
+        def unsafe_method_used?(node, method_chain, method)
+          return true if unsafe_method?(node, method)
 
           method.each_ancestor(:send).any? do |ancestor|
             break true unless config.cop_enabled?('Lint/SafeNavigationChain')
 
-            break true if unsafe_method?(ancestor)
+            break true if unsafe_method?(node, ancestor)
             break true if nil_methods.include?(ancestor.method_name)
             break false if ancestor == method_chain
           end
         end
 
-        def unsafe_method?(send_node)
-          negated?(send_node) ||
-            send_node.assignment? ||
+        def unsafe_method?(node, send_node)
+          return true if negated?(send_node)
+
+          return false if node.respond_to?(:ternary?) && node.ternary?
+
+          send_node.assignment? ||
             (!send_node.dot? && !send_node.safe_navigation?)
         end
 
@@ -377,8 +410,7 @@ module RuboCop
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
             break unless %i[send block].include?(ancestor.type)
-            next unless ancestor.send_type?
-            next if ancestor.safe_navigation?
+            next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')
 

data/lib/rubocop/cop/style/semicolon.rb

@@ -69,10 +69,11 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            semicolon_pos = semicolon_position(tokens)
+            next unless (semicolon_pos = semicolon_position(tokens))
+
             after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
 
-            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos]
           end
         end
 
@@ -119,6 +120,7 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -130,14 +132,19 @@ module RuboCop
               # without parentheses.
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
-                range_node = find_range_node(token_before_semicolon)
-                corrector.wrap(range_node, '(', ')') if range_node
+                node = find_node(range_nodes, token_before_semicolon)
+              elsif token_before_semicolon&.type == :tLABEL
+                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
+                space = node.parent.loc.selector.end.join(node.source_range.begin)
+                corrector.remove(space)
               end
 
+              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
@@ -153,9 +160,9 @@ module RuboCop
           end
         end
 
-        def find_range_node(token_before_semicolon)
-          range_nodes.detect do |range_node|
-            range_node.source_range.contains?(token_before_semicolon.pos)
+        def find_node(nodes, token_before_semicolon)
+          nodes.detect do |node|
+            node.source_range.overlaps?(token_before_semicolon.pos)
           end
         end
 
@@ -166,6 +173,15 @@ module RuboCop
           @range_nodes = ast.range_type? ? [ast] : []
           @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
+
+        def value_omission_pair_nodes
+          if instance_variable_defined?(:@value_omission_pair_nodes)
+            return @value_omission_pair_nodes
+          end
+
+          ast = processed_source.ast
+          @value_omission_pair_nodes = ast.each_descendant(:pair).to_a.select(&:value_omission?)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/single_line_methods.rb

@@ -65,7 +65,7 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method? ||
+          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
                           NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
           !body_node.type?(:begin, :kwbegin)
@@ -86,10 +86,10 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
-          self_receiver = node.self_receiver? ? 'self.' : ''
+          receiver = "#{node.receiver.source}." if node.receiver
           arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+          replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
         end
@@ -130,7 +130,10 @@ module RuboCop
         end
 
         def require_parentheses?(method_body)
-          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+          return false unless method_body.send_type?
+          return false if method_body.arithmetic_operation?
+
+          !method_body.arguments.empty? && !method_body.comparison_method?
         end
 
         def disallow_endless_method_style?

data/lib/rubocop/cop/style/sole_nested_conditional.rb

@@ -115,8 +115,9 @@ module RuboCop
         end
 
         def correct_node(corrector, node)
-          corrector.replace(node.loc.keyword, 'if') if node.unless?
+          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
           corrector.replace(node.condition, chainable_condition(node))
+          ignore_node(node)
         end
 
         def correct_for_guard_condition_style(corrector, node, if_branch)
@@ -128,6 +129,7 @@ module RuboCop
           corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_for_basic_condition_style(corrector, node, if_branch)
           range = range_between(
             node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
@@ -136,8 +138,14 @@ module RuboCop
 
           corrector.replace(if_branch.condition, chainable_condition(if_branch))
 
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+          end_range = if same_line?(node.loc.end, node.if_branch.loc.end)
+                        node.loc.end
+                      else
+                        range_by_whole_lines(node.loc.end, include_final_newline: true)
+                      end
+          corrector.remove(end_range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
           correct_node(corrector, if_branch)
@@ -174,6 +182,8 @@ module RuboCop
 
           if parenthesize_method?(condition)
             parenthesized_method_arguments(condition)
+          elsif condition.and_type?
+            parenthesized_and(condition)
           else
             "(#{condition.source})"
           end
@@ -185,12 +195,19 @@ module RuboCop
         end
 
         def add_parentheses?(node)
-          return true if node.assignment? || (node.operator_keyword? && !node.and_type?)
+          return true if node.assignment? || node.or_type?
+          return true if assignment_in_and?(node)
           return false unless node.call_type?
 
           (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
         end
 
+        def assignment_in_and?(node)
+          return false unless node.and_type?
+
+          node.each_descendant.any?(&:assignment?)
+        end
+
         def parenthesized_method_arguments(node)
           method_call = node.source_range.begin.join(node.loc.selector.end).source
           arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
@@ -198,6 +215,26 @@ module RuboCop
           "#{method_call}(#{arguments})"
         end
 
+        def parenthesized_and(node)
+          # We only need to add parentheses around the last clause if it's an assignment,
+          # because other clauses will be unchanged by merging conditionals.
+          lhs = node.lhs.source
+          rhs = parenthesized_and_clause(node.rhs)
+          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
+
+          "#{lhs}#{operator}#{rhs}"
+        end
+
+        def parenthesized_and_clause(node)
+          if node.and_type?
+            parenthesized_and(node)
+          elsif node.assignment?
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def allow_modifier?
           cop_config['AllowModifier']
         end

data/lib/rubocop/cop/style/stabby_lambda_parentheses.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for parentheses around stabby lambda arguments.
+      # Checks for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
       # @example EnforcedStyle: require_parentheses (default)

data/lib/rubocop/cop/style/string_concatenation.rb

@@ -100,7 +100,7 @@ module RuboCop
           node.receiver.str_type? &&
             node.first_argument.str_type? &&
             node.multiline? &&
-            node.source =~ /\+\s*\n/
+            node.source.match?(/\+\s*\n/)
         end
 
         def find_topmost_plus_node(node)
@@ -141,22 +141,26 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts = parts.map do |part|
-            case part.type
-            when :str
-              adjust_str(part)
-            when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
-            else
-              "\#{#{part.source}}"
-            end
-          end
+          interpolated_parts = parts.map { |part| adjust_str(part) }
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
-        def adjust_str(node)
-          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
         end
 
         def handle_quotes(parts)

data/lib/rubocop/cop/style/symbol_array.rb

@@ -81,7 +81,7 @@ module RuboCop
 
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
-            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
 
             content.include?(' ') || DELIMITERS.any? do |delimiter|
               content_without_delimiter_pairs.include?(delimiter)

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -270,7 +270,7 @@ module RuboCop
         end
 
         def allow_if_method_has_argument?(send_node)
-          !!cop_config.fetch('AllowMethodsWithArguments', false) && !send_node.arguments.count.zero?
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && send_node.arguments.any?
         end
 
         def allow_comments?