rubocop 1.72.1 → 1.81.7

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

@@ -84,7 +84,10 @@ module RuboCop
 
         def autocorrect(corrector, node)
           if (preferred_accessors = preferred_accessors(node))
-            corrector.replace(node, preferred_accessors)
+            corrector.replace(
+              grouped_style? ? node : range_with_trailing_argument_comment(node),
+              preferred_accessors
+            )
           else
             range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
@@ -139,12 +142,16 @@ module RuboCop
           style == :separated
         end
 
+        def groupable_sibling_accessor?(node, sibling)
+          sibling.attribute_accessor? &&
+            sibling.method?(node.method_name) &&
+            node_visibility(sibling) == node_visibility(node) &&
+            groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+        end
+
         def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            sibling.attribute_accessor? &&
-              sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node) &&
-              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+            groupable_sibling_accessor?(send_node, sibling)
           end
         end
 
@@ -155,13 +162,23 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
+            return if skip_for_grouping?(node)
+
             accessors = groupable_sibling_accessors(node)
-            group_accessors(node, accessors) if node.loc == accessors.first.loc
+            if node.loc == accessors.first.loc || skip_for_grouping?(accessors.first)
+              group_accessors(node, accessors)
+            end
           else
             separate_accessors(node)
           end
         end
 
+        # Group after constants
+        def skip_for_grouping?(node)
+          node.right_siblings.any?(&:casgn_type?) &&
+            node.right_siblings.any? { |n| n.send_type? && groupable_sibling_accessor?(node, n) }
+        end
+
         def group_accessors(node, accessors)
           accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 
@@ -182,6 +199,15 @@ module RuboCop
             end
           end.join("\n")
         end
+
+        def range_with_trailing_argument_comment(node)
+          comment = processed_source.ast_with_comments[node.last_argument].last
+          if comment
+            add_range(node.source_range, comment.source_range)
+          else
+            node
+          end
+        end
       end
     end
   end

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

@@ -16,26 +16,26 @@ module RuboCop
       #
       # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
       #
-      # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
-      # replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
-      # by setting `UseAnonymousForwarding: false`.
+      # This cop also identifies places where `+use_args(*args)+`/`+use_kwargs(**kwargs)+` can be
+      # replaced by `+use_args(*)+`/`+use_kwargs(**)+`; if desired, this functionality can be
+      # disabled by setting `UseAnonymousForwarding: false`.
       #
       # And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`,
       # and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names
       # that are sufficient for anonymizing meaningless naming.
       #
       # Meaningless names that are commonly used can be anonymized by default:
-      # e.g., `*args`, `**options`, `&block`, and so on.
+      # e.g., `+*args+`, `+**options+`, `&block`, and so on.
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
       # This cop handles not only method forwarding but also forwarding to `super`.
       #
       # [NOTE]
-      # --
+      # ====
       # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
       # no offense will be registered until Ruby 3.4:
-
+      #
       # [source,ruby]
       # ----
       # def foo(&block)
@@ -43,7 +43,7 @@ module RuboCop
       #   block_method { bar(&block) }
       # end
       # ----
-      # --
+      # ====
       #
       # @example
       #   # bad
@@ -146,7 +146,6 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
-        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -198,9 +197,9 @@ module RuboCop
           send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          _rest_arg, _kwrest_arg, block_arg = *forwardable_args
+          rest_arg, kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
 
           send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
@@ -212,16 +211,20 @@ module RuboCop
               registered_block_arg_offense = true
               break
             else
-              register_forward_all_offense(send_node, send_node, forward_rest)
+              first_arg = forward_rest || forward_kwrest || forward_all_first_argument(send_node)
+              register_forward_all_offense(send_node, send_node, first_arg)
             end
           end
 
           return if registered_block_arg_offense
 
-          rest_arg, _kwrest_arg, _block_arg = *forwardable_args
-          register_forward_all_offense(node, node.arguments, rest_arg)
+          register_forward_all_offense(node, node.arguments, rest_arg || kwrest_arg)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def forward_all_first_argument(node)
+          node.arguments.reverse_each.find(&:forwarded_restarg_type?)
         end
-        # rubocop:enable Metrics/MethodLength
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
@@ -361,18 +364,9 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         def arguments_range(node, first_node)
-          arguments = node.arguments.reject do |arg|
-            next true if ADDITIONAL_ARG_TYPES.include?(arg.type) || arg.variable? || arg.call_type?
-
-            arg.literal? && arg.each_descendant(:kwsplat).none?
-          end
-
-          start_node = first_node || arguments.first
-          start_node.source_range.begin.join(arguments.last.source_range.end)
+          first_node.source_range.begin.join(node.last_argument.source_range.end)
         end
-        # rubocop:enable Metrics/AbcSize
 
         def allow_only_rest_arguments?
           cop_config.fetch('AllowOnlyRestArgument', true)
