rubocop 1.71.1 → 1.88.2

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for blocks with one argument where `it` block parameter can be used.
+      #
+      # It provides four `EnforcedStyle` options:
+      #
+      # 1. `allow_single_line` (default) ... Always uses the `it` block parameter in a single line.
+      # 2. `only_numbered_parameters` ... Detects only numbered block parameters.
+      # 3. `always` ... Always uses the `it` block parameter.
+      # 4. `disallow` ... Disallows the `it` block parameter.
+      #
+      # A single numbered parameter is detected when `allow_single_line`,
+      # `only_numbered_parameters`, or `always`.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   block do
+      #     do_something(it)
+      #   end
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: only_numbered_parameters
+      #   # bad
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: always
+      #   # bad
+      #   block { do_something(_1) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   block { do_something(it) }
+      #
+      #   # good
+      #   block { do_something(_1) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      class ItBlockParameter < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        MSG_USE_IT_PARAMETER = 'Use `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
+
+        minimum_target_ruby_version 3.4
+
+        def on_block(node)
+          return unless style == :always
+          return unless node.arguments.one?
+
+          # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
+          return unless node.first_argument.arg_type?
+
+          variables = find_block_variables(node, node.first_argument.source)
+
+          variables.each do |variable|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
+              corrector.remove(node.arguments)
+              corrector.replace(variable, 'it')
+            end
+          end
+        end
+
+        def on_numblock(node)
+          return if style == :disallow
+          return unless node.children[1] == 1
+
+          variables = find_block_variables(node, '_1')
+
+          variables.each do |variable|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
+              corrector.replace(variable, 'it')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          case style
+          when :allow_single_line
+            return if node.single_line?
+
+            add_offense(node, message: MSG_AVOID_IT_PARAMETER_MULTILINE)
+          when :disallow
+            variables = find_block_variables(node, 'it')
+
+            variables.each do |variable|
+              add_offense(variable, message: MSG_AVOID_IT_PARAMETER)
+            end
+          end
+        end
+
+        private
+
+        def find_block_variables(node, block_argument_name)
+          return [] unless node.body
+
+          node.body.each_descendant(:lvar).select do |descendant|
+            descendant.source == block_argument_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -37,6 +37,10 @@ module RuboCop
           return unless (ancestor = node.parent&.parent)
 
           merge_kwargs?(ancestor) do |merge_node, hash_node, other_hash_node|
+            # A block-pass argument (e.g. `merge(other, &block)`) has no keyword
+            # equivalent, so spreading it would produce invalid Ruby (`**&block`).
+            next if other_hash_node.any?(&:block_pass_type?)
+
             add_offense(merge_node) do |corrector|
               autocorrect(corrector, node, hash_node, other_hash_node)
             end

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

@@ -42,25 +42,35 @@ module RuboCop
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
-            if node.parent.find(&:kwoptarg_type?) == node
-              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+            defining_node = node.each_ancestor(:any_def, :block).first
+            next if processed_source.contains_comment?(arguments_range(defining_node))
+            next unless node.parent.find(&:kwoptarg_type?) == node
 
-              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
-              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
-
-              remove_kwargs(kwarg_nodes, corrector)
-            end
+            autocorrect(corrector, node, defining_node, kwarg_nodes)
           end
         end
 
         private
 
+        def autocorrect(corrector, node, defining_node, kwarg_nodes)
+          corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+          arguments = defining_node.arguments
+          append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
+          remove_kwargs(kwarg_nodes, corrector)
+        end
+
         def append_newline_to_last_kwoptarg(arguments, corrector)
-          last_argument = arguments.last
-          return if last_argument.type?(:kwrestarg, :blockarg)
+          # The newline only needs restoring when the moved keyword argument was
+          # the last parameter, so removing it also consumes the line break before
+          # the body. When a `kwoptarg` already trails the list, the body stays
+          # separated and inserting a newline would leave a spurious blank line.
+          return unless arguments.last.kwarg_type?
+          return if arguments.parent.block_type?
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
-          corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?
+          corrector.insert_after(last_kwoptarg, "\n")
         end
 
         def remove_kwargs(kwarg_nodes, corrector)

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

@@ -77,6 +77,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -117,7 +118,13 @@ module RuboCop
         end
 
         def lambda_arg_string(args)
-          args.children.map(&:source).join(', ')
+          # Block-local (shadow) arguments are separated from regular arguments by a
+          # `;`; joining everything with `,` would turn them into extra parameters
+          # and change the lambda's arity.
+          regular, shadow = args.children.partition { |arg| !arg.shadowarg_type? }
+          arg_string = regular.map(&:source).join(', ')
+          arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+          arg_string
         end
       end
     end

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

