rubocop 1.81.7 → 1.92.1

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

@@ -15,31 +15,24 @@ module RuboCop
       # would yield false positives. For example, `String` implements `length`
       # and `size`, but it doesn't include `Enumerable`.
       #
+      # When `count` is used without a block, it measures the collection's
+      # size, so the offense is corrected to `empty?` or `!empty?`. The
+      # predicate methods `any?`, `none?` and `one?` test element truthiness
+      # instead and would return different results for collections with falsey
+      # elements (e.g. `[false].count.zero?` is `false`, but `[false].none?`
+      # is `true`). For the same reason, `count == 1` and `count > 1` without
+      # a block are not flagged.
+      #
       # @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
-      #   ----
+      #   Blockless `count` is corrected to `empty?`, which `Enumerable` doesn't
+      #   define. `Range`, `Enumerator` (including lazy ones), `Struct`, `StringIO`
+      #   and any class that just includes `Enumerable` respond to `count` but not
+      #   to `empty?`, so `(1...1).count.zero?` is `true` while `(1...1).empty?`
+      #   raises `NoMethodError`.
       #
       #   Autocorrection is unsafe when replacement methods don't iterate over
       #   every element in collection and the given block runs side effects:
@@ -60,12 +53,14 @@ module RuboCop
       #   x.count > 0
       #   x.count != 0
       #
+      #   # good
+      #   !x.empty?
+      #
+      #   # bad
       #   x.count(&:foo?).positive?
       #   x.count { |item| item.foo? }.positive?
       #
       #   # good
-      #   x.any?
-      #
       #   x.any?(&:foo?)
       #   x.any? { |item| item.foo? }
       #
@@ -74,24 +69,33 @@ module RuboCop
       #   x.count == 0
       #
       #   # good
-      #   x.none?
+      #   x.empty?
       #
       #   # bad
-      #   x.count == 1
-      #   x.one?
+      #   x.count(&:foo?).zero?
+      #   x.count(&:foo?) == 0
+      #
+      #   # good
+      #   x.none?(&:foo?)
+      #
+      #   # bad
+      #   x.count(&:foo?) == 1
+      #
+      #   # good
+      #   x.one?(&:foo?)
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #
       #   # bad
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       #   # good
-      #   x.many?
+      #   x.many?(&:foo?)
       #
       class CollectionQuerying < Base
         include RangeHelp
@@ -102,13 +106,21 @@ module RuboCop
         RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
 
         REPLACEMENTS = {
-          [:positive?, nil] => :any?,
-          [:>, 0] => :any?,
-          [:!=, 0] => :any?,
-          [:zero?, nil] => :none?,
-          [:==, 0] => :none?,
-          [:==, 1] => :one?,
-          [:>, 1] => :many?
+          [:positive?, nil] => 'any?',
+          [:>, 0] => 'any?',
+          [:!=, 0] => 'any?',
+          [:zero?, nil] => 'none?',
+          [:==, 0] => 'none?',
+          [:==, 1] => 'one?',
+          [:>, 1] => 'many?'
+        }.freeze
+
+        NO_BLOCK_REPLACEMENTS = {
+          [:positive?, nil] => '!empty?',
+          [:>, 0] => '!empty?',
+          [:!=, 0] => '!empty?',
+          [:zero?, nil] => 'empty?',
+          [:==, 0] => 'empty?'
         }.freeze
 
         # @!method count_predicate(node)
@@ -132,28 +144,49 @@ module RuboCop
         def on_send(node)
           return unless (count_node = count_predicate(node))
 
-          replacement_method = replacement_method(node)
+          replacement = replacement_method(node, count_node)
 
-          return unless replacement_supported?(replacement_method)
+          return unless replacement_supported?(node, replacement)
 
           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))
+          add_offense(offense_range, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, count_node, replacement)
           end
         end
 
         private
 