@@ -479,6 +473,9 @@ module RuboCop
           end
 
           def ruby_32_only_anonymous_forwarding?
+            # A block argument and an anonymous block argument are never passed together.
+            return false if @send_node.each_ancestor(:any_block).any?
+
             def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
           end
 

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

@@ -5,11 +5,17 @@ module RuboCop
     module Style
       # In Ruby 3.1, `Array#intersect?` has been added.
       #
-      # This cop identifies places where `(array1 & array2).any?`
-      # can be replaced by `array1.intersect?(array2)`.
+      # This cop identifies places where:
       #
-      # The `array1.intersect?(array2)` method is faster than
-      # `(array1 & array2).any?` and is more readable.
+      # * `(array1 & array2).any?`
+      # * `(array1.intersection(array2)).any?`
+      # * `array1.any? { |elem| array2.member?(elem) }`
+      # * `(array1 & array2).count > 0`
+      # * `(array1 & array2).size > 0`
+      #
+      # can be replaced with `array1.intersect?(array2)`.
+      #
+      # `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.
@@ -20,6 +26,10 @@ module RuboCop
       # [1].intersect?([1,2]) { |x| false } # => true
       # ----
       #
+      # NOTE: Although `Array#intersection` can take zero or multiple arguments,
+      # only cases where exactly one argument is provided can be replaced with
+      # `Array#intersect?` and are handled by this cop.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -30,10 +40,32 @@ module RuboCop
       #   (array1 & array2).empty?
       #   (array1 & array2).none?
       #
+      #   # bad
+      #   array1.intersection(array2).any?
+      #   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)
       #
+      #   # bad
+      #   (array1 & array2).count > 0
+      #   (array1 & array2).count.positive?
+      #   (array1 & array2).count != 0
+      #
+      #   (array1 & array2).count == 0
+      #   (array1 & array2).count.zero?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #
+      #   !array1.intersect?(array2)
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #   # good
       #   (array1 & array2).present?
@@ -53,50 +85,96 @@ module RuboCop
 
         minimum_target_ruby_version 3.1
 
-        # @!method regular_bad_intersection_check?(node)
-        def_node_matcher :regular_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:any? :empty? :none?}
+        PREDICATES = %i[any? empty? none?].to_set.freeze
+        ACTIVE_SUPPORT_PREDICATES = (PREDICATES + %i[present? blank?]).freeze
+
+        ARRAY_SIZE_METHODS = %i[count length size].to_set.freeze
+
+        # @!method bad_intersection_check?(node, predicates)
+        def_node_matcher :bad_intersection_check?, <<~PATTERN
+          $(call
+            {
+              (begin (send $_ :& $_))
+              (call $!nil? :intersection $_)
+            }
+            $%1
           )
         PATTERN
 
-        # @!method active_support_bad_intersection_check?(node)
-        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:present? :any? :blank? :empty? :none?}
+        # @!method intersection_size_check?(node, predicates)
+        def_node_matcher :intersection_size_check?, <<~PATTERN
+          (call
+            $(call
+              {
+                (begin (send $_ :& $_))
+                (call $!nil? :intersection $_)
+              }
+              %ARRAY_SIZE_METHODS
+            )
+            {$:> (int 0) | $:positive? | $:!= (int 0) | $:== (int 0) | $:zero?}
           )
         PATTERN
 
-        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
-              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
-        STRAIGHT_METHODS = %i[present? any?].freeze
-        NEGATED_METHODS = %i[blank? empty? none?].freeze
+        # @!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? > positive? !=].freeze
+        NEGATED_METHODS = %i[blank? empty? none? == zero?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
           return if node.block_literal?
-          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+          return unless (dot_node, receiver, argument, method_name = bad_intersection?(node))
 
-          message = message(receiver.source, argument.source, method_name)
+          dot = dot_node.loc.dot.source
+          bang = straight?(method_name) ? '' : '!'
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
-          add_offense(node, message: message) do |corrector|
-            bang = straight?(method_name) ? '' : '!'
+          register_offense(node, replacement)
+        end
+        alias on_csend on_send
 
-            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
-          end
+        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_check?(node)
+        def bad_intersection?(node)
+          bad_intersection_check?(node, bad_intersection_predicates) ||
+            intersection_size_check?(node)
+        end
+
+        def bad_intersection_predicates
           if active_support_extensions_enabled?
-            active_support_bad_intersection_check?(node)
+            ACTIVE_SUPPORT_PREDICATES
           else
-            regular_bad_intersection_check?(node)
+            PREDICATES
           end
         end
 
@@ -104,15 +182,12 @@ module RuboCop
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
-        def message(receiver, argument, method_name)
-          negated = straight?(method_name) ? '' : '!'
-          format(
-            MSG,
-            negated: negated,
-            receiver: receiver,
-            argument: argument,
-            method_name: method_name
-          )
+        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/array_intersect_with_single_element.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `include?(element)` instead of `intersect?([element])`.
+      #
+      # @safety
+      #   The receiver might not be an array.
+      #
+      # @example
+      #   # bad
+      #   array.intersect?([element])
+      #
+      #   # good
+      #   array.include?(element)
+      class ArrayIntersectWithSingleElement < Base
+        extend AutoCorrector
+
+        MSG = 'Use `include?(element)` instead of `intersect?([element])`.'
+
+        RESTRICT_ON_SEND = %i[intersect?].freeze
+
+        # @!method single_element(node)
+        def_node_matcher :single_element, <<~PATTERN
+          (send _ _ $(array $_))
+        PATTERN
+
+        def on_send(node)
+          array, element = single_element(node)
+          return unless array
+
+          add_offense(
+            node.source_range.with(begin_pos: node.loc.selector.begin_pos)
+          ) do |corrector|
+            corrector.replace(node.loc.selector, 'include?')
+            corrector.replace(
+              array,
+              array.percent_literal? ? element.value.inspect : element.source
+            )
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -70,18 +70,25 @@ module RuboCop
             (send _ :& _))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless node.receiver&.begin_type?
           return unless (preferred_method = preferred_method(node))
 
           bit_operation = node.receiver.children.first
           lhs, _operator, rhs = *bit_operation
