rubocop 1.72.1 → 1.81.7

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/combinable_loops.rb

@@ -80,6 +80,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?

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/conditional_assignment.rb

@@ -111,7 +111,7 @@ module RuboCop
         end
       end
 
-      # Check for `if` and `case` statements where each branch is used for
+      # Checks for `if` and `case` statements where each branch is used for
       # both the assignment and comparison of the same variable
       # when using the return of the condition can be used instead.
       #
@@ -314,6 +314,7 @@ module RuboCop
 
         def assignment_node(node)
           assignment = node.send_type? ? node.last_argument : node.expression
+          return unless assignment
 
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
@@ -436,26 +437,41 @@ module RuboCop
       # Helper module to provide common methods to ConditionalAssignment
       # correctors
       module ConditionalCorrectorHelper
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
             next if child.source_range.nil?
+            next if child.parent.dstr_type?
 
             white_space = white_space_range(child, column)
-            corrector.remove(white_space) if white_space.source.strip.empty?
+            corrector.remove(white_space) if white_space
           end
 
-          [condition.loc.else, condition.loc.end].each do |loc|
-            next unless loc
-
-            corrector.remove_preceding(loc, loc.column - column)
+          if condition.loc.else && !same_line?(condition.else_branch, condition)
+            corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
+
+          return unless condition.loc.end && !same_line?(
+            condition.branches.last.parent.else_branch, condition.loc.end
+          )
+
+          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)
         end
 
         def white_space_range(node, column)
           expression = node.source_range
-          begin_pos = expression.begin_pos - (expression.column - column - 2)
+          end_pos = expression.begin_pos
+          begin_pos = end_pos - (expression.column - column - 2)
+
+          return nil if begin_pos > end_pos
 
-          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
+          white_space = Parser::Source::Range.new(expression.source_buffer, begin_pos, end_pos)
+          white_space if white_space.source.strip.empty?
         end
 
         def assignment(node)
@@ -595,6 +611,8 @@ module RuboCop
 
             return unless (branch_else = branch.parent.loc.else)
 
+            return if same_line?(branch_else, condition)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

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

@@ -48,6 +48,11 @@ module RuboCop
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
+        # @!method visibility_declaration_for(node)
+        def_node_matcher :visibility_declaration_for, <<~PATTERN
+          (send nil? {:public_constant :private_constant} $...)
+        PATTERN
+
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
@@ -77,20 +82,20 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
-            visibility_declaration_for?(child, node.name)
-          end
-        end
+            next false unless (arguments = visibility_declaration_for(child))
 
-        # @!method visibility_declaration_for?(node, const_name)
-        def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
-        PATTERN
+            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            constant_values = arguments.map do |argument|
+              argument.value.to_sym if argument.respond_to?(:value)
+            end
 
-        def match_name?(name, constant_name)
-          name.to_sym == constant_name.to_sym
+            constant_values.include?(node.name)
+          end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -25,8 +25,9 @@ module RuboCop
       #   # good
       #   def foo = do_something
       #
-      #   # good (without parentheses it's a syntax error)
+      #   # good - without parentheses it's a syntax error
       #   def foo() do_something end
+      #   def foo()=do_something
       #
       #   # bad
       #   def Baz.foo()
@@ -38,19 +39,31 @@ module RuboCop
       #     do_something
       #   end
       class DefWithParentheses < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
-          return if node.single_line? && !node.endless?
-          return unless !node.arguments? && (node_arguments = node.arguments.source_range)
+          return unless !node.arguments? && (arguments_range = node.arguments.source_range)
+          return if parentheses_required?(node, arguments_range)
 
-          add_offense(node_arguments) do |corrector|
-            corrector.remove(node_arguments)
+          add_offense(arguments_range) do |corrector|
+            corrector.remove(arguments_range)
           end
         end
         alias on_defs on_def
+
+        private
+
+        def parentheses_required?(node, arguments_range)
+          return true if node.single_line? && !node.endless?
+
+          end_pos = arguments_range.end.end_pos
+          token_after_argument = range_between(end_pos, end_pos + 1).source
+
+          token_after_argument == '='
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for chained `dig` calls that can be collapsed into a single `dig`.
+      # Checks for chained `dig` calls that can be collapsed into a single `dig`.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver

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

@@ -96,20 +96,20 @@ module RuboCop
           elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
-            last_child.last_line <= node.last_line
+            last_child.first_line <= node.first_line
           end
         end
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.type?(:def, :defs)
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
         def define_method?(node)
-          return false unless node.block_type?
+          return false unless node.any_block_type?
 
           child = node.child_nodes.first
           return false unless child.send_type?

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for empty strings being assigned inside string interpolation.
+      #
+      # Empty strings are a meaningless outcome inside of string interpolation, so we remove them.
+      # Alternatively, when configured to do so, we prioritise using empty strings.
+      #
+      # While this cop would also apply to variables that are only going to be used as strings,
+      # RuboCop can't detect that, so we only check inside of string interpolation.
+      #
+      # @example EnforcedStyle: trailing_conditional (default)
+      #   # bad
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # good
+      #   "#{'foo' if condition}"
+      #
+      #   # bad
+      #   "#{condition ? '' : 'foo'}"
+      #
+      #   # good
+      #   "#{'foo' unless condition}"
+      #
+      # @example EnforcedStyle: ternary
+      #   # bad
+      #   "#{'foo' if condition}"
+      #
+      #   # good
+      #   "#{condition ? 'foo' : ''}"
+      #
+      #   # bad
+      #   "#{'foo' unless condition}"
+      #
+      #   # good
+      #   "#{condition ? '' : 'foo'}"
+      #
+      class EmptyStringInsideInterpolation < Base
+        include ConfigurableEnforcedStyle
+        include Interpolation
+        extend AutoCorrector
+
+        MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
+        MSG_TERNARY = 'Do not return empty strings in string interpolation.'
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def on_interpolation(node)
+          node.each_child_node(:if) do |child_node|
+            if style == :trailing_conditional
+              if empty_if_outcome?(child_node)
+                ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+              end
+
+              if empty_else_outcome?(child_node)
+                ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+              end
+            elsif style == :ternary
+              next unless child_node.modifier_form?
+
+              ternary_component = if child_node.unless?
+                                    "'' : #{child_node.if_branch.source}"
+                                  else
+                                    "#{child_node.if_branch.source} : ''"
+                                  end
+
+              add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+                corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        private
+
+        def empty_if_outcome?(node)
+          empty_branch_outcome?(node.if_branch)
+        end
+
+        def empty_else_outcome?(node)
+          empty_branch_outcome?(node.else_branch)
+        end
+
+        def empty_branch_outcome?(branch)
+          return false unless branch
+
+          branch.nil_type? || (branch.str_type? && branch.value.empty?)
+        end
+
+        def ternary_style_autocorrect(node, outcome, condition)
+          add_offense(node, message: MSG_TERNARY) do |corrector|
+            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+          end
+        end
+      end
+    end
+  end
+end