rubocop 1.79.2 → 1.87.0

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

@@ -10,6 +10,8 @@ module RuboCop
       # * `(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)`.
       #
@@ -51,6 +53,19 @@ module RuboCop
       #   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?
@@ -73,17 +88,33 @@ module RuboCop
         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
+          $(call
             {
               (begin (send $_ :& $_))
-              (call $_ :intersection $_)
+              (call $!nil? :intersection $_)
             }
             $%1
           )
         PATTERN
 
+        # @!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
+
         # @!method any_none_block_intersection(node)
         def_node_matcher :any_none_block_intersection, <<~PATTERN
           {
@@ -104,15 +135,15 @@ module RuboCop
         PATTERN
 
         MSG = 'Use `%<replacement>s` instead of `%<existing>s`.'
-        STRAIGHT_METHODS = %i[present? any?].freeze
-        NEGATED_METHODS = %i[blank? empty? none?].freeze
+        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?(node))
+          return unless (dot_node, receiver, argument, method_name = bad_intersection?(node))
 
-          dot = node.loc.dot.source
+          dot = dot_node.loc.dot.source
           bang = straight?(method_name) ? '' : '!'
           replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
@@ -135,13 +166,16 @@ module RuboCop
         private
 
         def bad_intersection?(node)
-          predicates = if active_support_extensions_enabled?
-                         ACTIVE_SUPPORT_PREDICATES
-                       else
-                         PREDICATES
-                       end
+          bad_intersection_check?(node, bad_intersection_predicates) ||
+            intersection_size_check?(node)
+        end
 
-          bad_intersection_check?(node, predicates)
+        def bad_intersection_predicates
+          if active_support_extensions_enabled?
+            ACTIVE_SUPPORT_PREDICATES
+          else
+            PREDICATES
+          end
         end
 
         def straight?(method_name)

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/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
       #

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

@@ -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

@@ -198,12 +198,13 @@ module RuboCop
         alias on_csend 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
 
@@ -231,9 +232,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.'
@@ -371,17 +370,22 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
+        # rubocop:disable 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)
+
+          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
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
@@ -390,19 +394,6 @@ module RuboCop
           resbody.children.first&.array_type?
         end
 
-        def special_method?(method_name)
-          allowed_method?(method_name) ||
-            matches_allowed_pattern?(method_name) ||
-            braces_required_method?(method_name)
-        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)
-
-          node.braces? if braces_required_method?(method_name)
-        end
-
         def braces_required_method?(method_name)
           braces_required_methods.include?(method_name.to_s)
         end
@@ -420,24 +411,18 @@ 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)
@@ -447,7 +432,11 @@ module RuboCop
         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)
@@ -459,7 +448,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)
@@ -488,7 +481,7 @@ module RuboCop
         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)

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

@@ -3,31 +3,40 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the case equality operator(===).
+      # Checks for uses of the case equality operator (`===`).
+      # The `===` operator has different behavior depending on the
+      # receiver and its use outside of `case`/`when` is confusing.
+      # Prefer more explicit alternatives like `is_a?`, `include?`,
+      # or `match?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
-
+      #
       # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
+      # NOTE: Regexp case equality (`/regexp/ === var`) is allowed because changing it to
+      # `/regexp/.match?(var)` needs to take into account `Regexp.last_match?`, `$~`, `$1`, etc.
+      # This potentially incompatible transformation is handled by `Performance/RegexpMatch` cop.
+      #
       # @example
       #   # bad
       #   (1..100) === 7
-      #   /something/ === some_string
       #
       #   # good
-      #   something.is_a?(Array)
       #   (1..100).include?(7)
-      #   /something/.match?(some_string)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
       #   Array === something
       #
+      #   # good
+      #   something.is_a?(Array)
+      #
       # @example AllowOnConstant: true
       #   # good
       #   Array === something
+      #   something.is_a?(Array)
       #
       # @example AllowOnSelfClass: false (default)
       #   # bad
@@ -51,7 +60,7 @@ module RuboCop
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
-            return if lhs.const_type? && !lhs.module_name?
+            return if lhs.regexp_type? || (lhs.const_type? && !lhs.module_name?)
 
             add_offense(node.loc.selector) do |corrector|
               replacement = replacement(lhs, rhs)
@@ -71,13 +80,6 @@ module RuboCop
 
         def replacement(lhs, rhs)
           case lhs.type
-          when :regexp
-            # The automatic correction from `a === b` to `a.match?(b)` needs to
-            # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
-            # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop/rubocop-performance/issues/152
-            #
-            # So here is noop.
           when :begin
             begin_replacement(lhs, rhs)
           when :const

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