-        def replacement_method(node)
-          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        def replacement_method(node, count_node)
+          key = [node.method_name, node.first_argument&.value]
+          return REPLACEMENTS.fetch(key) if block_given_to_count?(count_node)
+
+          NO_BLOCK_REPLACEMENTS[key]
+        end
+
+        def block_given_to_count?(count_node)
+          count_node.parent&.any_block_type? || count_node.last_argument&.block_pass_type?
+        end
+
+        def replacement_supported?(node, replacement)
+          return false unless replacement
+          return false if replacement == 'many?' && !active_support_extensions_enabled?
+
+          !(replacement.start_with?('!') && receiver_of_call?(node))
         end
 
-        def replacement_supported?(method_name)
-          return true if active_support_extensions_enabled?
+        def receiver_of_call?(node)
+          node.parent&.call_type? && node.parent.receiver == node && node.parent.loc.dot
+        end
+
+        def autocorrect(corrector, node, count_node, replacement)
+          if replacement.start_with?('!')
+            corrector.insert_before(count_node, '!')
+            corrector.replace(count_node.loc.selector, 'empty?')
+          else
+            corrector.replace(count_node.loc.selector, replacement)
+          end
 
-          method_name != :many?
+          corrector.remove(removal_range(node))
         end
 
         def removal_range(node)

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,24 +60,26 @@ module RuboCop
       #   end
       #
       class CombinableLoops < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Combine this loop with the previous loop.'
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        def self.autocorrect_incompatible_with
+          [Layout::BlockEndNewline, Layout::RedundantLineBreak]
+        end
+
         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
@@ -85,8 +87,11 @@ module RuboCop
         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
@@ -106,25 +111,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/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

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

@@ -23,6 +23,7 @@ module RuboCop
       #   list.push(qux, quux, corge)
       #
       class ConcatArrayLiterals < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
@@ -30,7 +31,15 @@ module RuboCop
           'Use `push` with elements as arguments without array brackets instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[concat].freeze
 
-        # rubocop:disable Metrics
+        # `Style/MethodCallWithArgsParentheses` removing the parentheses of the `push(...)`
+        # this cop writes in the same pass drops the line continuation a multiline call needs.
+        # `Style/TrailingCommaInArguments` adds a comma after the array literal this cop
+        # replaces with its elements in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::TrailingCommaInArguments]
+        end
+
+        # rubocop:disable-next Metrics
         def on_send(node)
           return if node.arguments.empty?
           return unless node.arguments.all?(&:array_type?)
@@ -52,17 +61,18 @@ module RuboCop
 
           add_offense(offense, message: message) do |corrector|
             if use_percent_literal
-              corrector.replace(offense, prefer)
+              next unless prefer
+
+              rebuild_call(corrector, offense, prefer)
+            elsif node.arguments.any? { |argument| argument.children.empty? }
+              # In-place bracket removal would leave dangling commas (e.g.
+              # `concat([], [b])` -> `push(, b)`), so rebuild the call instead.
+              rebuild_call(corrector, offense, preferred_method(node))
             else
-              corrector.replace(node.loc.selector, 'push')
-              node.arguments.each do |argument|
-                corrector.remove(argument.loc.begin)
-                corrector.remove(argument.loc.end)
-              end
+              remove_brackets(corrector, node)
             end
           end
         end
-        # rubocop:enable Metrics
         alias on_csend on_send
 
         private
@@ -73,7 +83,7 @@ module RuboCop
 
         def preferred_method(node)
           new_arguments =
-            node.arguments.map do |arg|
+            node.arguments.flat_map do |arg|
               if arg.percent_literal?
                 arg.children.map { |child| child.value.inspect }
               else
@@ -89,6 +99,52 @@ module RuboCop
             arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
