rubocop 1.71.1 → 1.92.0

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,15 @@ 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.
+      #
+      # NOTE: In the block form, `include?` is only detected when its receiver is
+      # an array literal, because `include?` is defined with different semantics
+      # on many non-array classes (e.g. `String#include?` checks for substrings).
+      # `member?` does not have this restriction.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -30,8 +45,30 @@ 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| [1, 2].include?(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)
@@ -53,50 +90,103 @@ 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 $!nil? ${:member? :include?} (lvar _key))
+            )
+            (numblock
+              (call $_receiver ${:any? :none?}) 1
+              (send $!nil? ${:member? :include?} (lvar :_1))
+            )
+            (itblock
+              (call $_receiver ${:any? :none?}) :it
+              (send $!nil? ${:member? :include?} (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) ? '' : '!'
+          # `a&.intersection(b)&.none?` returns `nil` when `a` is `nil`, but the negated
+          # rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return if bang == '!' && dot == '&.'
 
-          add_offense(node, message: message) do |corrector|
-            bang = straight?(method_name) ? '' : '!'
+          replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
-            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
-          end
+          register_offense(node, replacement)
+        end
+        alias on_csend on_send
+
+        def on_block(node)
+          return unless (captures = any_none_block_intersection(node))
+
+          receiver, method_name, argument, block_method = captures
+          return if uncorrectable_block_intersection?(node, method_name, argument, block_method)
+
+          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 +194,23 @@ 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 uncorrectable_block_intersection?(node, method_name, argument, block_method)
+          # `a&.none? { |elem| b.include?(elem) }` returns `nil` when `a` is `nil`,
+          # but the negated rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return true if method_name == :none? && node.send_node.safe_navigation?
+
+          # `include?` is defined with different semantics on many non-array classes
+          # (e.g. `String#include?` checks for substrings), so it is only a reliable
+          # signal of an intersection check when the receiver is an array literal.
+          block_method == :include? && !argument.array_type?
+        end
+
+        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,50 @@
+# 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
+          # `[*foo]` is not a single element: the splat can expand to any number of
+          # elements, so `intersect?([*foo])` is not equivalent to `include?(*foo)`.
+          return if element.splat_type?
+
+          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/array_join.rb

@@ -3,9 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of "*" as a substitute for _join_.
+      # Checks for uses of `*` as a substitute for `Array#join`.
+      # Using `join` is clearer about intent and more readable than
+      # overloading the `*` operator for string conversion.
       #
-      # Not all cases can reliably checked, due to Ruby's dynamic
+      # Not all cases can be reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an
       # array literal or the second is a string literal.
       #

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

@@ -4,8 +4,11 @@ module RuboCop
   module Cop
     module Style
       # Checks for non-ascii (non-English) characters
-      # in comments. You could set an array of allowed non-ascii chars in
-      # `AllowedChars` attribute (copyright notice "©" by default).
+      # in comments. Non-ascii characters can cause issues with
+      # portability and encoding across different environments
+      # and editors. You could set an array of allowed non-ascii
+      # chars in `AllowedChars` attribute (copyright notice "©"
+      # by default).
       #
       # @example
       #   # bad
@@ -49,7 +52,7 @@ module RuboCop
         end
 
         def allowed_non_ascii_chars
-          cop_config['AllowedChars'] || []
+          @allowed_non_ascii_chars ||= (cop_config['AllowedChars'] || []).freeze
         end
       end
     end

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of Module#attr.
+      # Checks for uses of `Module#attr`. The `attr` method has confusing
+      # behavior: with a single argument it creates a reader (like `attr_reader`),
+      # but with a second boolean argument it creates an accessor (deprecated in
+      # Ruby 1.9). Use `attr_reader` or `attr_accessor` to make intent explicit.
       #
       # @example
-      #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+      #   # bad
       #   attr :something, true
       #   attr :one, :two, :three # behaves as attr_reader
       #
@@ -47,10 +50,9 @@ module RuboCop
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 
-          node_expr = node.source_range
-          attr_expr = attr_name.source_range
-
-          remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
+          if setter&.boolean_type?
+            remove = range_between(attr_name.source_range.end_pos, setter.source_range.end_pos)
+          end
 
           corrector.replace(node.loc.selector, replacement_method(node))
           corrector.remove(remove) if remove

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if usage of %() or %Q() matches configuration.
+      # Checks if usage of `%()` or `%Q()` matches configuration.
+      # Consistent use of one style makes the codebase easier
+      # to read.
       #
       # @example EnforcedStyle: bare_percent (default)
       #   # bad
@@ -41,8 +43,7 @@ module RuboCop
 
         def check(node)
           return if node.heredoc?
-          return unless node.loc.respond_to?(:begin)
-          return unless node.loc.begin
+          return unless node.loc?(:begin)
 
           source = node.loc.begin.source
           if requires_percent_q?(source)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for BEGIN blocks.
+      # Checks for `BEGIN` blocks. They are Perl-style constructs that execute
+      # code before the rest of the file is parsed, making the control flow
+      # harder to follow and reason about.
       #
       # @example
       #   # bad

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

@@ -66,17 +66,25 @@ module RuboCop
 
         # @!method bit_operation?(node)
         def_node_matcher :bit_operation?, <<~PATTERN
-          (begin
-            (send _ :& _))
+          {
+            (begin (send _ :& _))
+            (send _ :& _)
+          }
         PATTERN
 
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
-          return unless node.receiver&.begin_type?
+          return unless bit_operation?(node.receiver)
           return unless (preferred_method = preferred_method(node))
 
-          bit_operation = node.receiver.children.first
+          bit_operation = node.receiver.begin_type? ? node.receiver.children.first : node.receiver
           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)

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
+# rubocop:disable-next Metrics/ClassLength
 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
@@ -177,7 +177,7 @@ module RuboCop
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Layout::SpaceBeforeBlockBraces, Style::MethodCallWithArgsParentheses, Style::RedundantBegin]
         end
 
         def on_send(node)
