rubocop 1.19.0 → 1.40.0

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

@@ -3,18 +3,12 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for ambiguous ranges.
+      # Checks for ambiguous ranges.
       #
-      # Ranges have quite low precedence, which leads to unexpected behaviour when
+      # Ranges have quite low precedence, which leads to unexpected behavior when
       # using a range with other operators. This cop avoids that by making ranges
       # explicit by requiring parenthesis around complex range boundaries (anything
-      # that is not a basic literal: numerics, strings, symbols, etc.).
-      #
-      # NOTE: The cop auto-corrects by wrapping the entire boundary in parentheses, which
-      # makes the outcome more explicit but is possible to not be the intention of the
-      # programmer. For this reason, this cop's auto-correct is marked as unsafe (it
-      # will not change the behaviour of the code, but will not necessarily match the
-      # intent of the program).
+      # that is not a literal: numerics, strings, symbols, etc.).
       #
       # This cop can be configured with `RequireParenthesesForMethodChains` in order to
       # specify whether method chains (including `self.foo`) should be wrapped in parens
@@ -23,6 +17,13 @@ module RuboCop
       # NOTE: Regardless of this configuration, if a method receiver is a basic literal
       # value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
       #
+      # @safety
+      #   The cop autocorrects by wrapping the entire boundary in parentheses, which
+      #   makes the outcome more explicit but is possible to not be the intention of the
+      #   programmer. For this reason, this cop's autocorrect is unsafe (it will not
+      #   change the behavior of the code, but will not necessarily match the
+      #   intent of the program).
+      #
       # @example
       #   # bad
       #   x || 1..2
@@ -55,7 +56,6 @@ module RuboCop
       #
       #   # good
       #   (a.foo)..(b.bar)
-      #
       class AmbiguousRange < Base
         extend AutoCorrector
 
@@ -81,9 +81,9 @@ module RuboCop
 
         def acceptable?(node)
           node.begin_type? ||
-            node.basic_literal? ||
-            node.variable? || node.const_type? ||
-            node.call_type? && acceptable_call?(node)
+            node.literal? ||
+            node.variable? || node.const_type? || node.self_type? ||
+            (node.call_type? && acceptable_call?(node))
         end
 
         def acceptable_call?(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for ambiguous regexp literals in the first argument of
+      # Checks for ambiguous regexp literals in the first argument of
       # a method invocation without parentheses.
       #
       # @example
@@ -30,7 +30,11 @@ module RuboCop
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
-            next unless diagnostic.reason == :ambiguous_literal
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
 
             offense_node = find_offense_node_by(diagnostic)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for assignments in the conditions of
+      # Checks for assignments in the conditions of
       # if/while/until.
       #
       # `AllowSafeAssignment` option for safe assignment.
@@ -11,6 +11,10 @@ module RuboCop
       # an assignment to indicate "I know I'm using an assignment
       # as a condition. It's not a mistake."
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it assumes that
+      #   the author meant to use an assignment result as a condition.
+      #
       # @example
       #   # bad
       #   if some_var = true
@@ -35,6 +39,8 @@ module RuboCop
       #   end
       #
       class AssignmentInCondition < Base
+        extend AutoCorrector
+
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -49,11 +55,15 @@ module RuboCop
         def on_if(node)
           return if node.condition.block_type?
 
-          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+          traverse_node(node.condition) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node.loc.operator)
+            add_offense(asgn_node.loc.operator) do |corrector|
+              next unless safe_assignment_allowed?
+
+              corrector.wrap(asgn_node, '(', ')')
+            end
           end
         end
         alias on_while on_if
@@ -83,13 +93,15 @@ module RuboCop
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end
 
-        # each_node/visit_descendants_with_types with :skip_children
-        def traverse_node(node, types, &block)
-          result = yield node if types.include?(node.type)
+        def traverse_node(node, &block)
+          # if the node is a block, any assignments are irrelevant
+          return if node.block_type?
+
+          result = yield node if ASGN_TYPES.include?(node.type)
 
           return if result == :skip_children
 
