rubocop 1.87.0 → 1.88.2

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

@@ -121,16 +121,24 @@ module RuboCop
         end
 
         def multi_argument(node)
+          # A splat argument can expand to any number of elements, so the pairs
+          # can't be built statically and there is no literal hash to suggest.
+          return if node.arguments.any?(&:splat_type?)
+
           if node.arguments.count.odd?
             add_offense(node, message: MSG_LITERAL_MULTI_ARG)
           else
-            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
-              corrector.replace(node, args_to_hash(node.arguments))
+            correct_multi_argument(node)
+          end
+        end
 
-              parent = node.parent
-              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-                add_parentheses(parent, corrector)
-              end
+        def correct_multi_argument(node)
+          add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+            corrector.replace(node, args_to_hash(node.arguments))
+
+            parent = node.parent
+            if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+              add_parentheses(parent, corrector)
             end
           end
         end

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

@@ -74,7 +74,7 @@ module RuboCop
 
         def offense_for_brackets?(node)
           style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
-            !node.block_literal?
+            !node.block_literal? && !node.csend_type?
         end
 
         def offense_for_fetch?(node)
@@ -84,11 +84,7 @@ module RuboCop
         def correct_fetch_to_brackets(corrector, node)
           key = node.first_argument.source
 
-          if node.csend_type?
-            corrector.replace(node, "(#{node.receiver.source}[#{key}])")
-          else
-            corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
-          end
+          corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
         end
 
         def correct_brackets_to_fetch(corrector, node)

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

@@ -19,6 +19,22 @@ module RuboCop
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is a `Hash` or responds to the replacement method.
       #
+      #   Additionally, the replacement may change the order of the resulting
+      #   hash: `Hash#slice` returns entries in the order the keys are given,
+      #   whereas `select`, `filter`, and `reject` preserve the entry order of
+      #   the receiver.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   hash = {foo: 1, bar: 2, baz: 3}
+      #   keys = %i[baz foo]
+      #
+      #   hash.select { |k, _v| keys.include?(k) } # => {foo: 1, baz: 3}
+      #   hash.slice(*keys)                        # => {baz: 3, foo: 1}
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -263,6 +263,8 @@ module RuboCop
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
+          # This runs once per pair, but the hash must only be wrapped once.
+          return unless pair_node.equal?(hash_node.pairs.first)
 
           corrector.wrap(hash_node, '{', '}')
         end

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

@@ -216,23 +216,34 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def correct_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node.parent)
+
           if insert_position == :after_condition
             assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
             corrector.remove(assignment)
-            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{assignment.source}#{expression.source}")
           else
-            corrector.insert_before(node.parent, "#{expression.source}\n")
+            corrector.insert_before(node.parent, "#{expression.source}\n#{indentation}")
           end
         end
 
         def correct_no_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node)
+
           if insert_position == :after_condition
-            corrector.insert_after(node, "\n#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{expression.source}")
           else
-            corrector.insert_before(node, "#{expression.source}\n")
+            corrector.insert_before(node, "#{expression.source}\n#{indentation}")
           end
         end
 
+        # The leading indentation of the line the conditional starts on, so a
+        # hoisted expression keeps the surrounding nesting instead of landing
+        # at column zero.
+        def indentation_of(node)
+          ' ' * node.source_range.column
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)
 

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

@@ -86,12 +86,12 @@ module RuboCop
         MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
-          [Style::SoleNestedConditional]
+          [Style::Next, Style::SoleNestedConditional]
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
+          return if endless_method?(node.body) || node.each_ancestor(:dstr).any?
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -119,7 +119,7 @@ module RuboCop
           if condition.defined_type?
             [condition]
           else
-            condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant(:defined?)
           end
         end
 
@@ -137,7 +137,7 @@ module RuboCop
           if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select(&:any_match_pattern_type?)
+            condition.each_descendant(:any_match_pattern)
           end
         end
 
@@ -350,7 +350,7 @@ module RuboCop
         end
 
         def comment_on_node_line(node)
-          processed_source.comments.find { |c| same_line?(c, node) }
+          processed_source.comment_at_line(node.first_line)
         end
 
         def remove_comment(corrector, _node, comment)

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

@@ -82,7 +82,7 @@ module RuboCop
 
           then_code, else_code = else_code, then_code if node.unless?
 
-          "#{node.condition.source} ? #{then_code} : #{else_code}"
+          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)
@@ -103,6 +103,14 @@ module RuboCop
           "#{method.source}(#{arguments.source})"
         end
 
+        # An assignment used as the condition must be parenthesized, otherwise the
+        # assignment would capture the whole ternary (`a = b ? c : d` instead of
+        # `(a = b) ? c : d`), changing what gets assigned.
+        def ternary_condition(node)
+          condition = node.condition
+          condition.assignment? ? "(#{condition.source})" : condition.source
+        end
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}

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

