rubocop 1.77.0 → 1.79.0

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

@@ -5,12 +5,13 @@ module RuboCop
     module Style
       # In Ruby 3.1, `Array#intersect?` has been added.
       #
-      # This cop identifies places where `(array1 & array2).any?`
-      # or `(array1.intersection(array2)).any?` can be replaced by
-      # `array1.intersect?(array2)`.
+      # This cop identifies places where:
+      # * `(array1 & array2).any?`
+      # * `(array1.intersection(array2)).any?`
+      # * `array1.any? { |elem| array2.member?(elem) }`
+      # can be replaced with `array1.intersect?(array2)`.
       #
-      # The `array1.intersect?(array2)` method is faster than
-      # `(array1 & array2).any?` and is more readable.
+      # `array1.intersect?(array2)` is faster and more readable.
       #
       # In cases like the following, compatibility is not ensured,
       # so it will not be detected when using block argument.
@@ -40,6 +41,10 @@ module RuboCop
       #   array1.intersection(array2).empty?
       #   array1.intersection(array2).none?
       #
+      #   # bad
+      #   array1.any? { |elem| array2.member?(elem) }
+      #   array1.none? { |elem| array2.member?(elem) }
+      #
       #   # good
       #   array1.intersect?(array2)
       #   !array1.intersect?(array2)
@@ -77,8 +82,26 @@ module RuboCop
           )
         PATTERN
 
