rubocop 1.81.7 → 1.92.1

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

@@ -17,9 +17,13 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
-        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
-        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `%<keyword>s %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
+        MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
+
+        LOWER_PRECEDENCE_THAN_TERNARY_TYPES = %i[
+          and or if rescue any_match_pattern while until while_post until_post
+        ].freeze
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
@@ -49,7 +53,7 @@ module RuboCop
                        MSG_TERNARY
                      end
 
-          format(template, expr: node.condition.source)
+          format(template, keyword: node.keyword, expr: node.condition.source)
         end
 
         def autocorrect(corrector, node)
@@ -71,16 +75,20 @@ module RuboCop
         end
 
         def use_return_with_argument?(node)
-          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+          node.branches.compact.any? { |branch| branch.return_type? && branch.arguments.any? }
         end
 
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
-          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
+          then_code = node.if_branch ? ternary_operand(node.if_branch) : 'nil'
+          else_code = node.else_branch ? ternary_operand(node.else_branch) : 'nil'
+
+          then_code, else_code = else_code, then_code if node.unless?
+
+          ternary = "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
 
-          "#{node.condition.source} ? #{then_code} : #{else_code}"
+          operand_of_parent?(node) ? "(#{ternary})" : ternary
         end
 
         def correct_elsif(node)
@@ -101,6 +109,41 @@ 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})" : ternary_operand(condition)
+        end
+
+        def ternary_operand(expr)
+          lower_precedence_than_ternary?(expr) ? "(#{expr.source})" : build_expression(expr)
+        end
+
+        # Expressions that bind looser than `?:` (or cannot appear unparenthesized
+        # inside it) would otherwise absorb or break the ternary.
+        def lower_precedence_than_ternary?(node)
+          return true if node.type?(*LOWER_PRECEDENCE_THAN_TERNARY_TYPES)
+          return true if node.send_type? && (node.prefix_not? || prefix_bang_on_command?(node))
+
+          node.type?(:yield, :super, :defined?) && node.arguments.any? && !node.parenthesized?
+        end
+
+        def operand_of_parent?(node)
+          return false unless (parent = node.parent)
+          return true if parent.operator_keyword?
+
+          parent.call_type? && call_operand?(parent, node)
+        end
+
+        def call_operand?(call, node)
+          return false if call.prefix_not?
+          return true if call.receiver.equal?(node)
+
+          call.operator_method? && !call.method?(:[]) && !call.method?(:[]=)
+        end
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
@@ -121,6 +164,16 @@ module RuboCop
           result
         end
 
+        # `!foo a` leaves the arguments of `foo` unparenthesized at the end of the operand,
+        # where they would absorb the rest of the ternary.
+        def prefix_bang_on_command?(node)
+          return false unless node.prefix_bang?
+
+          receiver = node.receiver
+
+          require_argument_parentheses?(receiver) || lower_precedence_than_ternary?(receiver)
+        end
+
         def require_argument_parentheses?(node)
           return false if !node.call_type? || node.arithmetic_operation?
 

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for trailing inline comments.
+      # Checks for trailing inline comments. Inline comments can
+      # make lines harder to read, especially when they are long.
+      # Placing comments on their own line above the code they
+      # describe is often clearer.
       #
       # @example
       #
@@ -23,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/inverse_methods.rb

@@ -114,9 +114,31 @@ module RuboCop
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          corrector.remove(not_to_receiver(node, method_call))
+          remove_negation(corrector, node, method, method_call)
           corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
-          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def remove_negation(corrector, node, method, method_call)
+          if !keep_parentheses?(node, method_call)
+            corrector.remove(not_to_receiver(node, method_call))
+            remove_end_parenthesis(corrector, node, method, method_call)
+          elsif node.parenthesized?
+            corrector.remove(node.loc.selector)
+          else
+            corrector.remove(node.loc.selector.join(node.receiver.source_range.begin))
+          end
+        end
+
+        def keep_parentheses?(node, method_call)
+          return false unless node.receiver.begin_type? || node.parenthesized?
+          return false unless method_call.operator_method?
+          return false unless (parent = node.parent)&.call_type?
+
+          binary_operator?(parent) || parent.receiver.equal?(node)
+        end
+
+        def binary_operator?(node)
+          node.operator_method? && !node.loc.dot && !node.method?(:[]) && !node.method?(:[]=)
         end
 
         def correct_inverse_block(corrector, node)

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/ip_addresses.rb

@@ -48,8 +48,7 @@ module RuboCop
         private
 
         def allowed_addresses
-          allowed_addresses = cop_config['AllowedAddresses']
-          Array(allowed_addresses).map(&:downcase)
+          @allowed_addresses ||= Array(cop_config['AllowedAddresses']).map(&:downcase).freeze
         end
 
         def potential_ip?(str)

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

@@ -59,8 +59,20 @@ module RuboCop
         MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
         MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
 
+        SCOPE_TYPES = %i[any_def class module sclass].freeze
+
         minimum_target_ruby_version 3.4
 
+        # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
+        # which would leave an empty parameter list that forbids `it`.
+        def self.autocorrect_incompatible_with
+          [Style::Lambda, Style::StabbyLambdaParentheses]
+        end
+
+        def on_new_investigation
+          @it_variable_definitions = nil
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -68,9 +80,10 @@ module RuboCop
           # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
           return unless node.first_argument.arg_type?
 
-          variables = find_block_variables(node, node.first_argument.source)
+          block_argument_name = node.first_argument.source
+          return if keep_parameter_name?(node.body, block_argument_name)
 
-          variables.each do |variable|
+          find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
@@ -109,12 +122,89 @@ module RuboCop
         private
 
         def find_block_variables(node, block_argument_name)
-          return [] unless node.body
+          return [] if !node.body || it_variable_in_scope?(node)
+
+          ranges = inner_block_ranges(node.body)
+
+          block_variables(node.body, block_argument_name).reject do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def it_variable_in_scope?(node)
+          scope = nearest_scope(node)
+          return true if it_argument_in_scope?(node, scope)
 
-          node.body.each_descendant(:lvar).select do |descendant|
+          it_variable_definitions.any? do |definition|
+            nearest_scope(definition).equal?(scope) && visible_in_block?(definition, node)
+          end
+        end
+
+        def it_variable_definitions
+          @it_variable_definitions ||=
+            variable_definitions(processed_source.ast).filter_map do |name, definition|
+              definition if name == 'it'
+            end
+        end
+
+        def nearest_scope(node)
+          node.each_ancestor(*SCOPE_TYPES).first
+        end
+
+        def it_argument_in_scope?(node, scope)
+          owners = node.each_ancestor(:block).select { |block| nearest_scope(block).equal?(scope) }
+          owners << scope if scope&.any_def_type?
+
+          owners.any? { |owner| owner.arguments.argument_list.any? { |arg| arg.name == :it } }
+        end
+
+        def visible_in_block?(definition, node)
+          return true if definition.source_range.begin_pos < node.source_range.begin_pos
+
+          node.source_range.contains?(definition.source_range)
+        end
+
+        def inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        end
+
+        def keep_parameter_name?(body, block_arg_name)
+          used_within_inner_block?(body, block_arg_name) || reassigned?(body, block_arg_name)
+        end
+
+        def used_within_inner_block?(body, block_argument_name)
+          return false unless body
+
+          ranges = inner_block_ranges(body)
+
+          block_variables(body, block_argument_name).any? do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def reassigned?(body, block_argument_name)
+          return false unless body
+
+          variable_definitions(body).any? { |name, _definition| name == block_argument_name }
+        end
+
+        def block_variables(body, block_argument_name)
+          body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end
+
+        def variable_definitions(node)
+          node.each_node(:lvasgn, :match_var, :match_with_lvasgn).flat_map do |definition|
+            names = if definition.match_with_lvasgn_type?
+                      definition.children.first.each_capture(named: true).map(&:name)
+                    else
+                      [definition.children.first.to_s]
+                    end
+
+            names.map { |name| [name, definition] }
+          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

@@ -62,16 +62,22 @@ 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)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(kwarg.source_range)
+            range = range_with_surrounding_space(kwarg.source_range, side: :left, whitespace: true)
+            with_space = range_with_surrounding_space(range, side: :right)
+
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -48,6 +48,8 @@ module RuboCop
       #       end
       class Lambda < Base
         include ConfigurableEnforcedStyle
+        include PatternMatchingHelp
+        include RescueNode
         extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
@@ -61,12 +63,17 @@ module RuboCop
           }
         }.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::SymbolProc]
+        end
+
         def on_block(node)
           return unless node.lambda?
 
           selector = node.send_node.source
 
           return unless offending_selector?(node, selector)
+          return if uncorrectable_lambda_literal?(node)
 
           add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
@@ -87,6 +94,21 @@ module RuboCop
           selector == OFFENDING_SELECTORS[:style][style][lines]
         end
 
+        def uncorrectable_lambda_literal?(node)
+          return false unless node.send_node.lambda_literal?
+          return true if in_pattern?(node)
+          return false unless rescue_or_ensure_clause?(node.body)
+
+          LambdaLiteralToMethodCorrector.new(node).replace_delimiters?
+        end
+
+        def rescue_or_ensure_clause?(body)
+          return false unless body
+          return true if body.ensure_type?
+
+          body.rescue_type? && !rescue_modifier?(body.resbody_branches.first)
+        end
+
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
@@ -107,18 +129,39 @@ module RuboCop
 
           return unless node.arguments?
 
-          arg_str = "(#{lambda_arg_string(node.arguments)})"
+          arg_str = lambda_arg_string(node.arguments)
+          arg_str = " #{arg_str} " if space_inside_parens?
+          arg_str = "(#{arg_str})"
+          arg_str = " #{arg_str}" if space_in_lambda_literal_required?
 
           corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          %w[space compact].include?(config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'])
+        end
+
+        def space_in_lambda_literal_required?
+          return false unless config.cop_enabled?('Layout/SpaceInLambdaLiteral')
+
+          config.for_cop('Layout/SpaceInLambdaLiteral')['EnforcedStyle'] == 'require_space'
+        end
+
         def arguments_with_whitespace(node)
           node.loc.begin.end.join(node.arguments.loc.end)
         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,10 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          # Rewriting the call rebuilds it as a single expression, which would drop
+          # any comments or heredoc bodies inside the argument list, so leave it to be
+          # fixed manually.
+          return if comments_in_node?(node) || heredoc_argument?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -48,6 +52,18 @@ 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 heredoc_argument?(node)
+          node.arguments.any? { |argument| argument.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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
 
@@ -187,7 +187,7 @@ module RuboCop
             issues[:directives] << directive if directive_offends?(directive)
           end
 
-          comment.values.each do |value| # rubocop:disable Style/HashEachMethods
+          comment.values.each do |value| # rubocop:disable Style/HashEachMethods -- the receiver is a magic comment, not a Hash
             issues[:values] << value if wrong_capitalization?(value.source, value_capitalization)
           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)
@@ -112,8 +112,7 @@ module RuboCop
 
         def on_block(node)
           return unless each_block_with_push?(node)
-
-          dest_var = find_dest_var(node)
+          return unless (dest_var = find_dest_var(node))
 
           if offending_empty_array_tap?(node, dest_var)
             asgn = dest_var.declaration_node