+
+        def rebuild_call(corrector, offense, replacement)
+          # The comments inside the call would be lost.
+          return if comment_in?(offense)
+
+          corrector.replace(offense, replacement)
+        end
+
+        def comment_in?(range)
+          processed_source.each_comment_in_lines(range.line..range.last_line).any? do |comment|
+            range.contains?(comment.source_range)
+          end
+        end
+
+        def remove_brackets(corrector, node)
+          closing_ranges = node.arguments.map { |argument| closing_bracket_range(node, argument) }
+          # A comment or a heredoc body there can't be moved out of the way.
+          return unless closing_ranges.all? { |range| range.source.match?(/\A[\s,]*\]\z/) }
+
+          replace_selector(corrector, node)
+
+          node.arguments.zip(closing_ranges) do |argument, closing_range|
+            corrector.remove(argument.loc.begin)
+            corrector.remove(closing_range)
+          end
+        end
+
+        # Whatever sits between the last element and the `]` of an array that isn't the
+        # last argument would end up before the following comma (a newline before it is a
+        # syntax error), so it's removed along with the `]`.
+        def closing_bracket_range(node, argument)
+          return argument.loc.end if argument.equal?(node.last_argument)
+
+          range_between(argument.children.last.source_range.end_pos, argument.loc.end.end_pos)
+        end
+
+        def replace_selector(corrector, node)
+          if node.parenthesized? || node.single_line?
+            corrector.replace(node.loc.selector, 'push')
+          else
+            range = node.loc.selector.join(node.first_argument.source_range.begin)
+
+            corrector.replace(range, 'push(')
+            corrector.insert_after(node.last_argument.loc.end, ')')
+          end
+        end
       end
     end
   end

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

@@ -99,10 +99,6 @@ module RuboCop
           end
         end
 
-        def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
-        end
-
         def assignment_rhs_exist?(node)
           parent = node.parent
           return true unless parent
@@ -207,15 +203,14 @@ module RuboCop
       class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Use the return of the conditional for variable assignment and comparison.'
         ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals.'
         VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Layout/LineLength'
         ENABLED = 'Enabled'
-        MAX = 'Max'
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
@@ -228,6 +223,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         ASSIGNMENT_TYPES.each do |type|
           define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
@@ -289,8 +288,12 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
 
-          return unless else_branch
+          # Use the node accessor rather than the raw destructured branch: for
+          # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
+          # else slot, but `else_branch` correctly reports there is no `else` clause.
+          return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
+          return unless safe_to_correct?(node)
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -370,6 +373,7 @@ module RuboCop
           return unless allowed_statements?(branches)
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
+          return unless safe_to_correct?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
@@ -382,6 +386,25 @@ module RuboCop
           end
         end
 
+        # The correction rewrites the conditional structurally, so full AST
+        # equivalence cannot be asserted, but the result must at least reparse
+        # to valid Ruby. Applying the correction to a throwaway buffer here
+        # also exercises the branch-shape handling before an offense is even
+        # reported, so unusual branches that the corrector cannot handle are
+        # left alone instead of crashing or emitting invalid code - the bug
+        # class behind most of this cop's history.
+        def safe_to_correct?(node)
+          correction_parses?(node)
+        rescue StandardError
+          false
+        end
+
+        # `ReparsedEquivalence#correction_parses?` contract: apply the exact
+        # correction this cop would perform.
+        def apply_reparse_correction(corrector, node)
+          autocorrect(corrector, node)
+        end
+
         def allowed_statements?(branches)
           return false unless branches.all?
 
@@ -399,7 +422,7 @@ module RuboCop
         # of the longest line + the length of the corrected assignment is
         # greater than the max configured line length
         def correction_exceeds_line_limit?(node, branches)
-          return false unless line_length_cop_enabled?
+          return false unless config.cop_enabled?('Layout/LineLength')
 
           assignment = lhs(tail(branches[0]))
 
@@ -417,14 +440,6 @@ module RuboCop
           assignment + longest_line
         end
 
-        def line_length_cop_enabled?
-          config.for_cop(LINE_LENGTH)[ENABLED]
-        end
-
-        def max_line_length
-          config.for_cop(LINE_LENGTH)[MAX]
-        end
-
         def single_line_conditions_only?
           cop_config[SINGLE_LINE_CONDITIONS_ONLY]
         end
@@ -437,7 +452,7 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
@@ -457,7 +472,6 @@ module RuboCop
 
           corrector.remove_preceding(condition.loc.end, condition.loc.end.column - column)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def same_line?(node1, node2)
           RuboCop::Cop::Util.same_line?(node1, node2)
@@ -671,6 +685,8 @@ module RuboCop
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
+            return if same_line?(parent_keyword, condition)
+
             corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end