rubocop 1.75.8 → 1.81.7

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/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,7 +96,7 @@ 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
 

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

@@ -144,7 +144,7 @@ module RuboCop
         MSG_REQUIRE_ALWAYS = 'Use endless method definitions.'
 
         def on_def(node)
-          return if node.assignment_method?
+          return if node.assignment_method? || use_heredoc?(node)
 
           case style
           when :allow_single_line, :allow_always
@@ -198,6 +198,13 @@ module RuboCop
           add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
 
+        def use_heredoc?(node)
+          return false unless (body = node.body)
+          return true if body.str_type? && body.heredoc?
+
+          body.each_descendant(:str).any?(&:heredoc?)
+        end
+
         def correct_to_multiline(corrector, node)
           replacement = <<~RUBY.strip
             def #{node.method_name}#{arguments(node)}
@@ -225,7 +232,13 @@ module RuboCop
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 
-          endless_replacement(node).length > config.for_cop('Layout/LineLength')['Max']
+          offset = modifier_offset(node)
+
+          endless_replacement(node).length + offset > config.for_cop('Layout/LineLength')['Max']
+        end
+
+        def modifier_offset(node)
+          same_line?(node.parent, node) ? node.loc.column - node.parent.loc.column : 0
         end
       end
     end

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

@@ -56,7 +56,7 @@ module RuboCop
 
         def initialize(config = nil, options = nil)
           super
-          @def_nodes = Set.new
+          @def_nodes = Set.new.compare_by_identity
         end
 
         def on_yield(node)

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

@@ -59,6 +59,7 @@ module RuboCop
       #
       class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
+
         MESSAGES = {
           scientific: 'Use a mantissa >= 1 and < 10.',
           engineering: 'Use an exponent divisible by 3 and a mantissa >= 0.1 and < 1000.',
@@ -87,7 +88,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 +102,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/float_division.rb

@@ -7,9 +7,12 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # For `Regexp.last_match` and nth reference (e.g., `$1`), it assumes that the value
+      # is a string matched by a regular expression, and allows conversion with `#to_f`.
+      #
       # @safety
       #   This cop is unsafe, because if the operand variable is a string object
-      #   then `.to_f` will be removed and an error will occur.
+      #   then `#to_f` will be removed and an error will occur.
       #
       #   [source,ruby]
       #   ----
@@ -84,6 +87,14 @@ module RuboCop
           (send !nil? :to_f)
         PATTERN
 
+        # @!method regexp_last_match?(node)
+        def_node_matcher :regexp_last_match?, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Regexp) :last_match int)
+            (:nth_ref _)
+          }
+        PATTERN
+
         def on_send(node)
           return unless offense_condition?(node)
 
@@ -104,6 +115,9 @@ module RuboCop
         private
 
         def offense_condition?(node)
+          return false if regexp_last_match?(node.receiver.receiver) ||
+                          regexp_last_match?(node.first_argument.receiver)
+
           case style
           when :left_coerce
             right_coerce?(node)

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

@@ -44,17 +44,17 @@ module RuboCop
       class HashConversion < Base
         extend AutoCorrector
 
-        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
-        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
-        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
-        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        MSG_TO_H = 'Prefer `ary.to_h` to `Hash[ary]`.'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to `Hash[arg1, arg2, ...]`.'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to `Hash[key: value, ...]`.'
+        MSG_SPLAT = 'Prefer `array_of_pairs.to_h` to `Hash[*array]`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
         # @!method hash_from_array?(node)
         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,7 +63,8 @@ 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)
+          ignore_node(node)
         end
 
         private
@@ -111,7 +112,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)
@@ -122,7 +128,9 @@ module RuboCop
               corrector.replace(node, args_to_hash(node.arguments))
 
               parent = node.parent
-              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+                add_parentheses(parent, corrector)
+              end
             end
           end
         end

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

@@ -212,7 +212,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.type?(:sym, :dsym)
+          return false unless pair.key.any_sym_type?
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.type?(:while_post, :until_post)
+          if node.post_condition_loop?
             replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
             replace_source(corrector, node.source_range, modifier_replacement(node))

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for usages of not (`not` or `!`) called on a method
+      # Checks for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
       #
       # Methods that can be inverted by a not (`not` or `!`) should be defined

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

@@ -3,33 +3,90 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for assignments to a local `it` variable inside a block
+      # Checks for local variables and method parameters named `it`,
       # where `it` can refer to the first anonymous parameter as of Ruby 3.4.
+      # Use a meaningful variable name instead.
       #
-      # Although Ruby allows reassigning `it` in these cases, it could
+      # NOTE: Although Ruby allows reassigning `it` in these cases, it could
       # cause confusion if `it` is used as a block parameter elsewhere.
-      # For consistency, this also applies to numblocks and blocks with
-      # parameters, even though `it` cannot be used in those cases.
       #
       # @example
       #   # bad
-      #   foo { it = 5 }
-      #   foo { |bar| it = bar }
-      #   foo { it = _2 }
+      #   it = 5
       #
-      #   # good - use a different variable name
-      #   foo { var = 5 }
-      #   foo { |bar| var = bar }
-      #   foo { bar = _2 }
+      #   # good
+      #   var = 5
+      #
+      #   # bad
+      #   def foo(it)
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #   end
+      #
+      #   # bad
+      #   def foo(it = 5)
+      #   end
+      #
+      #   # good
+      #   def foo(arg = 5)
+      #   end
+      #
+      #   # bad
+      #   def foo(*it)
+      #   end
+      #
+      #   # good
+      #   def foo(*args)
+      #   end
+      #
+      #   # bad
+      #   def foo(it:)
+      #   end
+      #
+      #   # good
+      #   def foo(arg:)
+      #   end
+      #
+      #   # bad
+      #   def foo(it: 5)
+      #   end
+      #
+      #   # good
+      #   def foo(arg: 5)
+      #   end
+      #
+      #   # bad
+      #   def foo(**it)
+      #   end
+      #
+      #   # good
+      #   def foo(**kwargs)
+      #   end
+      #
+      #   # bad
+      #   def foo(&it)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #   end
       class ItAssignment < Base
         MSG = '`it` is the default block parameter; consider another name.'
 
         def on_lvasgn(node)
           return unless node.name == :it
-          return unless node.each_ancestor(:any_block).any?
 
           add_offense(node.loc.name)
         end
+        alias on_arg on_lvasgn
+        alias on_optarg on_lvasgn
+        alias on_restarg on_lvasgn
+        alias on_blockarg on_lvasgn
+        alias on_kwarg on_lvasgn
+        alias on_kwoptarg on_lvasgn
+        alias on_kwrestarg on_lvasgn
       end
     end
   end

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,26 +85,33 @@ 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
 
         private
 
         def find_block_variables(node, block_argument_name)
-          node.each_descendant(:lvar).select do |descendant|
+          return [] unless node.body
+
+          node.body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end