rubocop 1.65.1 → 1.75.6

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

@@ -40,7 +40,7 @@ module RuboCop
           traverse_node(node.condition) do |asgn_node|
             next unless asgn_node.loc.operator
 
-            rhs = asgn_node.to_a.last
+            rhs = asgn_node.rhs
             next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
 
             range = offense_range(asgn_node, rhs)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Lint
       # Checks for interpolated literals.
       #
+      # NOTE: Array literals interpolated in regexps are not handled by this cop, but
+      # by `Lint/ArrayLiteralInRegexp` instead.
+      #
       # @example
       #
       #   # bad
@@ -21,6 +24,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
+        # rubocop:disable Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -30,14 +34,23 @@ module RuboCop
           # interpolation should not be removed if the expanded value
           # contains a space character.
           expanded_value = autocorrected_value(final_node)
+          expanded_value = handle_special_regexp_chars(begin_node, 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
+            next if final_node.dstr_type? # nested, fixed in next iteration
+
+            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
+                            final_node.source.delete_prefix('"').delete_suffix('"')
+                          else
+                            expanded_value
+                          end
 
-            corrector.replace(final_node.parent, expanded_value)
+            corrector.replace(final_node.parent, replacement)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -45,8 +58,10 @@ module RuboCop
           node &&
             !special_keyword?(node) &&
             prints_as_self?(node) &&
-            # Special case for Layout/TrailingWhitespace
-            !(space_literal?(node) && ends_heredoc_line?(node))
+            # Special case for `Layout/TrailingWhitespace`
+            !(space_literal?(node) && ends_heredoc_line?(node)) &&
+            # Handled by `Lint/ArrayLiteralInRegexp`
+            !array_in_regexp?(node)
         end
 
         def special_keyword?(node)
@@ -54,6 +69,11 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        def array_in_regexp?(node)
+          grandparent = node.parent.parent
+          node.array_type? && grandparent.regexp_type?
+        end
+
         # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -77,6 +97,27 @@ module RuboCop
         end
         # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
+        def handle_special_regexp_chars(begin_node, value)
+          parent_node = begin_node.parent
+
+          return value unless parent_node.regexp_type? && parent_node.slash_literal? && value['/']
+
+          # When a literal string containing a forward slash preceded by backslashes
+          # is interpolated inside a regexp, the number of resultant backslashes in the
+          # compiled Regexp is `(2(n+1) / 4)+1`, where `n` is the number of backslashes
+          # inside the interpolation.
+          # ie. 0-2 backslashes is compiled to 1, 3-6 is compiled to 3, etc.
+          # This maintains that same behavior in order to ensure the Regexp behavior
+          # does not change upon removing the interpolation.
+          value.gsub(%r{(\\*)/}) do
+            backslashes = Regexp.last_match[1]
+            backslash_count = backslashes.length
+            needed_backslashes = (2 * ((backslash_count + 1) / 4)) + 1
+
+            "#{'\\' * needed_backslashes}/"
+          end
+        end
+
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
             node.children.last.inspect[1..-2]
@@ -145,12 +186,12 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.blank?
+          node.str_type? && node.value.valid_encoding? && node.value.blank?
         end
 
         def ends_heredoc_line?(node)
           grandparent = node.parent.parent
-          return false unless grandparent&.dstr_type? && grandparent&.heredoc?
+          return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
           line.size == node.loc.last_column + 1
@@ -158,10 +199,10 @@ module RuboCop
 
         def in_array_percent_literal?(node)
           parent = node.parent
-          return false unless parent.dstr_type? || parent.dsym_type?
+          return false unless parent.type?(:dstr, :dsym)
 
           grandparent = parent.parent
-          grandparent&.array_type? && grandparent&.percent_literal?
+          grandparent&.array_type? && grandparent.percent_literal?
         end
       end
     end

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

@@ -52,7 +52,7 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, (0..0))
+            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
             add_offense(range, message: message(cop, comment))

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