-        MSG = 'Use `%<negated>s%<receiver>s%<dot>sintersect?(%<argument>s)` ' \
-              'instead of `%<existing>s`.'
+        # @!method any_none_block_intersection(node)
+        def_node_matcher :any_none_block_intersection, <<~PATTERN
+          {
+            (block
+              (call $_receiver ${:any? :none?})
+              (args (arg _key))
+              (send $_argument :member? (lvar _key))
+            )
+            (numblock
+              (call $_receiver ${:any? :none?}) 1
+              (send $_argument :member? (lvar :_1))
+            )
+            (itblock
+              (call $_receiver ${:any? :none?}) :it
+              (send $_argument :member? (lvar :it))
+            )
+          }
+        PATTERN
+
+        MSG = 'Use `%<replacement>s` instead of `%<existing>s`.'
         STRAIGHT_METHODS = %i[present? any?].freeze
         NEGATED_METHODS = %i[blank? empty? none?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
@@ -88,16 +111,25 @@ module RuboCop
           return unless (receiver, argument, method_name = bad_intersection?(node))
 
           dot = node.loc.dot.source
-          message = message(receiver.source, argument.source, method_name, dot, node.source)
+          bang = straight?(method_name) ? '' : '!'
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
-          add_offense(node, message: message) do |corrector|
-            bang = straight?(method_name) ? '' : '!'
-
-            corrector.replace(node, "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})")
-          end
+          register_offense(node, replacement)
         end
         alias on_csend on_send
 
+        def on_block(node)
+          return unless (receiver, method_name, argument = any_none_block_intersection(node))
+
+          dot = node.send_node.loc.dot.source
+          bang = method_name == :any? ? '' : '!'
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
+
+          register_offense(node, replacement)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
         private
 
         def bad_intersection?(node)
@@ -114,16 +146,12 @@ module RuboCop
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
-        def message(receiver, argument, method_name, dot, existing)
-          negated = straight?(method_name) ? '' : '!'
-          format(
-            MSG,
-            negated: negated,
-            receiver: receiver,
-            argument: argument,
-            dot: dot,
-            existing: existing
-          )
+        def register_offense(node, replacement)
+          message = format(MSG, replacement: replacement, existing: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
         end
       end
     end

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

@@ -4,7 +4,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for uses of braces or do/end around single line or
+      # Checks for uses of braces or do/end around single line or
       # multi-line blocks.
       #
       # Methods that can be either procedural or functional and cannot be

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

@@ -111,7 +111,7 @@ module RuboCop
         end
       end
 
-      # Check for `if` and `case` statements where each branch is used for
+      # Checks for `if` and `case` statements where each branch is used for
       # both the assignment and comparison of the same variable
       # when using the return of the condition can be used instead.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for chained `dig` calls that can be collapsed into a single `dig`.
+      # Checks for chained `dig` calls that can be collapsed into a single `dig`.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver

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

@@ -59,6 +59,7 @@ module RuboCop
       #
       class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
+
         MESSAGES = {
           scientific: 'Use a mantissa >= 1 and < 10.',
           engineering: 'Use an exponent divisible by 3 and a mantissa >= 0.1 and < 1000.',

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

@@ -44,10 +44,10 @@ module RuboCop
       class HashConversion < Base
         extend AutoCorrector
 
-        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
-        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
-        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
-        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        MSG_TO_H = 'Prefer `ary.to_h` to `Hash[ary]`.'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to `Hash[arg1, arg2, ...]`.'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to `Hash[key: value, ...]`.'
+        MSG_SPLAT = 'Prefer `array_of_pairs.to_h` to `Hash[*array]`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
         # @!method hash_from_array?(node)
@@ -64,11 +64,11 @@ module RuboCop
           #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
           #   ...but don't suggest correction if there is odd number of them (it is a bug)
           node.arguments.one? ? single_argument(node) : multi_argument(node)
+          ignore_node(node)
         end
 
         private
 
-        # rubocop:disable Metrics/MethodLength
         def single_argument(node)
           first_argument = node.first_argument
           if first_argument.hash_type?
@@ -83,11 +83,8 @@ module RuboCop
               replacement = "(#{replacement})" if requires_parens?(first_argument)
               corrector.replace(node, "#{replacement}.to_h")
             end
-
-            ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def use_zip_method_without_argument?(first_argument)
           return false unless first_argument&.send_type?
@@ -131,7 +128,9 @@ module RuboCop
               corrector.replace(node, args_to_hash(node.arguments))
 
               parent = node.parent
-              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+                add_parentheses(parent, corrector)
+              end
             end
           end
         end

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

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

@@ -109,7 +109,9 @@ module RuboCop
         private
 
         def find_block_variables(node, block_argument_name)
-          node.each_descendant(:lvar).select do |descendant|
+          return [] unless node.body
+
+          node.body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end

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

@@ -222,11 +222,9 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            # NOTE: should be removed after releasing https://github.com/rubocop/rubocop-ast/pull/379
-            return node.source.match?(/\A[+-]/) if node.complex_type?
+            return true if node.numeric_type? && node.sign?
 
-            (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent.unary_operation?)
+            node.parent&.send_type? && node.parent.unary_operation?
           end
 
           def assigned_before?(node, target)

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

@@ -132,6 +132,22 @@ module RuboCop
       #     bar :baz
       #   end
       #
+      # @example AllowedMethods: ["puts", "print"]
+      #
+      #   # good
+      #   puts "Hello world"
+      #   print "Hello world"
+      #   # still enforces parentheses on other methods
+      #   array.delete(e)
+      #
+      # @example AllowedPatterns: ["^assert"]
+      #
+      #   # good
+      #   assert_equal 'test', x
+      #   assert_match(/foo/, bar)
+      #   # still enforces parentheses on other methods
+      #   array.delete(e)
+      #
       # @example AllowParenthesesInMultilineCall: false (default)
       #
       #   # bad

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

@@ -29,6 +29,8 @@ module RuboCop
         MSG = 'Do not use parallel assignment.'
 
         def on_masgn(node) # rubocop:disable Metrics/AbcSize
+          return if part_of_ignored_node?(node)
+
           rhs = node.rhs
           rhs = rhs.body if rhs.rescue_type?
           rhs_elements = Array(rhs).compact # edge case for one constant
@@ -41,6 +43,7 @@ module RuboCop
           add_offense(range) do |corrector|
             autocorrect(corrector, node, rhs)
           end
+          ignore_node(node)
         end
 
         private

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

@@ -49,7 +49,7 @@ module RuboCop
           (block
             $(call _ :fetch _)
             (args)
-            ${nil? #basic_literal? #const_type?})
+            ${nil? basic_literal? const_type?})
         PATTERN
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
@@ -71,14 +71,6 @@ module RuboCop
 
         private
 
-        def basic_literal?(node)
-          node&.basic_literal?
-        end
-
-        def const_type?(node)
-          node&.const_type?
-        end
-
         def should_not_check?(send, body)
           (body&.const_type? && !check_for_constant?) ||
             (body&.str_type? && !check_for_string?) ||

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for uses of `Object#freeze` on immutable objects.
+      # Checks for uses of `Object#freeze` on immutable objects.
       #
       # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for redundant line continuation.
+      # Checks for redundant line continuation.
       #
       # This cop marks a line continuation as redundant if removing the backslash
       # does not result in a syntax error.

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

@@ -169,6 +169,7 @@ module RuboCop
           end
           return 'an interpolated expression' if interpolation?(begin_node)
           return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          return 'a one-line rescue' if !begin_node.parent&.call_type? && node.rescue_type?
 
           return if begin_node.chained?
 

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

@@ -65,7 +65,7 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.parent.assignment_method? ||
+          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
                           NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
 
           !body_node.type?(:begin, :kwbegin)
@@ -86,10 +86,10 @@ module RuboCop
         end
 
         def correct_to_endless(corrector, node)
-          self_receiver = node.self_receiver? ? 'self.' : ''
+          receiver = "#{node.receiver.source}." if node.receiver
           arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+          replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
         end
@@ -130,7 +130,10 @@ module RuboCop
         end
 
         def require_parentheses?(method_body)
-          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+          return false unless method_body.send_type?
+          return false if method_body.arithmetic_operation?
+
+          !method_body.arguments.empty? && !method_body.comparison_method?
         end
 
         def disallow_endless_method_style?

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

@@ -175,6 +175,8 @@ module RuboCop
 
           if parenthesize_method?(condition)
             parenthesized_method_arguments(condition)
+          elsif condition.and_type?
+            parenthesized_and(condition)
           else
             "(#{condition.source})"
           end
@@ -186,12 +188,19 @@ module RuboCop
         end
 
         def add_parentheses?(node)
-          return true if node.assignment? || (node.operator_keyword? && !node.and_type?)
+          return true if node.assignment? || node.or_type?
+          return true if assignment_in_and?(node)
           return false unless node.call_type?
 
           (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
         end
 
+        def assignment_in_and?(node)
+          return false unless node.and_type?
+
+          node.each_descendant.any?(&:assignment?)
+        end
+
         def parenthesized_method_arguments(node)
           method_call = node.source_range.begin.join(node.loc.selector.end).source
           arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
@@ -199,6 +208,26 @@ module RuboCop
           "#{method_call}(#{arguments})"
         end
 
+        def parenthesized_and(node)
+          # We only need to add parentheses around the last clause if it's an assignment,
+          # because other clauses will be unchanged by merging conditionals.
+          lhs = node.lhs.source
+          rhs = parenthesized_and_clause(node.rhs)
+          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
+
+          "#{lhs}#{operator}#{rhs}"
+        end
+
+        def parenthesized_and_clause(node)
+          if node.and_type?
+            parenthesized_and(node)
+          elsif node.assignment?
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def allow_modifier?
           cop_config['AllowModifier']
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for parentheses around stabby lambda arguments.
+      # Checks for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
       # @example EnforcedStyle: require_parentheses (default)

data/lib/rubocop/cop/variable_force.rb

@@ -296,7 +296,7 @@ module RuboCop
         variable_table.accessible_variables.each { |variable| variable.reference!(node) }
       end
 
-      # Mark all assignments which are referenced in the same loop
+      # Mark last assignments which are referenced in the same loop
       # as referenced by ignoring AST order since they would be referenced
       # in next iteration.
       def mark_assignments_as_referenced_in_loop(node)
@@ -308,13 +308,12 @@ module RuboCop
           # would be skipped here.
           next unless variable
 
-          variable.assignments.each do |assignment|
-            next if assignment_nodes_in_loop.none? do |assignment_node|
-                      assignment_node.equal?(assignment.node)
-                    end
-
-            assignment.reference!(node)
+          loop_assignments = variable.assignments.select do |assignment|
+            assignment_nodes_in_loop.include?(assignment.node)
           end
+          next unless loop_assignments.any?
+
+          reference_assignments(loop_assignments, node)
         end
       end
 
@@ -354,6 +353,16 @@ module RuboCop
         end
       end
 
+      def reference_assignments(loop_assignments, node)
+        # If inside a case statement, mark all as referenced.
+        # Otherwise, mark only the last assignment as referenced.
+        if loop_assignments.first.node.each_ancestor(:case, :case_match).any?
+          loop_assignments.each { |assignment| assignment.reference!(node) }
+        else
+          loop_assignments.last&.reference!(node)
+        end
+      end
+
       def scanned_node?(node)
         scanned_nodes.include?(node)
       end

data/lib/rubocop/cops_documentation_generator.rb

@@ -7,6 +7,7 @@ require 'yard'
 # @api private
 class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   include ::RuboCop::Cop::Documentation
+
   CopData = Struct.new(
     :cop, :description, :example_objects, :safety_objects, :see_objects, :config, keyword_init: true
   )

data/lib/rubocop/formatter/markdown_formatter.rb

@@ -6,6 +6,7 @@ module RuboCop
     class MarkdownFormatter < BaseFormatter
       include TextUtil
       include PathUtil
+
       attr_reader :files, :summary
 
       def initialize(output, options = {})

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -9,6 +9,7 @@ module RuboCop
     # https://github.com/go-labs/rspec_pacman_formatter
     class PacmanFormatter < ClangStyleFormatter
       include TextUtil
+
       attr_accessor :progress_line
 
       FALLBACK_TERMINAL_WIDTH = 80

data/lib/rubocop/pending_cops_reporter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Reports information about pending cops that are not explicitly configured.
+  #
+  # This class is responsible for displaying warnings when new cops have been added to RuboCop
+  # but have not yet been enabled or disabled in the user's configuration.
+  # It provides a centralized way to determine whether such warnings should be shown,
+  # based on global flags or configuration settings.
+  class PendingCopsReporter
+    class << self
+      PENDING_BANNER = <<~BANNER
+        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
+
+        Please also note that you can opt-in to new cops by default by adding this to your config:
+          AllCops:
+            NewCops: enable
+      BANNER
+
+      attr_accessor :disable_pending_cops, :enable_pending_cops
+
+      def warn_if_needed(config)
+        return if possible_new_cops?(config)
+
+        pending_cops = pending_cops_only_qualified(config.pending_cops)
+        warn_on_pending_cops(pending_cops) unless pending_cops.empty?
+      end
+
+      private
+
+      def pending_cops_only_qualified(pending_cops)
+        pending_cops.select { |cop| Cop::Registry.qualified_cop?(cop.name) }
+      end
+
+      def possible_new_cops?(config)
+        disable_pending_cops || enable_pending_cops ||
+          config.disabled_new_cops? || config.enabled_new_cops?
+      end
+
+      def warn_on_pending_cops(pending_cops)
+        warn Rainbow(PENDING_BANNER).yellow
+
+        pending_cops.each { |cop| warn_pending_cop cop }
+
+        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
+      end
+
+      def warn_pending_cop(cop)
+        version = cop.metadata['VersionAdded'] || 'N/A'
+
+        warn Rainbow("#{cop.name}: # new in #{version}").yellow
+        warn Rainbow('  Enabled: true').yellow
+      end
+    end
+  end
+end