@@ -26,7 +26,7 @@ module RuboCop
         def on_new_investigation
           processed_source.comments.each do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match?(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable|todo)/)
 
             add_offense(comment)
           end

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

@@ -75,7 +75,9 @@ module RuboCop
         def invertible?(node) # rubocop:disable Metrics/CyclomaticComplexity
           case node&.type
           when :begin
-            invertible?(node.children.first)
+            # A multi-statement `begin` evaluates to its last expression, so it
+            # cannot be inverted by negating a single child.
+            node.children.one? && invertible?(node.children.first)
           when :send
             return false if inheritance_check?(node)
 
@@ -124,12 +126,17 @@ module RuboCop
         end
 
         def preferred_logical_condition(node)
-          preferred_lhs = preferred_condition(node.lhs)
-          preferred_rhs = preferred_condition(node.rhs)
+          preferred_lhs = preferred_operand(node, node.lhs)
+          preferred_rhs = preferred_operand(node, node.rhs)
 
           "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
         end
 
+        def preferred_operand(node, operand)
+          preferred = preferred_condition(operand)
+          parenthesize_inverted_operand?(node, operand) ? "(#{preferred})" : preferred
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin
@@ -138,11 +145,24 @@ module RuboCop
             autocorrect_send_node(corrector, node)
           when :or, :and
             corrector.replace(node.loc.operator, node.inverse_operator)
-            autocorrect(corrector, node.lhs)
-            autocorrect(corrector, node.rhs)
+            autocorrect_operand(corrector, node, node.lhs)
+            autocorrect_operand(corrector, node, node.rhs)
           end
         end
 
+        def autocorrect_operand(corrector, node, operand)
+          autocorrect(corrector, operand)
+          corrector.wrap(operand, '(', ')') if parenthesize_inverted_operand?(node, operand)
+        end
+
+        # When an `and` is nested in an `or`, inverting both operators turns the
+        # `and` into an `or` that now binds looser than its parent, so it must be
+        # parenthesized to keep the original grouping (`a && b || c` inverts to
+        # `(!a || !b) && !c`, not `!a || !b && !c`).
+        def parenthesize_inverted_operand?(node, operand)
+          node.or_type? && operand.and_type?
+        end
+
         def autocorrect_send_node(corrector, node)
           if node.method?(:!)
             corrector.remove(node.loc.selector)

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

@@ -62,11 +62,15 @@ module RuboCop
         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

@@ -118,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

@@ -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,6 +51,14 @@ 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

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)

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

@@ -50,9 +50,11 @@ module RuboCop
         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 +90,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,6 +102,10 @@ module RuboCop
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
+        def self.autocorrect_incompatible_with
+          [Style::ArgumentsForwarding]
+        end
+
         def on_def(node)
           args = node.arguments
 
@@ -166,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

@@ -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_respond_to_missing.rb

@@ -65,16 +65,19 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          return false unless (grand_parent = node.parent.parent)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
-
-            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
 

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

@@ -36,7 +36,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          node.then? && node.loc.begin.line != node.if_branch&.loc&.line
+          node.multiline? && node.then? && node.loc.begin.line != node.if_branch&.loc&.line
         end
       end
     end

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

@@ -65,10 +65,16 @@ module RuboCop
           if style == :keyword
             rhs.begin_type?
           else
-            rhs.kwbegin_type?
+            # A `begin` block with `rescue`/`ensure` cannot be expressed with
+            # parentheses, so wrapping it in `(` and `)` is not possible.
+            rhs.kwbegin_type? && !contains_rescue_or_ensure?(rhs)
           end
         end
 
+        def contains_rescue_or_ensure?(node)
+          node.each_child_node(:rescue, :ensure).any?
+        end
+
         def keyword_autocorrect(node, corrector)
           node_buf = node.source_range.source_buffer
           corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))

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

@@ -51,10 +51,12 @@ module RuboCop
           end
 
           arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
-          # If the method name isn't on the same line as def, move it directly after def
+          # If the method name isn't on the same line as `def`, pull the name and
+          # the opening parenthesis up next to `def` so the collapsed signature
+          # stays on a single line and remains valid Ruby.
           if arguments_range.first_line != opening_line(node)
-            corrector.remove(node.loc.name)
-            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+            prefix_range = range_between(node.loc.keyword.end_pos, begin_of_arguments.begin_pos)
+            corrector.replace(prefix_range, " #{prefix_range.source.strip}")
           end
 
           corrector.remove(arguments_range)
@@ -85,7 +87,12 @@ module RuboCop
         end
 
         def definition_width(node)
-          node.source_range.begin.join(node.arguments.source_range.end).length
+          # Measure the collapsed single-line width the autocorrect would
+          # produce, not the multi-line source length, so a signature that
+          # would fit on one line is not skipped.
+          signature = node.source_range.begin.join(node.arguments.source_range.end).source
+
+          signature.gsub(/\s+/, ' ').length
         end
       end
     end