@@ -97,7 +97,7 @@ module RuboCop
 
         # @!method class_new_block(node)
         def_node_matcher :class_new_block, <<~RUBY
-          ({block numblock}
+          (any_block
             (send
               (const {nil? cbase} :Class) :new $_) ...)
         RUBY
@@ -135,7 +135,7 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          if (block_node = node.each_ancestor(:block, :numblock).first)
+          if (block_node = node.each_ancestor(:any_block).first)
             return false unless (super_class = class_new_block(block_node))
 
             !allowed_class?(super_class)

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

@@ -8,7 +8,7 @@ module RuboCop
       # Offenses are registered for regexp character classes like `/[A-z]/`
       # as well as range objects like `('A'..'z')`.
       #
-      # NOTE: Range objects cannot be autocorrected.
+      # NOTE: `Range` objects cannot be autocorrected.
       #
       # @safety
       #   The cop autocorrects regexp character classes
@@ -36,12 +36,9 @@ module RuboCop
 
         def on_irange(node)
           return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
 
-          range_start, range_end = node.children
-
-          return if range_start.nil? || range_end.nil?
-
-          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
         end
         alias on_erange on_irange
 
@@ -82,7 +79,7 @@ module RuboCop
         end
 
         def range_pairs(expr)
-          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
         end
 
         def unsafe_range?(range_start, range_end)
@@ -97,7 +94,7 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type != :literal
+            bound&.type != :literal
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Do not mix named captures and numbered captures in a Regexp literal
+      # Do not mix named captures and numbered captures in a `Regexp` literal
       # because numbered capture is ignored if they're mixed.
       # Replace numbered captures with non-capturing groupings or
       # named captures.

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

@@ -95,14 +95,14 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
-          return if node.defs_type? && subject.variable?
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
 
-          def_ancestor = node.each_ancestor(:def, :defs).first
+          def_ancestor = node.each_ancestor(:any_def).first
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -117,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 
@@ -125,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block, :numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end

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

@@ -45,8 +45,8 @@ module RuboCop
             end
           end
         end
-        alias on_or_asgn    on_lvasgn
-        alias on_op_asgn    on_lvasgn
+        alias on_or_asgn on_lvasgn
+        alias on_op_asgn on_lvasgn
       end
     end
   end

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<~PATTERN
-          $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
         def_node_matcher :receiver_and_method_name, <<~PATTERN
-          (send (const nil? $_) $_ ...)
+          (send (const {cbase nil?} $_) $_ ...)
         PATTERN
 
         # @!method force?(node)
@@ -78,6 +78,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless node.receiver&.const_type?
           return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
@@ -95,7 +96,7 @@ module RuboCop
         end
 
         def allowable_use_with_if?(if_node)
-          if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
+          if_node.condition.operator_keyword? || if_node.else_branch
         end
 
         def register_offense(node, exist_node)
@@ -115,6 +116,7 @@ module RuboCop
 
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
+
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 
@@ -134,6 +136,7 @@ module RuboCop
 
           corrector.replace(node.child_nodes.first.loc.name, 'FileUtils')
           corrector.replace(node.loc.selector, replacement_method(node))
+          corrector.insert_before(node.last_argument, 'mode: ') if require_mode_keyword?(node)
         end
 
         def replacement_method(node)
@@ -152,6 +155,12 @@ module RuboCop
           force_method_name?(node) || force_option?(node)
         end
 
+        def require_mode_keyword?(node)
+          return false unless node.receiver.const_name == 'Dir'
+
+          replacement_method(node) == 'mkdir_p' && node.arguments.length == 2
+        end
+
         def force_option?(node)
           node.arguments.any? { |arg| force?(arg) }
         end

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

@@ -59,11 +59,13 @@ module RuboCop
       #
       class NonDeterministicRequireOrder < Base
         extend AutoCorrector
+        extend TargetRubyVersion
 
         MSG = 'Sort files before requiring them.'
 
+        maximum_target_ruby_version 2.7
+
         def on_block(node)
-          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -75,7 +77,6 @@ module RuboCop
         end
 
         def on_numblock(node)
-          return if target_ruby_version >= 3.0
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 
@@ -87,7 +88,6 @@ module RuboCop
         end
 
         def on_block_pass(node)
-          return if target_ruby_version >= 3.0
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 

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

@@ -46,7 +46,7 @@ module RuboCop
         def on_return(return_node)
           return if return_value?(return_node)
 
-          return_node.each_ancestor(:block, :def, :defs) do |node|
+          return_node.each_ancestor(:any_block, :any_def) do |node|
             break if scoped_node?(node)
 
             # if a proc is passed to `Module#define_method` or
@@ -54,7 +54,7 @@ module RuboCop
             # non-local exit error
             break if define_method?(node.send_node)
 
-            next unless node.arguments?
+            next if node.argument_list.empty?
 
             if chained_send?(node.send_node)
               add_offense(return_node.loc.keyword)
@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         def return_value?(return_node)

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

@@ -74,7 +74,6 @@ module RuboCop
         extend AutoCorrector
         include AllowedMethods
         include AllowedPattern
-        include IgnoredNode
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",

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

@@ -33,8 +33,7 @@ module RuboCop
         NUMBERED_PARAMETER_RANGE = (1..9).freeze
 
         def on_lvasgn(node)
-          lhs, _rhs = *node
-          return unless /\A_(\d+)\z/ =~ lhs
+          return unless /\A_(\d+)\z/ =~ node.name
 
           number = Regexp.last_match(1).to_i
           template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have a constant result, usually 0 or 1.
+      # Multiplying a number by 0 will always return 0.
+      # Dividing a number by itself or raising it to the power of 0 will always return 1.
+      # As such, they can be replaced with that result.
+      # These are probably leftover from debugging, or are mistakes.
+      # Other numeric operations that are similarly leftover from debugging or mistakes
+      # are handled by `Lint/UselessNumericOperation`.
+      #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
+      # a numeric operation.
+      #
+      # @example
+      #
+      #   # bad
+      #   x * 0
+      #
+      #   # good
+      #   0
+      #
+      #   # bad
+      #   x *= 0
+      #
+      #   # good
+      #   x = 0
+      #
+      #   # bad
+      #   x / x
+      #   x ** 0
+      #
+      #   # good
+      #   1
+      #
+      #   # bad
+      #   x /= x
+      #   x **= 0
+      #
+      #   # good
+      #   x = 1
+      #
+      class NumericOperationWithConstantResult < Base
+        extend AutoCorrector
+        MSG = 'Numeric operation with a constant result detected.'
+        RESTRICT_ON_SEND = %i[* / **].freeze
+
+        # @!method operation_with_constant_result?(node)
+        def_node_matcher :operation_with_constant_result?,
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
+
+        # @!method abbreviated_assignment_with_constant_result?(node)
+        def_node_matcher :abbreviated_assignment_with_constant_result?,
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
+
+        def on_send(node)
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, result.to_s)
+          end
+        end
+        alias on_csend on_send
+
+        def on_op_asgn(node)
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{lhs} = #{result}")
+          end
+        end
+
+        private
+
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
+            return 0 if operation == :*
+            return 1 if operation == :**
+          elsif rhs == lhs
+            return 1 if operation == :/
+          end
+          # If we weren't able to find any matches, return false so we can bail out.
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -27,11 +27,10 @@ module RuboCop
         MSG = 'Avoid using or-assignment with constants.'
 
         def on_or_asgn(node)