@@ -8,8 +8,8 @@ module RuboCop
       # essentially one-character strings, so this syntax
       # is mostly redundant at this point.
       #
-      # ? character literal can be used to express meta and control character.
-      # That's a good use case of ? literal so it doesn't count it as an offense.
+      # A `?` character literal can be used to express meta and control characters.
+      # That's a good use case of a `?` literal so it doesn't count as an offense.
       #
       # @example
       #   # bad

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

@@ -28,16 +28,24 @@ module RuboCop
       #   manual oversight.
       #
       # @example EnforcedStyle: nested (default)
+      #   # bad
+      #   class Foo::Bar
+      #   end
+      #
       #   # good
-      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
       # @example EnforcedStyle: compact
+      #   # bad
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
       #   # good
-      #   # combine definitions as much as possible
       #   class Foo::Bar
       #   end
       #
@@ -173,6 +181,7 @@ module RuboCop
 
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
+          return unless const_namespace?(node.identifier.namespace)
 
           if style == :nested
             check_nested_style(node)
@@ -181,8 +190,16 @@ module RuboCop
           end
         end
 
+        def const_namespace?(node)
+          return true if node.nil? || node.cbase_type?
+          return false unless node.const_type?
+
+          const_namespace?(node.namespace)
+        end
+
         def check_nested_style(node)
           return unless compact_node_name?(node)
+          return if node.parent&.type?(:class, :module)
 
           add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
             autocorrect(corrector, node)

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

@@ -64,22 +64,34 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (call
-              !nil? {:reject :reject!})
+            (call !nil? {:reject :reject!})
             $(args ...)
-            (call
-              $(lvar _) :nil?))
+            (call $(lvar _) :nil?))
+        PATTERN
+
+        # @!method reject_method_for_numblock_or_itblock?(node)
+        def_node_matcher :reject_method_for_numblock_or_itblock?, <<~PATTERN
+          {
+            (numblock (call !nil? {:reject :reject!}) _ (call (lvar :_1) :nil?))
+            (itblock (call !nil? {:reject :reject!}) _ (call (lvar :it) :nil?))
+          }
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (call
-              !nil? {:select :select! :filter :filter!})
+            (call !nil? {:select :select! :filter :filter!})
             $(args ...)
             (call
-              (call
-                $(lvar _) :nil?) :!))
+              (call $(lvar _) :nil?) :!))
+        PATTERN
+
+        # @!method select_method_for_numblock_or_itblock?(node)
+        def_node_matcher :select_method_for_numblock_or_itblock?, <<~PATTERN
+          {
+            (numblock (call !nil? {:select :select! :filter :filter!}) _ (call (call (lvar :_1) :nil?) :!))
+            (itblock (call !nil? {:select :select! :filter :filter!}) _ (call (call (lvar :it) :nil?) :!))
+          }
         PATTERN
 
         # @!method grep_v_with_nil?(node)
@@ -102,26 +114,34 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def offense_range(node)
           if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
             range(node, node)
           else
             block_node = node.parent
 
-            return unless block_node&.block_type?
-            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
-              return
-            end
-            return unless args.last.source == receiver.source
+            return unless block_node&.any_block_type?
+            return unless match_block_method?(block_node)
 
             range(node, block_node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def match_block_method?(block_node)
+          if block_node.block_type?
+            result = reject_method?(block_node) || select_method?(block_node)
+            return false unless result
+
+            args, receiver = result
+            args.last.source == receiver.source
+          else
+            reject_method_for_numblock_or_itblock?(block_node) ||
+              select_method_for_numblock_or_itblock?(block_node)
+          end
+        end
 
         def to_enum_method?(node)
-          return false unless node.receiver.send_type?
+          return false unless node.receiver.call_type?
 
           TO_ENUM_METHODS.include?(node.receiver.method_name)
         end

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

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Style
       # Checks for methods invoked via the `::` operator instead
-      # of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
+      # of the `.` operator (like `FileUtils::rmdir` instead of
+      # `FileUtils.rmdir`). The `::` operator is conventionally used to
+      # reference constants, so using it for method calls can be misleading.
       #
       # @example
       #   # bad

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

@@ -52,6 +52,8 @@ module RuboCop
 
           add_offense(offense, message: message) do |corrector|
             if use_percent_literal
+              next unless prefer
+
               corrector.replace(offense, prefer)
             else
               corrector.replace(node.loc.selector, 'push')