-          preferred = "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+
+          preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source
+                        "#{rhs.source}.allbits?(#{lhs.source})"
+                      else
+                        "#{lhs.source}.#{preferred_method}(#{rhs.source})"
+                      end
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

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
@@ -208,6 +208,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -347,7 +348,7 @@ module RuboCop
         # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             yield node
           when :send, :csend
             # When a method has an argument which is another method with a block,

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

@@ -269,7 +269,7 @@ module RuboCop
         end
 
         def regexp_with_named_captures?(node)
-          node.regexp_type? && node.each_capture(named: true).count.positive?
+          node.regexp_type? && node.each_capture(named: true).any?
         end
       end
     end

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

@@ -3,14 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
+      # Checks that namespaced classes and modules are defined with a consistent style.
+      #
+      # With `nested` style, classes and modules should be defined separately (one constant
+      # on each line, without `::`). With `compact` style, classes and modules should be
+      # defined with fully qualified names (using `::` for namespaces).
+      #
+      # NOTE: The style chosen will affect `Module.nesting` for the class or module. Using
+      # `nested` style will result in each level being added, whereas `compact` style will
+      # only include the fully qualified class or module name.
+      #
+      # By default, `EnforcedStyle` applies to both classes and modules. If desired, separate
+      # styles can be defined for classes and modules by using `EnforcedStyleForClasses` and
+      # `EnforcedStyleForModules` respectively. If not set, or set to nil, the `EnforcedStyle`
+      # value will be used.
       #
       # @safety
       #   Autocorrection is unsafe.
       #
-      #   Moving from compact to nested children requires knowledge of whether the
-      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   Moving from `compact` to `nested` children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from `nested` to `compact` requires
       #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
@@ -42,16 +54,18 @@ module RuboCop
         def on_class(node)
           return if node.parent_class && style != :nested
 
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_classes)
         end
 
         def on_module(node)
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_modules)
         end
 
         private
 
         def nest_or_compact(corrector, node)
+          style = node.class_type? ? style_for_classes : style_for_modules
+
           if style == :nested
             nest_definition(corrector, node)
           else
@@ -117,21 +131,27 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
+                               body.loc.name.end_pos
+                             else
+                               body.loc.end.begin_pos - leading_spaces(body).size
+                             end
           adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
           range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def unindent(corrector, node)
           return unless node.body.children.last
 
           last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if leading_spaces(node).size == last_child_leading_spaces.size
+          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
 
-          column_delta = configured_indentation_width - last_child_leading_spaces.size
+          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -141,7 +161,17 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def check_style(node, body)
+        def spaces_size(spaces_string)
+          mapping = { "\t" => tab_indentation_width }
+          spaces_string.chars.sum { |character| mapping.fetch(character, 1) }
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+            configured_indentation_width
+        end
+
+        def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
@@ -183,6 +213,14 @@ module RuboCop
         def compact_node_name?(node)
           node.identifier.source.include?('::')
         end
+
+        def style_for_classes
+          cop_config['EnforcedStyleForClasses'] || style
+        end
+
+        def style_for_modules
+          cop_config['EnforcedStyleForModules'] || style
+        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return if def_node &&
                     (allowed_method?(def_node.method_name) ||
                     matches_allowed_pattern?(def_node.method_name))

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

@@ -50,6 +50,7 @@ module RuboCop
           check_method_node(node.send_node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless implicit_block?(node)