-          node.each_child_node { |child| traverse_node(child, types, &block) }
+          node.each_child_node { |child| traverse_node(child, &block) }
         end
       end
     end

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

@@ -3,17 +3,30 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for places where binary operator has identical operands.
+      # Checks for places where binary operator has identical operands.
       #
-      # It covers arithmetic operators: `+`, `-`, `*`, `/`, `%`, `**`;
+      # It covers arithmetic operators: `-`, `/`, `%`;
       # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
-      # bitwise operators: `|`, `^`, `&`, `<<`, `>>`;
+      # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
       # and "spaceship" operator - `<=>`.
       #
-      # This cop is marked as unsafe as it does not consider side effects when calling methods
-      # and thus can generate false positives:
+      # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
+      # Although these can be rewritten in a different way, it should not be necessary to
+      # do so. This does not include operations such as `-` or `/` where the result will
+      # always be the same (`x - x` will always be 0; `x / x` will always be 1), and
+      # thus are legitimate offenses.
+      #
+      # @safety
+      #   This cop is unsafe as it does not consider side effects when calling methods
+      #   and thus can generate false positives, for example:
+      #
+      #   [source,ruby]
+      #   ----
       #   if wr.take_char == '\0' && wr.take_char == '\0'
+      #     # ...
+      #   end
+      #   ----
       #
       # @example
       #   # bad
@@ -24,7 +37,7 @@ module RuboCop
       #     do_something
       #   end
       #
-      #   def childs?
+      #   def child?
       #     left_child || left_child
       #   end
       #

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

@@ -3,9 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `:true` and `:false` symbols.
+      # Checks for `:true` and `:false` symbols.
       # In most cases it would be a typo.
       #
+      # @safety
+      #   Autocorrection is unsafe for this cop because code relying
+      #   on `:true` or `:false` symbols will break when those are
+      #   changed to actual booleans.
+      #
       # @example
       #
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for circular argument references in optional keyword
+      # Checks for circular argument references in optional keyword
       # arguments and optional ordinal arguments.
       #
       # This cop mirrors a warning produced by MRI since 2.2.

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

@@ -92,7 +92,7 @@ module RuboCop
         private
 
         def method_name(node)
-          node.ancestors.find(&:block_type?).send_node.method_name
+          node.ancestors.find(&:block_type?).method_name
         end
       end
     end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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`.
+      # In that case, the result of `rescue` will overwrite `StandardError`.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue => StandardError
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue StandardError
+      #   end
+      #
+      class ConstantOverwrittenInRescue < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`%<constant>s` is overwritten by `rescue =>`.'
+
+        # @!method overwritten_constant(node)
+        def_node_matcher :overwritten_constant, <<~PATTERN
+          (resbody nil? (casgn nil? $_) nil?)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Naming::RescuedExceptionsVariableName, Style::RescueStandardError]
+        end
+
+        def on_resbody(node)
+          return unless (constant = overwritten_constant(node))
+
+          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+            corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,21 +3,31 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # Checks for debug calls (such as `debugger` or `binding.pry`) that should
       # not be kept for production code.
       #
       # The cop can be configured using `DebuggerMethods`. By default, a number of gems
-      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
-      # and `WebConsole`). Additional methods can be added.
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
+      # `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
       #
       # Specific default groups can be disabled if necessary:
       #
       # [source,yaml]
       # ----
       # Lint/Debugger:
-      #   WebConsole: ~
+      #   DebuggerMethods:
+      #     WebConsole: ~
       # ----
       #
+      # You can also add your own methods by adding a new category:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   DebuggerMethods:
+      #     MyDebugger:
+      #       MyDebugger.debug_this
+      # ----
       #
       # @example
       #
