rubocop 1.54.1 → 1.64.1

data/lib/rubocop/cop/layout/space_inside_string_interpolation.rb

@@ -25,8 +25,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space inside string interpolation detected.'
+        MSG = '%<command>s space inside string interpolation.'
 
         def on_interpolation(begin_node)
           return if begin_node.multiline?
@@ -36,9 +35,9 @@ module RuboCop
           return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, MSG)
           else
-            space_offenses(begin_node, left, right, SPACE_MSG)
+            space_offenses(begin_node, left, right, MSG)
           end
         end
 

data/lib/rubocop/cop/layout/trailing_empty_lines.rb

@@ -51,6 +51,7 @@ module RuboCop
           # there could be good reasons why it needs to end with a certain
           # number of newlines.
           return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
 
           whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
@@ -86,6 +87,10 @@ module RuboCop
           extra&.strip&.start_with?('__END__')
         end
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def message(wanted_blank_lines, blank_lines)
           case blank_lines
           when -1

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -17,24 +17,24 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
@@ -50,7 +50,7 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'
-        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
           return if node.condition.block_type?
@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+          (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -6,10 +6,10 @@ module RuboCop
       # Checks for places where binary operator has identical operands.
       #
       # It covers arithmetic operators: `-`, `/`, `%`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
+      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
       # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
-      # and "spaceship" operator - `<=>`.
+      # and "spaceship" operator - ``<=>``.
       #
       # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
       # Although these can be rewritten in a different way, it should not be necessary to

data/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for overwriting an exception with an exception result by use `rescue =>`.
+      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
       #
       # You intended to write as `rescue StandardError`.
       # However, you have written `rescue => StandardError`.

data/lib/rubocop/cop/lint/debugger.rb

@@ -29,6 +29,11 @@ module RuboCop
       #       MyDebugger.debug_this
       # ----
       #
+      # Some gems also ship files that will start a debugging session when required,
+      # for example `require 'debug/start'` from `ruby/debug`. These requires can
+      # be configured through `DebuggerRequires`. It has the same structure as
+      # `DebuggerMethods`, which you can read about above.
+      #
       # @example
       #
       #   # bad (ok during development)
@@ -64,13 +69,20 @@ module RuboCop
       #   def some_method
       #     my_debugger
       #   end
+      #
+      # @example DebuggerRequires: [my_debugger/start]
+      #
+      #   # bad (ok during development)
+      #
+      #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
+        BLOCK_TYPES = %i[block numblock kwbegin].freeze
 
         def on_send(node)
-          return if !debugger_method?(node) || assumed_usage_context?(node)
+          return if assumed_usage_context?(node)
 
-          add_offense(node)
+          add_offense(node) if debugger_method?(node) || debugger_require?(node)
         end
 
         private
@@ -86,17 +98,34 @@ module RuboCop
           end
         end
 
+        def debugger_requires
+          @debugger_requires ||= begin
+            config = cop_config.fetch('DebuggerRequires', [])
+            config.is_a?(Array) ? config : config.values.flatten
+          end
+        end
+
         def debugger_method?(send_node)
           return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
 
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        def debugger_require?(send_node)
+          return false unless send_node.method?(:require) && send_node.arguments.one?
+          return false unless (argument = send_node.first_argument).str_type?
+
+          debugger_requires.include?(argument.value)
+        end
+
         def assumed_usage_context?(node)
           # Basically, debugger methods are not used as a method argument without arguments.
           return false unless node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+          return true if assumed_argument?(node)
 
-          node.each_ancestor.none?(&:lambda_or_proc?)
+          node.each_ancestor.none? do |ancestor|
+            BLOCK_TYPES.include?(ancestor.type) || ancestor.lambda_or_proc?
+          end
         end
 
         def chained_method_name(send_node)
@@ -109,6 +138,12 @@ module RuboCop
           end
           chained_method_name
         end
+
+        def assumed_argument?(node)
+          parent = node.parent
+
+          parent.call_type? || parent.literal? || parent.pair_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -52,7 +52,7 @@ module RuboCop
         # @!method deprecated_class_method?(node)
         def_node_matcher :deprecated_class_method?, <<~PATTERN
           {
-            (send (const {cbase nil?} {:ENV}) {:clone :dup :freeze})
+            (send (const {cbase nil?} :ENV) {:clone :dup :freeze})
             (send (const {cbase nil?} {:File :Dir}) :exists? _)
             (send (const {cbase nil?} :Socket) {:gethostbyaddr :gethostbyname} ...)
             (send nil? :attr _ boolean)

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -253,7 +253,7 @@ module RuboCop
           # Assume that if a method definition is inside any block call which
           # we can't identify, it could be a DSL
           node.each_ancestor(:block).any? do |ancestor|
-            ancestor.method_name != :class_eval && !ancestor.class_constructor?
+            !ancestor.method?(:class_eval) && !ancestor.class_constructor?
           end
         end
 

data/lib/rubocop/cop/lint/empty_block.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # Checks for blocks without a body.
       # Such empty blocks are typically an oversight or we should provide a comment
-      # be clearer what we're aiming for.
+      # to clarify what we're aiming for.
       #
       # Empty lambdas and procs are ignored by default.
       #

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -104,7 +104,7 @@ module RuboCop
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)
 
-          if node.else_branch&.if_type?
+          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
             # Replace an orphaned `elsif` with `if`
             corrector.replace(node.else_branch.loc.keyword, 'if')
           else
@@ -146,7 +146,7 @@ module RuboCop
             node.source_range.with(end_pos: node.condition.source_range.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
-            node.source_range.with(end_pos: if_node.loc.end.end_pos)
+            node.source_range.join(if_node.loc.end.end)
           else
             node.source_range
           end

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -65,17 +65,15 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        MESSAGES = [
-          'Passing safe_level with the 2nd argument of `ERB.new` is ' \
-          'deprecated. Do not use it, and specify other arguments as ' \
-          'keyword arguments.',
-          'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
-          'deprecated. Use keyword argument like ' \
-          '`ERB.new(str, trim_mode: %<arg_value>s)` instead.',
-          'Passing eoutvar with the 4th argument of `ERB.new` is ' \
-          'deprecated. Use keyword argument like ' \
-          '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
-        ].freeze
+        MESSAGE_SAFE_LEVEL = 'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+                             'deprecated. Do not use it, and specify other arguments as ' \
+                             'keyword arguments.'
+        MESSAGE_TRIM_MODE =  'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, trim_mode: %<arg_value>s)` instead.'
+        MESSAGE_EOUTVAR =    'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+                             'deprecated. Use keyword argument like ' \
+                             '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
 
         RESTRICT_ON_SEND = %i[new].freeze
 
@@ -92,10 +90,8 @@ module RuboCop
             arguments[1..3].each_with_index do |argument, i|
               next if !argument || argument.hash_type?
 
-              message = format(MESSAGES[i], arg_value: argument.source)
-
               add_offense(
-                argument.source_range, message: message
+                argument.source_range, message: message(i, argument.source)
               ) do |corrector|
                 autocorrect(corrector, node)
               end
@@ -105,8 +101,19 @@ module RuboCop
 
         private
 
+        def message(positional_argument_index, arg_value)
+          case positional_argument_index
+          when 0
+            MESSAGE_SAFE_LEVEL
+          when 1
+            format(MESSAGE_TRIM_MODE, arg_value: arg_value)
+          when 2
+            format(MESSAGE_EOUTVAR, arg_value: arg_value)
+          end
+        end
+
         def autocorrect(corrector, node)
-          str_arg = node.arguments[0].source
+          str_arg = node.first_argument.source
 
           kwargs = build_kwargs(node)
           overridden_kwargs = override_by_legacy_args(kwargs, node)
@@ -121,11 +128,11 @@ module RuboCop
         end
 
         def build_kwargs(node)
-          return [nil, nil] unless node.arguments.last.hash_type?
+          return [nil, nil] unless node.last_argument.hash_type?
 
           trim_mode_arg, eoutvar_arg = nil
 
-          node.arguments.last.pairs.each do |pair|
+          node.last_argument.pairs.each do |pair|
             case pair.key.source
             when 'trim_mode'
               trim_mode_arg = "trim_mode: #{pair.value.source}"

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -18,6 +18,10 @@ module RuboCop
       #   # good - using BigDecimal
       #   x.to_d == 0.1.to_d
       #
+      #  # good - comparing against zero
+      #   x == 0.0
+      #   x != 0.0
+      #
       #   # good
       #   (x - 0.1).abs < Float::EPSILON
       #
@@ -39,6 +43,8 @@ module RuboCop
 
         def on_send(node)
           lhs, _method, rhs = *node
+          return if literal_zero?(lhs) || literal_zero?(rhs)
+
           add_offense(node) if float?(lhs) || float?(rhs)
         end
 
@@ -59,6 +65,10 @@ module RuboCop
           end
         end
 
+        def literal_zero?(node)
+          node&.numeric_type? && node.value.zero?
+        end
+
         # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?

data/lib/rubocop/cop/lint/hash_compare_by_identity.rb

@@ -35,12 +35,13 @@ module RuboCop
 
         # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
-          (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
+          (call _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN
 
         def on_send(node)
           add_offense(node) if id_as_hash_key?(node)
         end
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/lint/it_without_arguments_in_block.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Emulates the following Ruby warning in Ruby 3.3.
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '0.times { it }'
+      # -e:1: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4;
+      # use it() or self.it
+      # ----
+      #
+      # `it` calls without arguments will refer to the first block param in Ruby 3.4.
+      # So use `it()` or `self.it` to ensure compatibility.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something { it }
+      #
+      #   # good
+      #   do_something { it() }
+      #   do_something { self.it }
+      #
+      class ItWithoutArgumentsInBlock < Base
+        include NodePattern::Macros
+
+        MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
+              'use `it()` or `self.it`.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless (body = node.body)
+          return unless node.arguments.empty_and_without_delimiters?
+
+          if body.send_type? && deprecated_it_method?(body)
+            add_offense(body)
+          else
+            body.each_descendant(:send).each do |send_node|
+              next unless deprecated_it_method?(send_node)
+
+              add_offense(send_node)
+            end
+          end
+        end
+
+        def deprecated_it_method?(node)
+          return false unless node.method?(:it)
+
+          !node.receiver && node.arguments.empty? && !node.parenthesized? && !node.block_literal?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/literal_assignment_in_condition.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.to_a.last
+            next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+
+            range = offense_range(asgn_node, rhs)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if AST::Node::EQUALS_ASSIGNMENTS.include?(node.type)
+
+          node.each_child_node { |child| traverse_node(child, &block) }
+        end
+
+        def all_literals?(node)
+          case node.type
+          when :dstr, :xstr
+            false
+          when :array
+            node.values.all? { |value| all_literals?(value) }
+          when :hash
+            (node.values + node.keys).all? { |item| all_literals?(item) }
+          else
+            node.respond_to?(:literal?) && node.literal?
+          end
+        end
+
+        def parallel_assignment_with_splat_operator?(node)
+          node.array_type? && node.values.first&.splat_type?
+        end
+
+        def offense_range(asgn_node, rhs)
+          asgn_node.loc.operator.join(rhs.source_range.end)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -34,7 +34,7 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
-          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration

data/lib/rubocop/cop/lint/mixed_case_range.rb

@@ -47,8 +47,10 @@ module RuboCop
 
         def on_regexp(node)
           each_unsafe_regexp_range(node) do |loc|
+            next unless (replacement = regexp_range(loc.source))
+
             add_offense(loc) do |corrector|
-              corrector.replace(loc, rewrite_regexp_range(loc.source))
+              corrector.replace(loc, replacement)
             end
           end
         end
@@ -95,14 +97,17 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type == :escape
+            bound.type != :literal
           end
         end
 
-        def rewrite_regexp_range(source)
+        def regexp_range(source)
           open, close = source.split('-')
-          first = [open, range_for(open).end]
-          second = [range_for(close).begin, close]
+          return unless (open_range = range_for(open))
+          return unless (close_range = range_for(close))
+
+          first = [open, open_range.end]
+          second = [close_range.begin, close]
           "#{first.uniq.join('-')}#{second.uniq.join('-')}"
         end
       end

data/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -34,35 +34,20 @@ module RuboCop
             add_offense(void_next) if void_next
           end
         end
-
-        def on_numblock(node)
-          on_numblock_body_of_reduce(node) do |body|
-            void_next = body.each_node(:next).find do |n|
-              n.children.empty? && parent_numblock_node(n) == node
-            end
-
-            add_offense(void_next) if void_next
-          end
-        end
+        alias on_numblock on_block
 
         private
 
         # @!method on_block_body_of_reduce(node)
         def_node_matcher :on_block_body_of_reduce, <<~PATTERN
-          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
-        PATTERN
-
-        # @!method on_numblock_body_of_reduce(node)
-        def_node_matcher :on_numblock_body_of_reduce, <<~PATTERN
-          (numblock (send _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          {
+            (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+            (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          }
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block).first
-        end
-
-        def parent_numblock_node(node)
-          node.each_ancestor(:numblock).first
+          node.each_ancestor(:block, :numblock).first
         end
       end
     end

data/lib/rubocop/cop/lint/non_atomic_file_operation.rb

@@ -43,7 +43,6 @@ module RuboCop
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
-        include Alignment
 
         MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
                                       '`%<receiver>s.%<method_name>s`.'
@@ -51,18 +50,20 @@ module RuboCop
         MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
         MAKE_METHODS = %i[mkdir].freeze
         REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure
-                            delete unlink remove_file rm rmdir safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
-          REMOVE_FORCE_METHODS).freeze
+        REMOVE_METHODS = %i[remove delete unlink remove_file rm rmdir safe_unlink].freeze
+        RECURSIVE_REMOVE_METHODS = %i[remove_dir remove_entry remove_entry_secure].freeze
+        RESTRICT_ON_SEND = (
+          MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS + RECURSIVE_REMOVE_METHODS +
+          REMOVE_FORCE_METHODS
+        ).freeze
 
         # @!method send_exist_node(node)
-        def_node_search :send_exist_node, <<-PATTERN
+        def_node_search :send_exist_node, <<~PATTERN
           $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
-        def_node_matcher :receiver_and_method_name, <<-PATTERN
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 
@@ -140,6 +141,8 @@ module RuboCop
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
             'rm_f'
+          elsif RECURSIVE_REMOVE_METHODS.include?(node.method_name)
+            'rm_rf'
           else
             node.method_name
           end

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -94,7 +94,7 @@ module RuboCop
           parent_node = node.parent
 
           add_offense(parent_node) do |corrector|
-            if parent_node.arguments.last&.block_pass_type?
+            if parent_node.last_argument&.block_pass_type?
               correct_block_pass(corrector, parent_node)
             else
               correct_block(corrector, parent_node)
@@ -116,7 +116,7 @@ module RuboCop
 
         def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            block_arg = node.arguments.last
+            block_arg = node.last_argument
 
             corrector.remove(last_arg_range(node))
             corrector.insert_after(node, ".sort.each(#{block_arg.source})")
@@ -130,9 +130,7 @@ module RuboCop
         # @return [Parser::Source::Range]
         #
         def last_arg_range(node)
-          node.arguments.last.source_range.with(
-            begin_pos: node.arguments[-2].source_range.end_pos
-          )
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
         end
 
         def unsorted_dir_loop?(node)