-          lhs, _rhs = *node
-          return unless lhs&.casgn_type?
+          return unless node.lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
-            next if node.each_ancestor(:def, :defs).any?
+            next if node.each_ancestor(:any_def).any?
 
             corrector.replace(node.loc.operator, '=')
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Looks for references of Regexp captures that are out of range
+      # Looks for references of `Regexp` captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -61,6 +61,7 @@ module RuboCop
             check_regexp(node.receiver)
           end
         end
+        alias after_csend after_send
 
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)
@@ -75,7 +76,7 @@ module RuboCop
         end
 
         def on_nth_ref(node)
-          backref, = *node
+          backref = node.children.first
           return if @valid_ref.nil? || backref <= @valid_ref
 
           message = format(

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

@@ -37,25 +37,20 @@ module RuboCop
         private
 
         def valid_context?(node)
-          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
-            return true
-          end
-          return true if first_argument_block_type?(node.first_argument)
+          return true unless node.arguments.one? && node.first_argument.parenthesized_call?
+          return true if node.first_argument.any_block_type?
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
-        def first_argument_block_type?(first_arg)
-          first_arg.block_type? || first_arg.numblock_type?
-        end
-
         def valid_first_argument?(first_arg)
-          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg)
+          first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
+            compound_range?(first_arg)
         end
 
