rubocop 1.71.1 → 1.91.0

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

@@ -45,18 +45,21 @@ module RuboCop
           }
         PATTERN
 
+        # @!method destructuring_argument(node)
+        def_node_matcher :destructuring_argument, <<~PATTERN
+          (args $(mlhs (arg _)+))
+        PATTERN
+
         def self.autocorrect_incompatible_with
           [Layout::SingleLineBlockChain]
         end
 
         def on_send(node)
           return unless (to_h_node, map_node = map_to_h(node))
+          return if to_h_node.block_literal?
 
           message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
-            # If the `to_h` call already has a block, do not autocorrect.
-            next if to_h_node.block_literal?
-
             autocorrect(corrector, to_h_node, map_node)
           end
         end
@@ -64,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)
 
@@ -73,8 +76,13 @@ module RuboCop
             corrector.replace(map_dot, to_h.loc.dot.source)
           end
           corrector.replace(map.loc.selector, 'to_h')
+
+          return unless map.parent.block_type?
+
+          if (argument = destructuring_argument(map.parent.arguments))
+            corrector.replace(argument, argument.source[1..-2])
+          end
         end
-        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -40,12 +40,10 @@ module RuboCop
 
         def on_send(node)
           return unless (to_set_node, map_node = map_to_set?(node))
+          return if to_set_node.block_literal?
 
           message = format(MSG, method: map_node.loc.selector.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
-            # If the `to_set` call already has a block, do not autocorrect.
-            next if to_set_node.block_literal?
-
             autocorrect(corrector, to_set_node, map_node)
           end
         end

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

@@ -5,14 +5,29 @@ 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
@@ -26,9 +41,11 @@ module RuboCop
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(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)
@@ -49,7 +66,7 @@ module RuboCop
 
           def inside_endless_method_def?(node)
             # parens are required around arguments inside an endless method
-            node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
+            node.each_ancestor(:any_def).any?(&:endless?) && node.arguments.any?
           end
 
           def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -108,7 +125,7 @@ module RuboCop
           end
 
           def call_in_literals?(node)
-            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
             parent.type?(:pair, :array, :range) ||
@@ -117,7 +134,7 @@ module RuboCop
           end
 
           def call_in_logical_operators?(node)
-            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
             logical_operator?(parent) ||
@@ -133,7 +150,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,14 +163,13 @@ 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?
           end
 
           def call_in_argument_with_block?(node)
-            parent = node.parent&.block_type? && node.parent.parent
+            parent = node.parent&.any_block_type? && node.parent.parent
             return false unless parent
 
             parent.type?(:call, :super, :yield)
@@ -167,7 +183,7 @@ module RuboCop
           def call_in_match_pattern?(node)
             return false unless (parent = node.parent)
 
-            parent.type?(:match_pattern, :match_pattern_p)
+            parent.any_match_pattern_type?
           end
 
           def hash_literal_in_arguments?(node)
@@ -222,8 +238,9 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent.unary_operation?)
+            return true if node.numeric_type? && node.sign?
+
+            node.parent&.send_type? && node.parent.unary_operation?
           end
 
           def assigned_before?(node, target)
@@ -248,10 +265,9 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return true if last_argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.first&.forwarded_kwrestarg_type?
+            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
           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.
@@ -132,6 +135,32 @@ module RuboCop
       #     bar :baz
       #   end
       #
+      # @example AllowedMethods: ["puts", "print"]
+      #
+      #   # good
+      #   puts "Hello world"
+      #   print "Hello world"
+      #   # still enforces parentheses on other methods
+      #   array.delete(e)
+      #
+      # @example AllowedPatterns: ["^assert"]
+      #
+      #   # good
+      #   assert_equal 'test', x
+      #   assert_match(/foo/, bar)
+      #   # 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
@@ -213,7 +242,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier]
+          [Style::NestedParenthesizedCalls, Style::RescueModifier, Style::TrailingCommaInArguments]
         end
 
         def on_send(node)

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
@@ -44,15 +44,16 @@ module RuboCop
 
           register_offense(node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private
 
         def register_offense(node)
-          add_offense(offense_range(node)) do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+          range = offense_range(node)
+          return if processed_source.contains_comment?(range)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 
@@ -88,8 +89,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_called_on_do_end_block.rb

@@ -36,12 +36,13 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return if ignored_node?(node)
 
           return unless (receiver = node.receiver)
-          return unless receiver.any_block_type? && receiver.loc.end.is?('end')
+          return unless receiver.any_block_type? && receiver.keywords?
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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
@@ -168,7 +170,7 @@ 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)
 

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]
       # ----
