rubocop 1.75.7 → 1.77.0

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

@@ -451,7 +451,9 @@ module RuboCop
             corrector.remove_preceding(condition.loc.else, condition.loc.else.column - column)
           end
 
-          return unless condition.loc.end && !same_line?(condition.loc.end, condition)
+          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

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

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

@@ -87,7 +87,7 @@ module RuboCop
           true
         end
 
-        def integral(node)
+        def integral?(node)
           mantissa, = node.source.split('e')
           /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
         end
@@ -101,7 +101,7 @@ module RuboCop
           when :engineering
             !engineering?(node)
           when :integral
-            !integral(node)
+            !integral?(node)
           else
             false
           end

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

@@ -9,7 +9,20 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises `KeyError` or returns the explicitly
       # specified default value.
       #
-      # @example
+      # @example DefaultToNil: true (default)
+      #   # bad
+      #   ENV['X']
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X', nil)
+      #   x = ENV.fetch('X', nil)
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      # @example DefaultToNil: false
       #   # bad
       #   ENV['X']
       #   x = ENV['X']
@@ -25,7 +38,8 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITH_NIL = 'Use `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITHOUT_NIL = 'Use `ENV.fetch(%<key>s)` instead of `ENV[%<key>s]`.'
         RESTRICT_ON_SEND = [:[]].freeze
 
         # @!method env_with_bracket?(node)
@@ -37,7 +51,7 @@ module RuboCop
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            message = format(MSG, key: name_node.source)
+            message = format(offense_message, key: name_node.source)
             add_offense(node, message: message) do |corrector|
               corrector.replace(node, new_code(name_node))
             end
@@ -46,6 +60,14 @@ module RuboCop
 
         private
 
+        def default_to_nil?
+          cop_config.fetch('DefaultToNil', true)
+        end
+
+        def offense_message
+          default_to_nil? ? MSG_WITH_NIL : MSG_WITHOUT_NIL
+        end
+
         def allowed_var?(node)
           env_key_node = node.children.last
           env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
@@ -53,12 +75,12 @@ module RuboCop
 
         def used_as_flag?(node)
           return false if node.root?
-          return true if used_if_condition_in_body(node)
+          return true if used_if_condition_in_body?(node)
 
           node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
         end
 
-        def used_if_condition_in_body(node)
+        def used_if_condition_in_body?(node)
           if_node = node.ancestors.find(&:if_type?)
 
           return false unless (condition = if_node&.condition)
@@ -125,7 +147,11 @@ module RuboCop
         end
 
         def new_code(name_node)
-          "ENV.fetch(#{name_node.source}, nil)"
+          if default_to_nil?
+            "ENV.fetch(#{name_node.source}, nil)"
+          else
+            "ENV.fetch(#{name_node.source})"
+          end
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
         def on_send(node)
-          return unless hash_from_array?(node)
+          return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
           # There are several cases:
           # If there is one argument:
@@ -63,11 +63,12 @@ module RuboCop
           # If there is 0 or 2+ arguments:
           #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
           #   ...but don't suggest correction if there is odd number of them (it is a bug)
-          node.arguments.count == 1 ? single_argument(node) : multi_argument(node)
+          node.arguments.one? ? single_argument(node) : multi_argument(node)
         end
 
         private
 
+        # rubocop:disable Metrics/MethodLength
         def single_argument(node)
           first_argument = node.first_argument
           if first_argument.hash_type?
@@ -82,8 +83,11 @@ module RuboCop
               replacement = "(#{replacement})" if requires_parens?(first_argument)
               corrector.replace(node, "#{replacement}.to_h")
             end
+
+            ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def use_zip_method_without_argument?(first_argument)
           return false unless first_argument&.send_type?
@@ -111,7 +115,12 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
+          if node.call_type?
+            return false if node.method?(:[])
+            return true if node.arguments.any? && !node.parenthesized?
+          end
+
+          node.operator_keyword?
         end
 
         def multi_argument(node)

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

@@ -132,12 +132,10 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.type?(:match_pattern, :match_pattern_p)
+          if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select do |node|
-              node.type?(:match_pattern, :match_pattern_p)
-            end
+            condition.each_descendant.select(&:any_match_pattern_type?)
           end
         end
 
@@ -225,8 +223,17 @@ module RuboCop
 
         def too_long_line_based_on_allow_uri?(line)
           if allow_uri?
-            uri_range = find_excessive_uri_range(line)
-            return false if uri_range && allowed_uri_position?(line, uri_range)
+            uri_range = find_excessive_range(line, :uri)
+            return false if uri_range && allowed_position?(line, uri_range)
+          end
+
+          true
+        end
+
+        def too_long_line_based_on_allow_qualified_name?(line)
+          if allow_qualified_name?
+            namespace_range = find_excessive_range(line, :namespace)
+            return false if namespace_range && allowed_position?(line, namespace_range)
           end
 
           true

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

@@ -5,15 +5,28 @@ module RuboCop
     module Style
       # Checks for blocks with one argument where `it` block parameter can be used.
       #