-        def first_argument_starts_with_left_parenthesis?(node)
-          node.first_argument.source.start_with?('(')
+        def compound_range?(first_arg)
+          first_arg.range_type? && first_arg.parenthesized_call?
         end
 
         def chained_calls?(node)

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

@@ -3,15 +3,18 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `raise` or `fail` statements which are
-      # raising `Exception` class.
+      # Checks for `raise` or `fail` statements which raise `Exception` or
+      # `Exception.new`. Use `StandardError` or a specific exception class instead.
       #
-      # You can specify a module name that will be an implicit namespace
-      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
-      # for namespaced `Exception` when a namespace is omitted. This option can
-      # prevent the false positive by specifying a namespace to be omitted for
-      # `Exception`. Alternatively, make `Exception` a fully qualified class
-      # name with an explicit namespace.
+      # If you have defined your own namespaced `Exception` class, it is possible
+      # to configure the cop to allow it by setting `AllowedImplicitNamespaces` to
+      # an array with the names of the namespaces to allow. By default, this is set to
+      # `['Gem']`, which allows `Gem::Exception` to be raised without an explicit namespace.
+      # If not allowed, a false positive may be registered if `raise Exception` is called
+      # within the namespace.
+      #
+      # Alternatively, use a fully qualified name with `raise`/`fail`
+      # (eg. `raise Namespace::Exception`).
       #
       # @safety
       #   This cop is unsafe because it will change the exception class being
@@ -20,15 +23,31 @@ module RuboCop
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
+      #   raise Exception.new('Error message here')
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #   raise MyError.new, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem'] (default)
+      #   # bad - `Foo` is not an allowed implicit namespace
+      #   module Foo
+      #     def self.foo
+      #       raise Exception # This is qualified to `Foo::Exception`.
+      #     end
+      #   end
       #
-      # @example AllowedImplicitNamespaces: ['Gem']
       #   # good
       #   module Gem
       #     def self.foo
-      #       raise Exception # This exception means `Gem::Exception`.
+      #       raise Exception # This is qualified to `Gem::Exception`.
+      #     end
+      #   end
+      #
+      #   # good
+      #   module Foo
+      #     def self.foo
+      #       raise Foo::Exception
       #     end
       #   end
       class RaiseException < Base

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

@@ -111,7 +111,7 @@ module RuboCop
           range_between(start + begin_pos - 1, start + end_pos)
         end
 
-        # If the list of cops is comma-separated, but without a empty space after the comma,
+        # If the list of cops is comma-separated, but without an empty space after the comma,
         # we should **not** remove the prepending empty space, thus begin_pos += 1
         def range_with_comma_after(comment, start, begin_pos, end_pos)
           begin_pos += 1 if comment.source[end_pos + 1] != ' '

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result: