rubocop 1.57.1 → 1.81.7

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for constant reassignments.
+      #
+      # Emulates Ruby's runtime warning "already initialized constant X"
+      # when a constant is reassigned in the same file and namespace using the
+      # `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when a constant
+      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      #
+      # The cop only takes into account constants assigned in a "simple" way: directly
+      # inside class/module definition, or within another constant. Other type of assignments
+      # (e.g., inside a conditional) are disregarded.
+      #
+      # The cop also tracks constant removal using `Module#remove_const` with symbol
+      # or string argument.
+      #
+      # @example
+      #   # bad
+      #   X = :foo
+      #   X = :bar
+      #
+      #   # bad
+      #   class A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # bad
+      #   module A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # good - keep only one assignment
+      #   X = :bar
+      #
+      #   class A
+      #     X = :bar
+      #   end
+      #
+      #   module A
+      #     X = :bar
+      #   end
+      #
+      #   # good - use OR assignment
+      #   X = :foo
+      #   X ||= :bar
+      #
+      #   # good - use conditional assignment
+      #   X = :foo
+      #   X = :bar unless defined?(X)
+      #
+      #   # good - remove the assigned constant first
+      #   class A
+      #     X = :foo
+      #     remove_const :X
+      #     X = :bar
+      #   end
+      #
+      class ConstantReassignment < Base
+        MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+
+        RESTRICT_ON_SEND = %i[remove_const].freeze
+
+        # @!method remove_constant(node)
+        def_node_matcher :remove_constant, <<~PATTERN
+          (send _ :remove_const
+            ({sym str} $_))
+        PATTERN
+
+        def on_casgn(node)
+          return unless fixed_constant_path?(node)
+          return unless simple_assignment?(node)
+          return if constant_names.add?(fully_qualified_constant_name(node))
+
+          add_offense(node, message: format(MSG, constant: node.name))
+        end
+
+        def on_send(node)
+          constant = remove_constant(node)
+
+          return unless constant
+
+          namespaces = ancestor_namespaces(node)
+
+          return if namespaces.none?
+
+          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+        end
+
+        private
+
+        def fixed_constant_path?(node)
+          node.each_path.all? { |path| path.type?(:cbase, :const, :self) }
+        end
+
+        def simple_assignment?(node)
+          node.ancestors.all? do |ancestor|
+            return true if ancestor.type?(:module, :class)
+
+            ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
+              freeze_method?(ancestor)
+          end
+        end
+
+        def freeze_method?(node)
+          node.send_type? && node.method?(:freeze)
+        end
+
+        def fully_qualified_constant_name(node)
+          if node.absolute?
+            namespace = node.namespace.const_type? ? node.namespace.source : nil
+
+            "#{namespace}::#{node.name}"
+          else
+            constant_namespaces = ancestor_namespaces(node) + constant_namespaces(node)
+
+            fully_qualified_name_for(constant_namespaces, node.name)
+          end
+        end
+
+        def fully_qualified_name_for(namespaces, constant)
+          ['', *namespaces, constant].join('::')
+        end
+
+        def constant_namespaces(node)
+          node.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def ancestor_namespaces(node)
+          node
+            .each_ancestor(:class, :module)
+            .map { |ancestor| ancestor.identifier.short_name }
+            .reverse
+        end
+
+        def constant_names
+          @constant_names ||= Set.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that `# rubocop:enable ...` and `# rubocop:disable ...` statements
+      # are strictly formatted.
+      #
+      # A comment can be added to the directive by prefixing it with `--`.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Layout/LineLength Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:disable
+      #
+      #   # good
+      #   # rubocop:disable all
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #   # rubocop:disable Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:wrongmode Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength comment
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength -- comment
+      #
+      class CopDirectiveSyntax < Base
+        COMMON_MSG = 'Malformed directive comment detected.'
+
+        MISSING_MODE_NAME_MSG = 'The mode name is missing.'
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, or `todo`.'
+        MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
+                                  'Comment in the directive must start with `--`.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive_comment = DirectiveComment.new(comment)
+            next unless directive_comment.start_with_marker?
+            next unless directive_comment.malformed?
+
+            message = offense_message(directive_comment)
+            add_offense(comment, message: message)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def offense_message(directive_comment)
+          comment = directive_comment.comment
+          after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
+          mode = after_marker.split(' ', 2).first
+          additional_msg = if mode.nil?
+                             MISSING_MODE_NAME_MSG
+                           elsif !DirectiveComment::AVAILABLE_MODES.include?(mode)
+                             INVALID_MODE_NAME_MSG
+                           elsif directive_comment.missing_cop_name?
+                             MISSING_COP_NAME_MSG
+                           else
+                             MALFORMED_COP_NAMES_MSG
+                           end
+
+          "#{COMMON_MSG} #{additional_msg}"
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Style/DoubleCopDisableDirective

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)
@@ -39,8 +44,6 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad (ok during development)
       #
       #   # using byebug