@@ -6,18 +6,18 @@ module RuboCop
       # Checks for use of the lambda.(args) syntax.
       #
       # @example EnforcedStyle: call (default)
-      #  # bad
-      #  lambda.(x, y)
+      #   # bad
+      #   lambda.(x, y)
       #
-      #  # good
-      #  lambda.call(x, y)
+      #   # good
+      #   lambda.call(x, y)
       #
       # @example EnforcedStyle: braces
-      #  # bad
-      #  lambda.call(x, y)
+      #   # bad
+      #   lambda.call(x, y)
       #
-      #  # good
-      #  lambda.(x, y)
+      #   # good
+      #   lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
@@ -27,6 +27,9 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          # Rewriting the call rebuilds it as a single expression, which would drop
+          # any comments inside the argument list, so leave it to be fixed manually.
+          return if comments_in_node?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -48,15 +51,28 @@ module RuboCop
 
         private
 
+        def comments_in_node?(node)
+          range = node.source_range
+          processed_source.comments.any? do |comment|
+            range.begin_pos <= comment.source_range.begin_pos &&
+              comment.source_range.end_pos <= range.end_pos
+          end
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
         def prefer(node)
           receiver = node.receiver.source
-          arguments = node.arguments.map(&:source).join(', ')
           dot = node.loc.dot.source
-          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+          call_arguments = if node.arguments.empty?
+                             ''
+                           else
+                             arguments = node.arguments.map(&:source).join(', ')
+                             "(#{arguments})"
+                           end
+          method = explicit_style? ? "call#{call_arguments}" : "(#{arguments})"
 
           "#{receiver}#{dot}#{method}"
         end

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

@@ -36,7 +36,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        MSG = 'Use `\\` instead of `%<operator>s` to concatenate multiline strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
@@ -61,14 +61,20 @@ module RuboCop
           successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
-
           return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
-
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
+          register_offense(operator)
+        end
+
+        def register_offense(operator)
+          message = format(MSG, operator: operator.text)
+
+          add_offense(operator.pos, message: message) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
         end
 
         def autocorrect(corrector, operator_range)

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

@@ -10,7 +10,7 @@ module RuboCop
       # Required capitalization can be set with the `DirectiveCapitalization` and
       # `ValueCapitalization` configuration keys.
       #
-      # NOTE: If one of these configuration is set to nil, any capitalization is allowed.
+      # NOTE: If one of these configurations is set to nil, any capitalization is allowed.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # The `snake_case` style will enforce that the frozen string literal
@@ -176,7 +176,7 @@ module RuboCop
           if first_non_comment_token
             0...first_non_comment_token.line
           else
-            (0..)
+            0..
           end
         end
 
@@ -299,7 +299,7 @@ module RuboCop
         end
 
         def supported_capitalizations
-          cop_config['SupportedCapitalizations'].map(&:to_sym)
+          @supported_capitalizations ||= cop_config['SupportedCapitalizations'].map(&:to_sym).freeze
         end
       end
     end

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

@@ -6,6 +6,17 @@ module RuboCop
       # Prefer `select` or `reject` over `map { ... }.compact`.
       # This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
       #
+      # @safety
+      #   This cop is unsafe because `compact` also removes `nil` elements that
+      #   were already present in the receiver, whereas `select`/`reject` keep
+      #   them. The result therefore differs when the collection contains `nil`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil, 1].map { |e| e if e }.compact # => [1]
+      #   [nil, 1].select { |e| e }           # => [nil, 1]
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -65,7 +65,7 @@ module RuboCop
 
         # @!method suitable_argument_node?(node)
         def_node_matcher :suitable_argument_node?, <<-PATTERN
-          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) block-pass}
         PATTERN
 
         # @!method each_block_with_push?(node)
@@ -127,6 +127,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -211,9 +212,11 @@ module RuboCop
         end
 
         def correct_push_node(corrector, push_node)
+          arg_node = push_node.first_argument
           range = push_node.source_range
-          arg_range = push_node.first_argument.source_range
+          arg_range = arg_node.source_range
 
+          corrector.wrap(arg_node, '{ ', ' }') if arg_node.hash_type? && !arg_node.braces?
           corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
           corrector.remove(range_between(arg_range.end_pos, range.end_pos))
         end

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
@@ -73,6 +76,12 @@ 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

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

@@ -49,7 +49,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 +108,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 +117,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) ||
@@ -153,7 +153,7 @@ module RuboCop
           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 +167,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 +222,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,7 +249,7 @@ 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

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