rubocop 1.81.7 → 1.92.1

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `map { |x| x.to_s }.join` and similar calls where the
+      # `map` is redundant because `Array#join` implicitly calls `#to_s` on
+      # each element.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot guarantee that the receiver
+      #   is an `Array` by static analysis. If the receiver does not have
+      #   an `Array#join`-compatible implementation (i.e. one that calls
+      #   `#to_s` on elements), the correction may change behavior.
+      #
+      # @example
+      #   # bad
+      #   array.map(&:to_s).join(', ')
+      #
+      #   # bad
+      #   array.map { |x| x.to_s }.join(', ')
+      #
+      #   # bad
+      #   array.collect(&:to_s).join
+      #
+      #   # good
+      #   array.join(', ')
+      #
+      #   # good
+      #   array.join
+      #
+      class MapJoin < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Remove redundant `%<method>s(&:to_s)` before `join`.'
+        RESTRICT_ON_SEND = %i[join].freeze
+
+        # map(&:to_s).join(...)
+        # @!method map_to_s_join?(node)
+        def_node_matcher :map_to_s_join?, <<~PATTERN
+          (call
+            $(call _ ${:map :collect} (block_pass (sym :to_s)))
+            :join ...)
+        PATTERN
+
+        # map { |x| x.to_s }.join(...)
+        # @!method map_to_s_block_join?(node)
+        def_node_matcher :map_to_s_block_join?, <<~PATTERN
+          (call
+            $(block
+              (call _ ${:map :collect})
+              (args (arg _x))
+              (send (lvar _x) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { _1.to_s }.join(...)
+        # @!method map_to_s_numblock_join?(node)
+        def_node_matcher :map_to_s_numblock_join?, <<~PATTERN
+          (call
+            $(numblock
+              (call _ ${:map :collect})
+              1
+              (send (lvar :_1) :to_s))
+            :join ...)
+        PATTERN
+
+        # map { it.to_s }.join(...)
+        # @!method map_to_s_itblock_join?(node)
+        def_node_matcher :map_to_s_itblock_join?, <<~PATTERN
+          (call
+            $(itblock
+              (call _ ${:map :collect})
+              :it
+              (send (lvar :it) :to_s))
+            :join ...)
+        PATTERN
+
+        def on_send(node)
+          map_to_s_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_block_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_numblock_join?(node) { |m, n| register_offense(node, m, n) } ||
+            map_to_s_itblock_join?(node) { |m, n| register_offense(node, m, n) }
+        end
+        alias on_csend on_send
+
+        private
+
+        def register_offense(join_node, map_node, method_name)
+          map_send = map_node.any_block_type? ? map_node.send_node : map_node
+          message = format(MSG, method: method_name)
+
+          add_offense(map_send.loc.selector, message: message) do |corrector|
+            remove_map_call(corrector, join_node, map_node, map_send)
+          end
+        end
+
+        def remove_map_call(corrector, join_node, map_node, map_send)
+          receiver = map_send.receiver
+          if receiver
+            corrector.replace(removal_range(receiver, map_node, map_send), '')
+          else
+            corrector.replace(no_receiver_range(map_node, join_node), '')
+          end
+        end
+
+        def removal_range(receiver, map_node, map_send)
+          start_pos = if receiver.last_line < map_send.loc.dot.line
+                        receiver.source_range.end_pos
+                      else
+                        map_send.loc.dot.begin_pos
+                      end
+          range_between(start_pos, map_node.source_range.end_pos)
+        end
+
+        def no_receiver_range(map_node, join_node)
+          range_between(map_node.source_range.begin_pos, join_node.loc.dot.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -67,7 +67,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
@@ -83,7 +83,6 @@ module RuboCop
             corrector.replace(argument, argument.source[1..-2])
           end
         end
-        # rubocop:enable Metrics/AbcSize
       end
     end
   end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -5,17 +5,32 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
-        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
           include RangeHelp
+          include ReparsedEquivalence
 
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
 
+          def on_investigation_end
+            # Each candidate's exact correction is verified by reparsing before
+            # the offense is registered, so an omission that would change how
+            # the code parses is never reported or offered.
+            verified_by_reparse(@pending_omit_offenses || []).each do |node|
+              add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            @pending_omit_offenses = []
+
+            super
+          end
+
           private
 
-          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
+          def omit_parentheses(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
@@ -25,10 +40,15 @@ module RuboCop
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
+            return if code_after_closing_parenthesis_on_its_own_line?(node)
+            return if comment_before_first_argument?(node)
+            return if args_parenthesized?(node)
 
-            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              autocorrect(corrector, node)
-            end
+            (@pending_omit_offenses ||= []) << node
+          end
+
+          def apply_reparse_correction(corrector, node)
+            autocorrect(corrector, node)
           end
 
           def autocorrect(corrector, node)
@@ -87,14 +107,33 @@ module RuboCop
               inside_string_interpolation?(node)
           end
 
+          def code_after_closing_parenthesis_on_its_own_line?(node)
+            closing = node.loc.end
+            return false if node.arguments.none? || node.last_argument.last_line == closing.line
+
+            rest = closing.source_line[(closing.column + 1)..].strip
+
+            !rest.empty? && !rest.start_with?('#')
+          end
+
+          # Without the parentheses, a comment before the first argument would end the call there,
+          # and a line continuation can't carry the call past a comment.
+          def comment_before_first_argument?(node)
+            return false unless (first_argument = node.first_argument)
+
+            lines = node.loc.begin.line...first_argument.first_line
+            processed_source.each_comment_in_lines(lines).any?
+          end
+
           def parentheses_at_the_end_of_multiline_call?(node)
-            node.multiline? &&
-              node.loc.begin.source_line
-                  .gsub(TRAILING_WHITESPACE_REGEX, '')
-                  .end_with?('(')
+            return false unless node.multiline?
+
+            opening = node.loc.begin
+
+            opening.source_line[(opening.column + 1)..].gsub(TRAILING_WHITESPACE_REGEX, '').empty?
           end
 
-          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
@@ -104,7 +143,9 @@ module RuboCop
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node) ||
               assignment_in_condition?(node) ||
-              forwards_anonymous_rest_arguments?(node)
+              command_assignment_in_expression?(node) ||
+              forwards_anonymous_rest_arguments?(node) ||
+              trailing_comma?(node)
           end
 
           def call_in_literals?(node)
@@ -120,9 +161,13 @@ module RuboCop
             parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
-            logical_operator?(parent) ||
-              (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+            if logical_operator?(parent) || command_assignment_before_keyword_operator?(parent)
+              return true
+            end
+
+            parent.send_type? && parent.arguments.any? do |argument|
+              logical_operator?(argument)
+            end
           end
 
           def call_in_optional_arguments?(node)
@@ -133,7 +178,7 @@ module RuboCop
             node.parent&.class_type? && node.parent.single_line?
           end
 
-          # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable-next Metrics/PerceivedComplexity
           def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_in_argument_with_block?(node) ||
@@ -146,7 +191,6 @@ module RuboCop
                   ambiguous_literal?(n) || logical_operator?(n)
               end
           end
-          # rubocop:enable Metrics/PerceivedComplexity
 
           def call_with_braced_block?(node)
             node.type?(:call, :super) && node.block_node&.braces?
@@ -213,6 +257,15 @@ module RuboCop
             node.operator_keyword? && node.logical_operator?
           end
 
+          def command_assignment_before_keyword_operator?(node)
+            return false unless node.assignment?
+
+            node = node.parent while node.parent&.assignment?
+            return false unless (operator = node.parent)
+
+            operator.operator_keyword? && operator.semantic_operator?
+          end
+
           def hash_literal?(node)
             node.hash_type? && node.braces?
           end
@@ -228,7 +281,7 @@ module RuboCop
           end
 
           def assigned_before?(node, target)
-            node.assignment? && node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.source_range.begin
           end
 
           def inside_string_interpolation?(node)
@@ -245,14 +298,43 @@ module RuboCop
             parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
           end
 
+          # rubocop:disable-next Metrics/PerceivedComplexity
+          def command_assignment_in_expression?(node)
+            value = node.parent&.type?(:any_block, :rescue) ? node.parent : node
+            assignment = outermost_assignment(value)
+            return false if assignment.equal?(value)
+
+            call_in_literals?(assignment) ||
+              call_in_logical_operators?(assignment) ||
+              call_in_optional_arguments?(assignment) ||
+              call_as_argument_or_chain?(assignment) ||
+              assignment.parent&.type?(:masgn, :return, :next, :break, :defined?)
+          end
+
+          def outermost_assignment(value)
+            parent = value.parent
+            return value if !parent&.assignment? || parent.masgn_type?
+            return value unless assigned_before?(parent, value)
+
+            outermost_assignment(parent)
+          end
+
           def forwards_anonymous_rest_arguments?(node)
+            node.arguments.any? do |argument|
+              next true if argument.forwarded_restarg_type?
+
+              argument.hash_type? && argument.children.any?(&:forwarded_kwrestarg_type?)
+            end
+          end
+
+          def trailing_comma?(node)
             return false unless (last_argument = node.last_argument)
-            return true if last_argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
+            range = last_argument.source_range.end.join(node.loc.end.begin)
+
+            processed_source.tokens_within(range).any?(&:comma?)
           end
         end
-        # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end
     end
   end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -33,13 +33,26 @@ module RuboCop
           end
 
           def included_macros_list
-            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+            @included_macros_list ||= cop_config.fetch('IncludedMacros', []).map(&:to_sym).freeze
+          end
+
+          def included_macro_patterns
+            @included_macro_patterns ||=
+              cop_config.fetch('IncludedMacroPatterns', [])
+                        .map { |pattern| Regexp.new(pattern) }.freeze
+          end
+
+          def matches_included_macro_pattern?(method_name)
+            included_macro_patterns.any? do |pattern|
+              pattern.match?(method_name.to_s)
+            end
           end
 
           def ignored_macro?(node)
             cop_config['IgnoreMacros'] &&
               node.macro? &&
-              !included_macros_list.include?(node.method_name)
+              !included_macros_list.include?(node.method_name) &&
+              !matches_included_macro_pattern?(node.method_name)
           end
         end
       end

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

@@ -9,17 +9,20 @@ module RuboCop
       # In the default style (require_parentheses), macro methods are allowed.
       # Additional methods can be added to the `AllowedMethods` or
       # `AllowedPatterns` list. These options are valid only in the default
-      # style. Macros can be included by either setting `IgnoreMacros` to false
-      # or adding specific macros to the `IncludedMacros` list.
+      # style. Macros can be included by either setting `IgnoreMacros` to false,
+      # adding specific macros to the `IncludedMacros` list, or using
+      # `IncludedMacroPatterns` for pattern-based matching.
       #
       # Precedence of options is as follows:
       #
       # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
+      # 4. `IncludedMacroPatterns`
       #
-      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
-      # then the latter takes precedence (that is, the method is allowed).
+      # If a method is listed in both `IncludedMacros`/`IncludedMacroPatterns`
+      # and `AllowedMethods`, then the latter takes precedence (that is, the
+      # method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -148,6 +151,16 @@ module RuboCop
       #   # still enforces parentheses on other methods
       #   array.delete(e)
       #
+      # @example IncludedMacroPatterns: ["^assert", "^refute"]
+      #
+      #   # bad
+      #   assert_equal 'test', x
+      #   refute_nil value
+      #
+      #   # good
+      #   assert_equal('test', x)
+      #   refute_nil(value)
+      #
       # @example AllowParenthesesInMultilineCall: false (default)
       #
       #   # bad
@@ -229,7 +242,13 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+          [
+            Style::NestedParenthesizedCalls,
+            Style::RedundantParentheses,
+            Style::RescueModifier,
+            Style::TernaryParentheses,
+            Style::TrailingCommaInArguments
+          ]
         end
 
         def on_send(node)
@@ -256,7 +275,24 @@ module RuboCop
           return false unless node.arguments.one?
 
           first_node = node.first_argument
-          first_node.begin_type? && first_node.parenthesized_call?
+          return false unless first_node.begin_type? && first_node.parenthesized_call?
+
+          first_node.children.one? && mergeable_parentheses?(first_node.children.first)
+        end
+
+        def mergeable_parentheses?(node)
+          case node.type
+          when :and, :or
+            !node.semantic_operator?
+          when :if, :while, :until
+            !node.modifier_form?
+          when :send
+            !node.keyword?
+          when :rescue, :masgn, :match_pattern, :match_pattern_p
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -29,11 +29,17 @@ module RuboCop
       class MethodCallWithoutArgsParentheses < Base
         include AllowedMethods
         include AllowedPattern
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_new_investigation
+          @pending_ranges = []
+          super
+        end
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
@@ -44,16 +50,34 @@ module RuboCop
 
           register_offense(node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
+        # The parentheses are significant when removing them changes how the
+        # code parses, e.g. when a local variable with the same name is in
+        # scope (`foo = 1; foo()`) or an operator follows (`foo() -1`). The
+        # candidates are verified together, since outside a method definition
+        # each one would otherwise reparse the whole file.
+        def on_investigation_end
+          verified_by_reparse(@pending_ranges).each do |range|
+            add_offense(range) do |corrector|
+              apply_reparse_correction(corrector, range)
+            end
+          end
+
+          super
+        end
+
         private
 
         def register_offense(node)
-          add_offense(offense_range(node)) do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
-          end
+          range = offense_range(node)
+          return if processed_source.contains_comment?(range)
+
+          @pending_ranges << range
+        end
+
+        def apply_reparse_correction(corrector, range)
+          corrector.remove(range)
         end
 
         def ineligible_node?(node)
@@ -88,8 +112,12 @@ module RuboCop
         #
         def parenthesized_it_method_in_block?(node)
           return false unless node.method?(:it)
-          return false unless (block_node = node.each_ancestor(:block).first)
-          return false unless block_node.arguments.empty_and_without_delimiters?
+          return false unless (block_node = node.each_ancestor(:any_block).first)
+          # Inside a numbered/`it` block, a bare `it` is a parse error (it conflicts
+          # with the implicit parameter), so `it()` must keep its parentheses.
+          if block_node.block_type? && !block_node.arguments.empty_and_without_delimiters?
+            return false
+          end
 
           !node.receiver && node.arguments.empty? && !node.block_literal?
         end

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

@@ -102,9 +102,11 @@ module RuboCop
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
-        def on_def(node)
-          return if forced_parentheses?(node)
+        def self.autocorrect_incompatible_with
+          [Style::ArgumentsForwarding]
+        end
 
+        def on_def(node)
           args = node.arguments
 
           if require_parentheses?(args)
@@ -113,10 +115,10 @@ module RuboCop
             else
               correct_style_detected
             end
+          elsif forced_parentheses?(node)
+            correct_style_detected
           elsif parentheses?(args)
             unwanted_parentheses(args)
-          else
-            correct_style_detected
           end
         end
         alias on_defs on_def
@@ -125,7 +127,19 @@ module RuboCop
 
         def correct_arguments(arg_node, corrector)
           corrector.replace(arg_node.loc.begin, ' ')
-          corrector.remove(arg_node.loc.end)
+
+          if code_after_arguments?(arg_node)
+            corrector.replace(arg_node.loc.end, ';')
+          else
+            corrector.remove(arg_node.loc.end)
+          end
+        end
+
+        def code_after_arguments?(arg_node)
+          closing = arg_node.loc.end
+          rest = closing.source_line[(closing.column + 1)..].strip
+
+          !rest.empty? && !rest.start_with?(';', '#')
         end
 
         def forced_parentheses?(node)
@@ -135,8 +149,11 @@ module RuboCop
           # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
           # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
           # 5. Argument lists containing an anonymous block forwarding (`&`)
-          # Removing the parens would be a syntax error here.
-          node.endless? || anonymous_arguments?(node)
+          # 6. Argument lists that begin on a line below the method name
+          # 7. Argument lists that begin with a destructuring parameter (`(a, b)`)
+          # Removing the parens would be a syntax error, or a change of the parameters, here.
+          node.endless? || anonymous_arguments?(node) || arguments_on_own_line?(node) ||
+            destructuring_first_argument?(node)
         end
 
         def require_parentheses?(args)
@@ -168,12 +185,23 @@ module RuboCop
 
         def anonymous_arguments?(node)
           return true if node.arguments.any? do |arg|
-            arg.type?(:forward_arg, :restarg, :kwrestarg)
+            arg.forward_arg_type? || (arg.type?(:restarg, :kwrestarg) && arg.name.nil?)
           end
           return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end
+
+        def arguments_on_own_line?(node)
+          return false unless (first_argument = node.first_argument)
+          return false unless parentheses?(node.arguments)
+
+          node.arguments.loc.begin.line != first_argument.first_line
+        end
+
+        def destructuring_first_argument?(node)
+          node.first_argument&.mlhs_type?
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Enforces the use of `max` or `min` instead of comparison for greater or less.
       #
       # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
-      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      # It is slow though. So autocorrection will apply generic `max` or `min`:
       #
       # [source,ruby]
       # ----
@@ -55,8 +55,11 @@ module RuboCop
           lhs, operator, rhs = comparison_condition(node.condition)
           return unless operator
 
+          # For `unless`, the branches run opposite to an `if`, so swap them to
+          # keep the `max`/`min` decision correct.
           if_branch = node.if_branch
           else_branch = node.else_branch
+          if_branch, else_branch = else_branch, if_branch if node.unless?
           preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
           return unless preferred_method
 

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

@@ -125,13 +125,19 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
+          return if node.else? || guard_clause_cop_conflict?(node)
 
           add_offense(node, message: format(message_template, type: node.type)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
+        def guard_clause_cop_conflict?(node)
+          return false unless node.if_type? && @config.cop_enabled?('Style/GuardClause')
+
+          [node.if_branch, node.else_branch].compact.any?(&:guard_clause?)
+        end
+
         def message_template
           case empty_else_style
           when :empty