rubocop 1.71.1 → 1.92.0

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

@@ -64,27 +64,39 @@ 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)
         def_node_matcher :grep_v_with_nil?, <<~PATTERN
-          (send _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
+          (call _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
         PATTERN
 
         def on_send(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/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)

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer `Enumerable` predicate methods over expressions with `count`.
+      #
+      # The cop checks calls to `count` without arguments, or with a
+      # block. It doesn't register offenses for `count` with a positional
+      # argument because its behavior differs from predicate methods (`count`
+      # matches the argument using `==`, while `any?`, `none?` and `one?` use
+      # `===`).
+      #
+      # NOTE: This cop doesn't check `length` and `size` methods because they
+      # would yield false positives. For example, `String` implements `length`
+      # and `size`, but it doesn't include `Enumerable`.
+      #
+      # @safety
+      #   The cop is unsafe because receiver might not include `Enumerable`, or
+      #   it has nonstandard implementation of `count` or any replacement
+      #   methods.
+      #
+      #   It's also unsafe because for collections with falsey values, expressions
+      #   with `count` without a block return a different result than methods `any?`,
+      #   `none?` and `one?`:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil, false].count.positive?
+      #   [nil].count == 1
+      #   # => true
+      #
+      #   [nil, false].any?
+      #   [nil].one?
+      #   # => false
+      #
+      #   [nil].count == 0
+      #   # => false
+      #
+      #   [nil].none?
+      #   # => true
+      #   ----
+      #
+      #   Autocorrection is unsafe when replacement methods don't iterate over
+      #   every element in collection and the given block runs side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   x.count(&:method_with_side_effects).positive?
+      #   # calls `method_with_side_effects` on every element
+      #
+      #   x.any?(&:method_with_side_effects)
+      #   # calls `method_with_side_effects` until first element returns a truthy value
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   x.count.positive?
+      #   x.count > 0
+      #   x.count != 0
+      #
+      #   x.count(&:foo?).positive?
+      #   x.count { |item| item.foo? }.positive?
+      #
+      #   # good
+      #   x.any?
+      #
+      #   x.any?(&:foo?)
+      #   x.any? { |item| item.foo? }
+      #
+      #   # bad
+      #   x.count.zero?
+      #   x.count == 0
+      #
+      #   # good
+      #   x.none?
+      #
+      #   # bad
+      #   x.count == 1
+      #   x.one?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   x.count > 1
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   x.count > 1
+      #
+      #   # good
+      #   x.many?
+      #
+      class CollectionQuerying < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+
+        RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
+
+        REPLACEMENTS = {
+          [:positive?, nil] => :any?,
+          [:>, 0] => :any?,
+          [:!=, 0] => :any?,
+          [:zero?, nil] => :none?,
+          [:==, 0] => :none?,
+          [:==, 1] => :one?,
+          [:>, 1] => :many?
+        }.freeze
+
+        # @!method count_predicate(node)
+        def_node_matcher :count_predicate, <<~PATTERN
+          (send
+            {
+              (any_block $(call !nil? :count) _ _)
+              $(call !nil? :count (block-pass _)?)
+            }
+            {
+              :positive? |
+              :> (int 0) |
+              :!= (int 0) |
+              :zero? |
+              :== (int 0) |
+              :== (int 1) |
+              :> (int 1)
+            })
+        PATTERN
+
+        def on_send(node)
+          return unless (count_node = count_predicate(node))
+
+          replacement_method = replacement_method(node)
+
+          return unless replacement_supported?(replacement_method)
+
+          offense_range = count_node.loc.selector.join(node.source_range.end)
+          add_offense(offense_range,
+                      message: format(MSG, prefer: replacement_method)) do |corrector|
+            corrector.replace(count_node.loc.selector, replacement_method)
+            corrector.remove(removal_range(node))
+          end
+        end
+
+        private
+
+        def replacement_method(node)
+          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        end
+
+        def replacement_supported?(method_name)
+          return true if active_support_extensions_enabled?
+
+          method_name != :many?
+        end
+
+        def removal_range(node)
+          range = (node.loc.dot || node.loc.selector).join(node.source_range.end)
+
+          range_with_surrounding_space(range, side: :left)
+        end
+      end
+    end
+  end
+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
@@ -22,10 +24,9 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
-        # @!method java_type_node?(node)
-        def_node_matcher :java_type_node?, <<~PATTERN
-          (send
-            (const nil? :Java) _)
+        # @!method java_root?(node)
+        def_node_matcher :java_root?, <<~PATTERN
+          (const nil? :Java)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -35,11 +36,19 @@ module RuboCop
         def on_send(node)
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
+          # ignore Java interop code like `Java::int` or `Java::com::method`
+          return if java_interop?(node)
 
           add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+
+        private
+
+        def java_interop?(node)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver.respond_to?(:receiver) && receiver.receiver
+          java_root?(receiver)
+        end
       end
     end
   end

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

@@ -60,32 +60,34 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine this loop with the previous loop.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
-          return unless same_collection_looping_block?(node, node.left_sibling)
-          return unless node.body && node.left_sibling.body
+          return unless combinable_looping_blocks?(node, node.left_sibling)
 
           add_offense(node) do |corrector|
-            next unless node.arguments == node.left_sibling.arguments
+            next unless combinable_blocks?(node, node.left_sibling)
 
             combine_with_left_sibling(corrector, node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?
           return unless same_collection_looping_for?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            next unless combinable_fors?(node, node.left_sibling)
+
             combine_with_left_sibling(corrector, node)
           end
         end
@@ -105,25 +107,102 @@ module RuboCop
             sibling.send_node.arguments == node.send_node.arguments
         end
 
+        def combinable_looping_blocks?(node, sibling)
+          same_collection_looping_block?(node, sibling) && node.body && sibling.body
+        end
+
         def same_collection_looping_for?(node, sibling)
           sibling&.for_type? && node.collection == sibling.collection
         end
 
+        def combinable_blocks?(node, sibling)
+          return false unless node.arguments == sibling.arguments
+          # Numbered and `it` parameters are implicit, so `arguments` is empty for both.
+          return false unless node.argument_list == sibling.argument_list
+          return false if directive_after_opening?(node)
+
+          !node.body.type?(:rescue, :ensure) && !sibling.body.type?(:rescue, :ensure)
+        end
+
+        # Combining loops with different iteration variables would leave the second
+        # body referencing an undefined variable, so only autocorrect when they match.
+        def combinable_fors?(node, sibling)
+          node.variable == sibling.variable && !directive_after_opening?(node)
+        end
+
+        # The opening is removed, so a directive after it would end up on a line of
+        # its own, where it covers the rest of the file instead of a single line.
+        def directive_after_opening?(node)
+          opening_line = loop_opening(node).line
+          return false if opening_line == node.body.first_line
+
+          comment = processed_source.comment_at_line(opening_line)
+          comment && DirectiveComment.new(comment).start_with_marker?
+        end
+
+        # The block arguments or `{`/`do` of a block, or the `do` or collection of a `for` loop.
+        def loop_opening(node)
+          if node.for_type?
+            node.loc.begin || node.collection.source_range
+          else
+            (node.block_type? && node.arguments.source_range) || node.loc.begin
+          end
+        end
+
         def combine_with_left_sibling(corrector, node)
-          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
-          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+          corrector.remove(closing_with_preceding_space(node.left_sibling, node))
+          corrector.remove(opening_with_following_space(node))
 
           correct_end_of_block(corrector, node)
         end
 
+        # Comments and heredoc bodies before the closing delimiter are kept. When
+        # the next loop starts on the delimiter's line, the line break before the
+        # delimiter is kept too, so that a comment doesn't swallow the next loop.
+        def closing_with_preceding_space(loop, next_loop)
+          separate_lines = !same_line?(loop.loc.end, next_loop)
+
+          range_with_surrounding_space(
+            loop.loc.end, side: :left, newlines: separate_lines, whitespace: separate_lines
+          )
+        end
+
+        # Comments between the opening and the body are kept.
+        def opening_with_following_space(node)
+          opening = node.source_range.begin.join(loop_opening(node))
+
+          range_with_surrounding_space(opening, side: :right, whitespace: true)
+        end
+
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.any_block_type?
+          return if combined_with_right_sibling?(node)
 
-          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          end_of_block = first_combined_block(node).braces? ? '}' : ' end'
           corrector.remove(node.loc.end)
           corrector.insert_before(node.source_range.end, end_of_block)
         end
+
+        def combined_with_right_sibling?(node)
+          sibling = node.right_sibling
+          return false unless sibling&.any_block_type?
+          # A disabled loop isn't corrected, so it doesn't get merged into this one.
+          return false unless enabled_lines?(sibling.source_range)
+
+          same_collection_looping_block?(sibling, node) && sibling.body &&
+            combinable_blocks?(sibling, node)
+        end
+
+        def first_combined_block(node)
+          first = node.left_sibling
+
+          while (previous = first.left_sibling) && enabled_lines?(first.source_range) &&
+                combinable_looping_blocks?(first, previous) && combinable_blocks?(first, previous)
+            first = previous
+          end
+
+          first
+        end
       end
     end
   end

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

@@ -173,7 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
         end
       end
     end

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

@@ -9,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # and RBS::Inline annotation comments are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -57,8 +57,10 @@ module RuboCop
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
-        SUBCLASS_DEFINITION = /\A\s*class\s+\w+\s*<\s*\w+/.freeze
-        METHOD_DEFINITION = /\A\s*def\s/.freeze
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
+
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -86,6 +88,7 @@ module RuboCop
         def offensive?(comment)
           line = source_line(comment)
           return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
 
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
@@ -99,12 +102,16 @@ module RuboCop
           case line
           when SUBCLASS_DEFINITION
             comment.text.start_with?(/#\[.+\]/)
-          when METHOD_DEFINITION
+          when METHOD_OR_END_DEFINITIONS
             comment.text.start_with?('#:')
           else
             false
           end
         end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver may not respond to `between?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value } || value
+          max = max_and_value.find { _1 != value } || value
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -90,7 +90,7 @@ module RuboCop
             max = if_body.source
           end
 
-          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+          prefer = "#{parenthesize_if_needed(else_body)}.clamp(#{min}, #{max})"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             autocorrect(corrector, node, prefer)
@@ -119,6 +119,17 @@ module RuboCop
 
           (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
         end
+
+        # `a + b` must become `(a + b).clamp(low, high)`, not `a + b.clamp(low, high)`
+        # (which parses as `a + (b.clamp(low, high))`).
+        def parenthesize_if_needed(node)
+          if node.type?(:and, :or, :if, :range) || node.assignment? ||
+             (node.send_type? && (node.operator_method? || node.unary_operation?))
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
       end
     end
   end