@@ -49,8 +52,6 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def some_method
@@ -64,13 +65,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 itblock 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,19 +94,31 @@ module RuboCop
           end
         end
 
-        def debugger_method?(send_node)
-          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+        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)
           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 false unless node.arguments.empty? && node.each_ancestor(:call).any?
           return true if assumed_argument?(node)
 
           node.each_ancestor.none? do |ancestor|
-            ancestor.block_type? || ancestor.numblock_type? || ancestor.lambda_or_proc?
+            ancestor.type?(:any_block, :kwbegin) || ancestor.lambda_or_proc?
           end
         end
 

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

@@ -43,7 +43,7 @@ module RuboCop
           dup: 'to_h',
           exists?: 'exist?',
           gethostbyaddr: 'Addrinfo#getnameinfo',
-          gethostbyname: 'Addrinfo#getaddrinfo',
+          gethostbyname: 'Addrinfo.getaddrinfo',
           iterator?: 'block_given?'
         }.freeze
 
@@ -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/deprecated_open_ssl_constant.rb

@@ -9,28 +9,18 @@ module RuboCop
       #
       # @example
       #
-      #   # Example for OpenSSL::Cipher instantiation.
-      #
       #   # bad
       #   OpenSSL::Cipher::AES.new(128, :GCM)
       #
       #   # good
       #   OpenSSL::Cipher.new('aes-128-gcm')
       #
-      # @example
-      #
-      #   # Example for OpenSSL::Digest instantiation.
-      #
       #   # bad
       #   OpenSSL::Digest::SHA256.new
       #
       #   # good
       #   OpenSSL::Digest.new('SHA256')
       #
-      # @example
-      #
-      #   # Example for ::Digest inherited class methods.
-      #
       #   # bad
       #   OpenSSL::Digest::SHA256.digest('foo')
       #
@@ -43,6 +33,7 @@ module RuboCop
 
         MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
 
+        RESTRICT_ON_SEND = %i[new digest].freeze
         NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
 
         # @!method algorithm_const(node)
@@ -61,7 +52,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return if node.arguments.any? { |arg| arg.variable? || arg.call_type? || arg.const_type? }
           return if digest_const?(node.receiver)
           return unless algorithm_const(node)
 
@@ -127,8 +118,11 @@ module RuboCop
 
         def replacement_args(node)
           algorithm_constant, = algorithm_const(node)
-          algorithm_name = algorithm_name(algorithm_constant)
+          if algorithm_constant.source == 'OpenSSL::Cipher::Cipher'
+            return node.first_argument.source
+          end
 
+          algorithm_name = algorithm_name(algorithm_constant)
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
             build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else
@@ -143,7 +137,7 @@ module RuboCop
           if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
             "'#{algorithm_parts.first}'"
           else
-            mode = 'cbc' unless size_and_mode == ['cbc']
+            mode = 'cbc' if size_and_mode.empty?
 
             "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
           end

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