@@ -57,21 +67,6 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        RESTRICT_ON_SEND = [].freeze
-
-        # @!method kernel?(node)
-        def_node_matcher :kernel?, <<~PATTERN
-          (const {nil? cbase} :Kernel)
-        PATTERN
-
-        # @!method valid_receiver?(node, arg1)
-        def_node_matcher :valid_receiver?, <<~PATTERN
-          {
-            (const {nil? cbase} %1)
-            (send {nil? #kernel?} %1)
-          }
-        PATTERN
-
         def on_send(node)
           return unless debugger_method?(node)
 
@@ -93,7 +88,7 @@ module RuboCop
 
               *receiver, method_name = v.split('.')
               {
-                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                receiver: receiver.empty? ? nil : receiver.map(&:to_sym),
                 method_name: method_name.to_sym
               }
             end.compact
@@ -107,10 +102,23 @@ module RuboCop
             if method[:receiver].nil?
               send_node.receiver.nil?
             else
-              valid_receiver?(send_node.receiver, method[:receiver])
+              method[:receiver] == receiver_chain(send_node)
             end
           end
         end
+
+        def receiver_chain(send_node)
+          receivers = []
+          receiver = send_node.receiver
+
+          while receiver
+            name = receiver.send_type? ? receiver.method_name : receiver.const_name&.to_sym
+            receivers.unshift(name)
+            receiver = receiver.receiver
+          end
+
+          receivers
+        end
       end
     end
   end

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

@@ -3,25 +3,27 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of the deprecated class method usages.
+      # Checks for uses of the deprecated class method usages.
       #
       # @example
       #
       #   # bad
-      #
       #   File.exists?(some_path)
       #   Dir.exists?(some_path)
       #   iterator?
+      #   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+      #   ENV.clone
+      #   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
       #   Socket.gethostbyname(host)
       #   Socket.gethostbyaddr(host)
       #
-      # @example
-      #
       #   # good
-      #
       #   File.exist?(some_path)
       #   Dir.exist?(some_path)
       #   block_given?
+      #   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+      #   ENV.to_h
+      #   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
       #   Addrinfo.getaddrinfo(nodename, service)
       #   Addrinfo.tcp(host, port).getnameinfo
       class DeprecatedClassMethods < Base
@@ -58,13 +60,13 @@ module RuboCop
           end
 
           def to_s
-            [class_constant, method].compact.join(delimeter)
+            [class_constant, method].compact.join(delimiter)
           end
 
           private
 
-          def delimeter
-            CLASS_METHOD_DELIMETER
+          def delimiter
+            CLASS_METHOD_DELIMITER
           end
         end
 
@@ -81,13 +83,13 @@ module RuboCop
           end
 
           def to_s
-            [class_constant, method].compact.join(delimeter)
+            [class_constant, method].compact.join(delimiter)
           end
 
           private
 
-          def delimeter
-            instance_method? ? INSTANCE_METHOD_DELIMETER : CLASS_METHOD_DELIMETER
+          def delimiter
+            instance_method? ? INSTANCE_METHOD_DELIMITER : CLASS_METHOD_DELIMITER
           end
 
           def instance_method?
@@ -106,6 +108,15 @@ module RuboCop
 
           DeprecatedClassMethod.new(:iterator?) => Replacement.new(:block_given?),
 
+          DeprecatedClassMethod.new(:freeze, class_constant: :ENV) =>
+            Replacement.new(nil, class_constant: :ENV),
+
+          DeprecatedClassMethod.new(:clone, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
+          DeprecatedClassMethod.new(:dup, class_constant: :ENV) =>
+            Replacement.new(:to_h, class_constant: :ENV),
+
           DeprecatedClassMethod.new(:gethostbyaddr, class_constant: :Socket, correctable: false) =>
             Replacement.new(:getnameinfo, class_constant: :Addrinfo, instance_method: true),
 
@@ -115,16 +126,23 @@ module RuboCop
 
         RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.keys.map(&:method).freeze
 
-        CLASS_METHOD_DELIMETER = '.'
-        INSTANCE_METHOD_DELIMETER = '#'
+        CLASS_METHOD_DELIMITER = '.'
+        INSTANCE_METHOD_DELIMITER = '#'
 
         def on_send(node)
           check(node) do |deprecated|
-            message = format(MSG, current: deprecated, prefer: replacement(deprecated))
+            prefer = replacement(deprecated)
+            message = format(MSG, current: deprecated, prefer: prefer)
+            current_method = node.loc.selector
 
-            add_offense(node.loc.selector, message: message) do |corrector|
-              if deprecated.correctable?
-                corrector.replace(node.loc.selector, replacement(deprecated).method)
+            add_offense(current_method, message: message) do |corrector|
+              next unless deprecated.correctable?
+
+              if (preferred_method = prefer.method)
+                corrector.replace(current_method, preferred_method)
+              else
+                corrector.remove(node.loc.dot)
+                corrector.remove(current_method)
               end
             end
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for deprecated constants.
+      # Checks for deprecated constants.
       #
       # It has `DeprecatedConstants` config. If there is an alternative method, you can set
       # alternative value as `Alternative`. And you can set the deprecated version as
@@ -14,7 +14,8 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured.
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
       #
@@ -22,13 +23,19 @@ module RuboCop
       #   NIL
       #   TRUE
       #   FALSE
+      #   Net::HTTPServerException
       #   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+      #   Struct::Group
+      #   Struct::Passwd
       #
       #   # good
       #   nil
       #   true
       #   false
+      #   Net::HTTPClientException
       #   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+      #   Etc::Group
+      #   Etc::Passwd
       #
       class DeprecatedConstants < Base
         extend AutoCorrector
@@ -42,11 +49,12 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
+          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
           version = deprecated_constant['DeprecatedVersion']
+          return if target_ruby_version < version.to_f
 
           add_offense(node, message: message(alternative, node.source, version)) do |corrector|
             corrector.replace(node, alternative)
@@ -56,7 +64,7 @@ module RuboCop
         private
 
         def constant_name(node, nested_constant_name)
-          return nested_constant_name unless node.namespace.const_type?
+          return nested_constant_name.to_s unless node.namespace.const_type?
 
           constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end

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

@@ -55,8 +55,14 @@ module RuboCop
             ...)
         PATTERN
 
+        # @!method digest_const?(node)
+        def_node_matcher :digest_const?, <<~PATTERN
+          (const _ :Digest)
+        PATTERN
+
         def on_send(node)
           return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if digest_const?(node.receiver)
           return unless algorithm_const(node)
 
           message = message(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks constructors for disjunctive assignments that should
+      # Checks constructors for disjunctive assignments (`||=`) that should
       # be plain assignments.
       #
       # So far, this cop is only concerned with disjunctive assignment of
@@ -12,6 +12,29 @@ module RuboCop
       # In ruby, an instance variable is nil until a value is assigned, so the
       # disjunction is unnecessary. A plain assignment has the same effect.
       #
+      # @safety
+      #   This cop is unsafe because it can register a false positive when a
+      #   method is redefined in a subclass that calls super. For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Base
+      #     def initialize
+      #       @config ||= 'base'
+      #     end
+      #   end
+      #
+      #   class Derived < Base
+      #     def initialize
+      #       @config = 'derived'
+      #       super
+      #     end
+      #   end
+      #   ----
+      #
+      #   Without the disjunctive assignment, `Derived` will be unable to override
+      #   the value for `@config`.
+      #
       # @example
       #   # bad
       #   def initialize

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated bodies
+      # Checks that there are no repeated bodies
       # within `if/unless`, `case-when`, `case-in` and `rescue` constructs.
       #
       # With `IgnoreLiteralBranches: true`, branches are not registered

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated conditions
+      # Checks that there are no repeated conditions
       # used in case 'when' expressions.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      # Checks that there are no repeated conditions used in if 'elsif'.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for duplicated keys in hash literals.
+      # Checks for duplicated keys in hash literals.
       #
       # This cop mirrors a warning in Ruby 2.2.
       #