@@ -39,16 +39,27 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Use `%<prefer>s` instead.'
-        GRATER_OPERATORS = %i[> >=].freeze
+        GREATER_OPERATORS = %i[> >=].freeze
         LESS_OPERATORS = %i[< <=].freeze
-        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+        COMPARISON_OPERATORS = (GREATER_OPERATORS + LESS_OPERATORS).to_set.freeze
+
+        # @!method comparison_condition(node, name)
+        def_node_matcher :comparison_condition, <<~PATTERN
+          {
+            (send $_lhs $COMPARISON_OPERATORS $_rhs)
+            (begin (send $_lhs $COMPARISON_OPERATORS $_rhs))
+          }
+        PATTERN
 
         def on_if(node)
-          lhs, operator, rhs = *node.condition
-          return unless COMPARISON_OPERATORS.include?(operator)
+          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
 
@@ -63,7 +74,7 @@ module RuboCop
 
         def preferred_method(operator, lhs, rhs, if_branch, else_branch)
           if lhs == if_branch && rhs == else_branch
-            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+            GREATER_OPERATORS.include?(operator) ? 'max' : 'min'
           elsif lhs == else_branch && rhs == if_branch
             LESS_OPERATORS.include?(operator) ? 'max' : 'min'
           end

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

@@ -28,6 +28,11 @@ module RuboCop
       # delegator.upcase # => FOO
       # ----
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, `respond_to_missing?` defined in another definition of the
+      # same class or module (e.g. a reopening in another file) also
+      # satisfies the check.
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
@@ -52,11 +57,14 @@ module RuboCop
       #   end
       #
       class MissingRespondToMissing < Base
+        include ProjectIndexHelp
+
         MSG = 'When using `method_missing`, define `respond_to_missing?`.'
 
         def on_def(node)
           return unless node.method?(:method_missing)
           return if implements_respond_to_missing?(node)
+          return if respond_to_missing_elsewhere?(node)
 
           add_offense(node)
         end
@@ -64,17 +72,42 @@ module RuboCop
 
         private
 
-        def implements_respond_to_missing?(node)
-          return false unless (grand_parent = node.parent.parent)
+        # When `AllCops/UseProjectIndex` is enabled, `respond_to_missing?`
+        # defined in another definition of the same class or module (e.g. a
+        # reopening in another file) also satisfies the check. Ancestors are
+        # not consulted: overriding `method_missing` warrants a matching
+        # `respond_to_missing?` for the same class.
+        def respond_to_missing_elsewhere?(node)
+          return false unless project_index
+          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          scope = singleton_definition?(node) ? indexed_singleton_of(declaration) : declaration
+          !scope&.member('respond_to_missing?()').nil?
+        rescue StandardError
+          false
+        end
+
+        def singleton_definition?(node)
+          node.defs_type? || node.each_ancestor(:sclass, :class, :module).first&.sclass_type?
+        end
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
+        def implements_respond_to_missing?(node)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
 
-            child = descendant.children.first
-            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          search_root.each_descendant(node.type).any? do |descendant|
+            descendant.method?(:respond_to_missing?) && enclosing_scope(descendant).equal?(scope)
           end
+        end
 
-          false
+        # The class/module/`class << self` body that lexically contains `node`,
+        # or `nil` when `node` is defined at the top level.
+        def enclosing_scope(node)
+          node.each_ancestor(:class, :module, :sclass).first
         end
       end
     end

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
-            const)
+            const+)
         PATTERN
 
         # @!method in_top_level_scope?(node)

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

@@ -110,9 +110,11 @@ module RuboCop
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          return unless node.body&.begin_type?
+          return unless node.body
 
-          each_wrong_style(node.body.children) do |child_node|
+          body_nodes = node.body.begin_type? ? node.body.children : [node.body]
+
+          each_wrong_style(body_nodes) do |child_node|
             add_offense(child_node) do |corrector|
               next if style == :forbidden