-      # It provides three `EnforcedStyle` options:
+      # It provides four `EnforcedStyle` options:
       #
-      # 1. `only_numbered_parameters` (default) ... Detects only numbered block parameters.
-      # 2. `always` ... Always uses the `it` block parameter.
-      # 3. `disallow` ... Disallows the `it` block parameter.
+      # 1. `allow_single_line` (default) ... Always uses the `it` block parameter in a single line.
+      # 2. `only_numbered_parameters` ... Detects only numbered block parameters.
+      # 3. `always` ... Always uses the `it` block parameter.
+      # 4. `disallow` ... Disallows the `it` block parameter.
       #
-      # A single numbered parameter is detected when `only_numbered_parameters` or `always`.
+      # A single numbered parameter is detected when `allow_single_line`,
+      # `only_numbered_parameters`, or `always`.
       #
-      # @example EnforcedStyle: only_numbered_parameters (default)
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   block do
+      #     do_something(it)
+      #   end
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: only_numbered_parameters
       #   # bad
       #   block { do_something(_1) }
       #
@@ -42,8 +55,9 @@ module RuboCop
         extend TargetRubyVersion
         extend AutoCorrector
 
-        MSG_USE_IT_BLOCK_PARAMETER = 'Use `it` block parameter.'
-        MSG_AVOID_IT_BLOCK_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_USE_IT_PARAMETER = 'Use `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
 
         minimum_target_ruby_version 3.4
 
@@ -57,7 +71,7 @@ module RuboCop
           variables = find_block_variables(node, node.first_argument.source)
 
           variables.each do |variable|
-            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
             end
@@ -71,19 +85,24 @@ module RuboCop
           variables = find_block_variables(node, '_1')
 
           variables.each do |variable|
-            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+            add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.replace(variable, 'it')
             end
           end
         end
 
         def on_itblock(node)
-          return unless style == :disallow
+          case style
+          when :allow_single_line
+            return if node.single_line?
 
-          variables = find_block_variables(node, 'it')
+            add_offense(node, message: MSG_AVOID_IT_PARAMETER_MULTILINE)
+          when :disallow
+            variables = find_block_variables(node, 'it')
 
-          variables.each do |variable|
-            add_offense(variable, message: MSG_AVOID_IT_BLOCK_PARAMETER)
+            variables.each do |variable|
+              add_offense(variable, message: MSG_AVOID_IT_PARAMETER)
+            end
           end
         end
 

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

@@ -45,6 +45,11 @@ module RuboCop
           }
         PATTERN
 
+        # @!method destructuring_argument(node)
+        def_node_matcher :destructuring_argument, <<~PATTERN
+          (args $(mlhs (arg _)+))
+        PATTERN
+
         def self.autocorrect_incompatible_with
           [Layout::SingleLineBlockChain]
         end
@@ -73,6 +78,12 @@ module RuboCop
             corrector.replace(map_dot, to_h.loc.dot.source)
           end
           corrector.replace(map.loc.selector, 'to_h')
+
+          return unless map.parent.block_type?
+
+          if (argument = destructuring_argument(map.parent.arguments))
+            corrector.replace(argument, argument.source[1..-2])
+          end
         end
         # rubocop:enable Metrics/AbcSize
       end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -167,7 +167,7 @@ module RuboCop
           def call_in_match_pattern?(node)
             return false unless (parent = node.parent)
 
-            parent.type?(:match_pattern, :match_pattern_p)
+            parent.any_match_pattern_type?
           end
 
           def hash_literal_in_arguments?(node)
@@ -251,7 +251,7 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return true if last_argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.first&.forwarded_kwrestarg_type?
+            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
           end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity

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

@@ -39,13 +39,21 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Use `%<prefer>s` instead.'
-        GRATER_OPERATORS = %i[> >=].freeze
+        GREATER_OPERATORS = %i[> >=].freeze
         LESS_OPERATORS = %i[< <=].freeze
-        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+        COMPARISON_OPERATORS = (GREATER_OPERATORS + LESS_OPERATORS).to_set.freeze
+
+        # @!method comparison_condition(node, name)
+        def_node_matcher :comparison_condition, <<~PATTERN
+          {
+            (send $_lhs $COMPARISON_OPERATORS $_rhs)
+            (begin (send $_lhs $COMPARISON_OPERATORS $_rhs))
+          }
+        PATTERN
 
         def on_if(node)
-          lhs, operator, rhs = *node.condition
-          return unless COMPARISON_OPERATORS.include?(operator)
+          lhs, operator, rhs = comparison_condition(node.condition)
+          return unless operator
 
           if_branch = node.if_branch
           else_branch = node.else_branch
@@ -63,7 +71,7 @@ module RuboCop
 
         def preferred_method(operator, lhs, rhs, if_branch, else_branch)
           if lhs == if_branch && rhs == else_branch
-            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+            GREATER_OPERATORS.include?(operator) ? 'max' : 'min'
           elsif lhs == else_branch && rhs == if_branch
             LESS_OPERATORS.include?(operator) ? 'max' : 'min'
           end