rubocop 1.71.1 → 1.92.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for usages of not (`not` or `!`) called on a method
+      # Checks for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
       #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
@@ -46,6 +46,7 @@ module RuboCop
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        SAFE_NAVIGATION_INCOMPATIBLE_METHODS = (CLASS_COMPARISON_METHODS + %i[any? none?]).freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
@@ -77,7 +78,7 @@ module RuboCop
         def on_send(node)
           inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
+            return if negated?(node) || safe_navigation_incompatible?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -105,6 +106,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -112,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)
@@ -154,10 +178,6 @@ module RuboCop
           node.parent.respond_to?(:method?) && node.parent.method?(:!)
         end
 
-        def relational_comparison_with_safe_navigation?(node)
-          node.csend_type? && CLASS_COMPARISON_METHODS.include?(node.method_name)
-        end
-
         def not_to_receiver(node, method_call)
           node.loc.selector.begin.join(method_call.source_range.begin)
         end
@@ -166,6 +186,12 @@ module RuboCop
           method_call.source_range.end.join(node.source_range.end)
         end
 
+        def safe_navigation_incompatible?(node)
+          return false unless node.csend_type?
+
+          SAFE_NAVIGATION_INCOMPATIBLE_METHODS.include?(node.method_name)
+        end
+
         # When comparing classes, `!(Integer < Numeric)` is not the same as
         # `Integer > Numeric`.
         def possible_class_hierarchy_check?(lhs, rhs, method)

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)
 
@@ -89,8 +91,8 @@ module RuboCop
 
         def inheritance_check?(node)
           argument = node.first_argument
-          node.method?(:<) &&
-            (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
+          node.method?(:<) && argument.const_type? &&
+            argument.short_name.to_s.upcase != argument.short_name.to_s
         end
 
         def preferred_condition(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

@@ -32,7 +32,7 @@ module RuboCop
 
           # To try to avoid doing two regex checks on every string,
           # shortcut out if the string does not look like an IP address
-          return false unless could_be_ip?(contents)
+          return false unless potential_ip?(contents)
 
           ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
         end
@@ -48,11 +48,10 @@ 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 could_be_ip?(str)
+        def potential_ip?(str)
           # If the string is too long, it can't be an IP
           return false if too_long?(str)
 

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

@@ -3,33 +3,90 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for assignments to a local `it` variable inside a block
+      # Checks for local variables and method parameters named `it`,
       # where `it` can refer to the first anonymous parameter as of Ruby 3.4.
+      # Use a meaningful variable name instead.
       #
-      # Although Ruby allows reassigning `it` in these cases, it could
+      # NOTE: Although Ruby allows reassigning `it` in these cases, it could
       # cause confusion if `it` is used as a block parameter elsewhere.
-      # For consistency, this also applies to numblocks and blocks with
-      # parameters, even though `it` cannot be used in those cases.
       #
       # @example
       #   # bad
-      #   foo { it = 5 }
-      #   foo { |bar| it = bar }
-      #   foo { it = _2 }
+      #   it = 5
       #
-      #   # good - use a different variable name
-      #   foo { var = 5 }
-      #   foo { |bar| var = bar }
-      #   foo { bar = _2 }
+      #   # good
+      #   var = 5
+      #
+      #   # bad
+      #   def foo(it)
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #   end
+      #
+      #   # bad
+      #   def foo(it = 5)
+      #   end
+      #
+      #   # good
+      #   def foo(arg = 5)
+      #   end
+      #
+      #   # bad
+      #   def foo(*it)
+      #   end
+      #
+      #   # good
+      #   def foo(*args)
+      #   end
+      #
+      #   # bad
+      #   def foo(it:)
+      #   end
+      #
+      #   # good
+      #   def foo(arg:)
+      #   end
+      #
+      #   # bad
+      #   def foo(it: 5)
+      #   end
+      #
+      #   # good
+      #   def foo(arg: 5)
+      #   end
+      #
+      #   # bad
+      #   def foo(**it)
+      #   end
+      #
+      #   # good
+      #   def foo(**kwargs)
+      #   end
+      #
+      #   # bad
+      #   def foo(&it)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #   end
       class ItAssignment < Base
         MSG = '`it` is the default block parameter; consider another name.'
 
         def on_lvasgn(node)
           return unless node.name == :it
-          return unless node.each_ancestor(:any_block).any?
 
           add_offense(node.loc.name)
         end
+        alias on_arg on_lvasgn
+        alias on_optarg on_lvasgn
+        alias on_restarg on_lvasgn
+        alias on_blockarg on_lvasgn
+        alias on_kwarg on_lvasgn
+        alias on_kwoptarg on_lvasgn
+        alias on_kwrestarg on_lvasgn
       end
     end
   end

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

@@ -0,0 +1,150 @@
+# 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
+
+        # `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_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?
+
+          block_argument_name = node.first_argument.source
+          return if used_within_inner_block?(node.body, block_argument_name)
+
+          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')
+            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
+
+          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 inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        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 block_variables(body, block_argument_name)
+          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,30 +42,42 @@ 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)
           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?
@@ -77,6 +84,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -86,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
 
@@ -117,7 +140,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,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,15 +52,32 @@ 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
 
         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)