@@ -15,6 +15,9 @@ module RuboCop
       # With `IgnoreConstantBranches: true`, branches are not registered
       # as offenses if they return a constant value.
       #
+      # With `IgnoreDuplicateElseBranch: true`, in conditionals with multiple branches,
+      # duplicate 'else' branches are not registered as offenses.
+      #
       # @example
       #   # bad
       #   if foo
@@ -83,21 +86,37 @@ module RuboCop
       #   else MEDIUM_SIZE
       #   end
       #
+      # @example IgnoreDuplicateElseBranch: true
+      #   # good
+      #   if foo
+      #     do_foo
+      #   elsif bar
+      #     do_bar
+      #   else
+      #     do_foo
+      #   end
+      #
       class DuplicateBranch < Base
         MSG = 'Duplicate branch body detected.'
 
         def on_branching_statement(node)
-          branches(node).each_with_object(Set.new) do |branch, previous|
-            next unless consider_branch?(branch)
+          branches = branches(node)
+          branches.each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branches, branch)
 
             add_offense(offense_range(branch)) unless previous.add?(branch)
           end
         end
-        alias on_if on_branching_statement
         alias on_case on_branching_statement
         alias on_case_match on_branching_statement
         alias on_rescue on_branching_statement
 
+        def on_if(node)
+          # Ignore 'elsif' nodes, because we don't want to check them separately whether
+          # the 'else' branch is duplicated. We want to check only on the outermost conditional.
+          on_branching_statement(node) unless node.elsif?
+        end
+
         private
 
         def offense_range(duplicate_branch)
@@ -118,10 +137,14 @@ module RuboCop
           node.branches.compact
         end
 
-        def consider_branch?(branch)
+        def consider_branch?(branches, branch)
           return false if ignore_literal_branches? && literal_branch?(branch)
           return false if ignore_constant_branches? && const_branch?(branch)
 
+          if ignore_duplicate_else_branches? && duplicate_else_branch?(branches, branch)
+            return false
+          end
+
           true
         end
 
@@ -133,6 +156,10 @@ module RuboCop
           cop_config.fetch('IgnoreConstantBranches', false)
         end
 
+        def ignore_duplicate_else_branches?
+          cop_config.fetch('IgnoreDuplicateElseBranch', false)
+        end
+
         def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
           return false if !branch.literal? || branch.xstr_type?
           return true if branch.basic_literal?
@@ -147,6 +174,14 @@ module RuboCop
         def const_branch?(branch)
           branch.const_type?
         end
+
+        def duplicate_else_branch?(branches, branch)
+          return false unless (parent = branch.parent)
+
+          branches.size > 2 &&
+            branch.equal?(branches.last) &&
+            parent.respond_to?(:else?) && parent.else?
+        end
       end
     end
   end

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

@@ -9,7 +9,6 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case x
       #   when 'first'
       #     do_something
@@ -17,10 +16,7 @@ module RuboCop
       #     do_something_else
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   case x
       #   when 'first'
       #     do_something
@@ -32,7 +28,7 @@ module RuboCop
 
         def on_case(case_node)
           case_node.when_branches.each_with_object(Set.new) do |when_node, previous|
-            when_node.each_condition do |condition|
+            when_node.conditions.each do |condition|
               add_offense(condition) unless previous.add?(condition)
             end
           end

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

@@ -11,13 +11,9 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   hash = { food: 'apple', food: 'orange' }
       #
-      # @example
-      #
       #   # good
-      #
       #   hash = { food: 'apple', other_food: 'orange' }
       class DuplicateHashKey < Base
         include Duplication

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

@@ -106,7 +106,7 @@ module RuboCop
         private
 
         def pattern_identity(pattern)
-          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+          pattern_source = if pattern.type?(:hash_pattern, :match_alt)
                              pattern.children.map(&:source).sort.to_s
                            else
                              pattern.source