rubocop 1.67.0 → 1.75.6

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

@@ -38,16 +38,12 @@ module RuboCop
 
         def valid_context?(node)
           return true unless node.arguments.one? && node.first_argument.parenthesized_call?
-          return true if first_argument_block_type?(node.first_argument)
+          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) ||
             compound_range?(first_arg)

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:

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

@@ -17,17 +17,12 @@ module RuboCop
       #   * 2.0+ ... `enumerator`
       #   * 2.1+ ... `thread`
       #   * 2.2+ ... Add `rational` and `complex` above
-      #   * 2.5+ ... Add `pp` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
       #   * 3.2+ ... `set`
       #
       # This cop target those features.
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because if `require 'pp'` is removed from one file,
-      #   `NameError` can be encountered when another file uses `PP.pp`.
-      #
       # @example
       #   # bad
       #   require 'unloaded_feature'
@@ -42,10 +37,6 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
         RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
-        PRETTY_PRINT_METHODS = %i[
-          pretty_inspect pretty_print pretty_print_cycle
-          pretty_print_inspect pretty_print_instance_variables
-        ].freeze
 
         # @!method redundant_require_statement?(node)
         def_node_matcher :redundant_require_statement?, <<~PATTERN
@@ -53,11 +44,6 @@ module RuboCop
             (str #redundant_feature?))
         PATTERN
 
-        # @!method pp_const?(node)
-        def_node_matcher :pp_const?, <<~PATTERN
-          (const {nil? cbase} :PP)
-        PATTERN
-
         def on_send(node)
           return unless redundant_require_statement?(node)
 
@@ -81,18 +67,11 @@ module RuboCop
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
-            (target_ruby_version >= 2.5 && feature_name == 'pp' && !need_to_require_pp?) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
             (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        def need_to_require_pp?
-          processed_source.ast.each_descendant(:send).any? do |node|
-            pp_const?(node.receiver) || PRETTY_PRINT_METHODS.include?(node.method_name)
-          end
-        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for redundant safe navigation calls.
       # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
       # and an offense is not detected when the receiver is a constant. The detection also applies
-      # to literal receivers, except for `nil`.
+      # to `self`, and to literal receivers, except for `nil`.
       #
       # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
       # and `equal?` methods are checked by default.
@@ -29,6 +29,9 @@ module RuboCop
       #   # bad
       #   CamelCaseConst&.do_something
       #
+      #   # good
+      #   CamelCaseConst.do_something
+      #
       #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
@@ -41,9 +44,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #   CamelCaseConst.do_something
-      #
-      #   # good
       #   while node.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -67,6 +67,12 @@ module RuboCop
       #   foo.to_f
       #   foo.to_s
       #
+      #   # bad
+      #   self&.foo
+      #
+      #   # good
+      #   self.foo
+      #
       # @example AllowedMethods: [nil_safe_method]
       #   # bad
       #   do_something if attrs&.nil_safe_method(:[])
@@ -133,7 +139,7 @@ module RuboCop
         def assume_receiver_instance_exists?(receiver)
           return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 
-          receiver.literal? && !receiver.nil_type?
+          receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
         def check?(node)
@@ -141,8 +147,7 @@ module RuboCop
           return false unless parent
 
           condition?(parent, node) ||
-            parent.and_type? ||
-            parent.or_type? ||
+            parent.operator_keyword? ||
             (parent.send_type? && parent.negation_method?)
         end