@@ -196,18 +196,22 @@ module RuboCop
           end
         end
         alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         def on_block(node)
-          return if ignored_node?(node)
+          return if part_of_ignored_node?(node)
           return if proper_block_style?(node)
 
           message = message(node)
           add_offense(node.loc.begin, message: message) do |corrector|
             autocorrect(corrector, node)
+            ignore_node(node)
           end
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -230,9 +234,7 @@ module RuboCop
         end
 
         def semantic_message(node)
-          block_begin = node.loc.begin.source
-
-          if block_begin == '{'
+          if node.braces?
             'Prefer `do...end` over `{...}` for procedural blocks.'
           else
             'Prefer `{...}` over `do...end` for functional blocks.'
@@ -292,7 +294,7 @@ module RuboCop
           corrector.replace(b, '{')
           corrector.replace(e, '}')
 
-          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
+          wrap_body_with_begin(corrector, node.body) if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -344,10 +346,10 @@ module RuboCop
           node.respond_to?(:block_node) && node.block_node
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next 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,
@@ -368,38 +370,47 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
-          return special_method_proper_block_style?(node) if special_method?(node.method_name)
+          return true if collection_of_for_loop?(node)
+
+          method_name = node.method_name
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+          return node.braces? if braces_required_method?(method_name)
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
           when :braces_for_chaining then braces_for_chaining_style?(node)
-          when :always_braces       then braces_style?(node)
+          when :always_braces       then node.braces?
           end
         end
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
-          return false unless (resbody = node.each_descendant(:resbody).first)
 
-          resbody.children.first&.array_type?
+          body = node.body
+          return false unless body
+          # `ensure` and a block-level `rescue` are illegal inside `{ }`; only a
+          # bare modifier rescue (`expr rescue expr`) can be written with braces.
+          return true if body.ensure_type?
+          return false unless body.rescue_type?
+
+          !modifier_rescue?(body)
         end
 
-        def special_method?(method_name)
-          allowed_method?(method_name) ||
-            matches_allowed_pattern?(method_name) ||
-            braces_required_method?(method_name)
+        def collection_of_for_loop?(node)
+          node.parent&.for_type? && node.parent.collection == node
         end
 
-        def special_method_proper_block_style?(node)
-          method_name = node.method_name
-          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        def modifier_rescue?(rescue_node)
+          return false if rescue_node.body.nil? || rescue_node.else_branch
+          return false unless rescue_node.resbody_branches.one?
 
-          node.braces? if braces_required_method?(method_name)
+          resbody = rescue_node.resbody_branches.first
+          resbody.exceptions.empty? && resbody.exception_variable.nil?
         end
 
         def braces_required_method?(method_name)
@@ -419,34 +430,41 @@ module RuboCop
 
           if node.braces?
             functional_method?(method_name) || functional_block?(node) ||
-              (procedural_oneliners_may_have_braces? && !node.multiline?)
+              (procedural_oneliners_may_have_braces? && node.single_line?)
           else
             procedural_method?(method_name) || !return_value_used?(node)
           end
         end
 
         def braces_for_chaining_style?(node)
-          block_begin = node.loc.begin.source
-
-          block_begin == if node.multiline?
-                           (node.chained? ? '{' : 'do')
-                         else
-                           '{'
-                         end
-        end
-
-        def braces_style?(node)
-          node.loc.begin.source == '{'
+          if node.multiline?
+            node.chained? ? node.braces? : !node.braces?
+          else
+            node.braces?
+          end
         end
 
         def correction_would_break_code?(node)
-          return false unless node.keywords?
+          return loop_condition?(node) if node.braces?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
+        # A `do` in the condition of `while` or `until` is taken as the start of
+        # the loop body. Inside the body of another block it is unambiguous again.
+        def loop_condition?(node)
+          ancestors = node.each_ancestor.take_while { |ancestor| !ancestor.any_block_type? }
+          [node, *ancestors].each_cons(2).any? do |child, parent|
+            parent.type?(:while, :until) && parent.condition.equal?(child)
+          end
+        end
+
         def functional_method?(method_name)
-          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
+          functional_methods.include?(method_name)
+        end
+
+        def functional_methods
+          @functional_methods ||= cop_config['FunctionalMethods'].to_set(&:to_sym).freeze
         end
 
         def functional_block?(node)
@@ -458,7 +476,11 @@ module RuboCop
         end
 
         def procedural_method?(method_name)
-          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
+          procedural_methods.include?(method_name)
+        end
+
+        def procedural_methods
+          @procedural_methods ||= cop_config['ProceduralMethods'].to_set(&:to_sym).freeze
         end
 
         def return_value_used?(node)
@@ -484,10 +506,20 @@ module RuboCop
           node.type?(:array, :range)
         end
 
+        def wrap_body_with_begin(corrector, body)
+          heredoc_ends = body.each_node(:any_str).select(&:heredoc?).map do |str|
+            str.loc.heredoc_end
+          end
+          body_end = [body.source_range, *heredoc_ends].max_by(&:end_pos)
+
+          corrector.insert_before(body, "begin\n")
+          corrector.insert_after(body_end, "\nend")
+        end
+
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.
-          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+          block_node.each_child_node(:rescue, :ensure).any? && block_node.multiline?
         end
 
         def single_argument_operator_method?(node)
@@ -499,4 +531,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength