rubocop 1.71.1 → 1.88.2

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

@@ -6,11 +6,19 @@ module RuboCop
       # 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.
+      # when a constant is reassigned in the same file and namespace.
       #
-      # 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 tracks constants defined via `NAME = value` syntax as well as
+      # class/module keyword definitions. It detects reassignment when a constant
+      # is first defined one way and then redefined using the `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when using metaprogramming
+      # (`Module#const_set`).
+      #
+      # By default the cop also cannot detect reassignment across files.
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the cop additionally consults the project-wide index and reports reassignments
+      # whose previous definition lives in another file.
       #
       # 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
@@ -36,6 +44,14 @@ module RuboCop
       #     X = :bar
       #   end
       #
+      #   # bad
+      #   class FooError < StandardError; end
+      #   FooError = Class.new(RuntimeError)
+      #
+      #   # bad
+      #   module M; end
+      #   M = 1
+      #
       #   # good - keep only one assignment
       #   X = :bar
       #
@@ -63,22 +79,44 @@ module RuboCop
       #   end
       #
       class ConstantReassignment < Base
+        include ProjectIndexHelp
+
         MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+        CROSS_FILE_MSG = 'Constant `%<constant>s` is already assigned in `%<path>s`.'
 
         RESTRICT_ON_SEND = %i[remove_const].freeze
 
         # @!method remove_constant(node)
         def_node_matcher :remove_constant, <<~PATTERN
-          (send _ :remove_const
+          (send {nil? self} :remove_const
             ({sym str} $_))
         PATTERN
 
+        def on_class(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :class
+        end
+
+        def on_module(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :module
+        end
+
         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))
+          name = fully_qualified_constant_name(node)
+
+          if constant_definitions.key?(name)
+            add_offense(node, message: format(MSG, constant: constant_display_name(node)))
+            return
+          end
+
+          constant_definitions[name] = :casgn
+          report_cross_file_collision(node, name, constant_display_name(node))
         end
 
         def on_send(node)
@@ -90,7 +128,7 @@ module RuboCop
 
           return if namespaces.none?
 
-          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+          constant_definitions.delete(fully_qualified_name_for(namespaces, constant))
         end
 
         private
@@ -104,7 +142,7 @@ module RuboCop
             return true if ancestor.type?(:module, :class)
 
             ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
-              freeze_method?(ancestor)
+              ancestor.type?(:masgn, :mlhs) || freeze_method?(ancestor)
           end
         end
 
@@ -128,6 +166,10 @@ module RuboCop
           ['', *namespaces, constant].join('::')
         end
 
+        def constant_display_name(node)
+          [*constant_namespaces(node), node.name].join('::')
+        end
+
         def constant_namespaces(node)
           node.each_path.select(&:const_type?).map(&:short_name)
         end
@@ -139,8 +181,48 @@ module RuboCop
             .reverse
         end
 
-        def constant_names
-          @constant_names ||= Set.new
+        def unconditional_definition?(node)
+          node.each_ancestor.all? do |ancestor|
+            ancestor.type?(:begin, :module, :class)
+          end
+        end
+
+        def definition_name(node)
+          identifier = node.identifier
+
+          if identifier.namespace&.cbase_type?
+            fully_qualified_name_for([], identifier.short_name)
+          else
+            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
+            fully_qualified_name_for(namespaces, identifier.short_name)
+          end
+        end
+
+        def identifier_namespaces(identifier)
+          identifier.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def constant_definitions
+          @constant_definitions ||= {}
+        end
+
+        def report_cross_file_collision(node, fully_qualified_name, display_name)
+          return unless project_index
+          return unless (declaration = project_index[fully_qualified_name.delete_prefix('::')])
+          return unless (prior = prior_definition_in_other_file(declaration))
+
+          msg = format(CROSS_FILE_MSG, constant: display_name, path: prior.location.to_file_path)
+
+          add_offense(node, message: msg)
+        end
+
+        def prior_definition_in_other_file(declaration)
+          current = processed_source.file_path
+
+          declaration.definitions.find do |definition|
+            other = definition.location.to_file_path
+            !File.identical?(other, current)
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check that certain constants are fully qualified.
+      # Checks that certain constants are fully qualified.
       #
       # This is not enabled by default because it would mark a lot of offenses
       # unnecessarily.
@@ -13,12 +13,12 @@ module RuboCop
       #
       # Large projects will over time end up with one or two constant names that
       # are problematic because of a conflict with a library or just internally
-      # using the same name a namespace and a class. To avoid too many unnecessary
-      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      # using the same name for a namespace and a class. To avoid too many unnecessary
+      # offenses, enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
-      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # this cop which is disabled by default.
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable this cop which is disabled by default.
       #
       # @example
       #   # By default checks every constant

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`, `todo`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
+        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/data_define_override.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks unexpected overrides of the `Data` built-in methods
+      # via `Data.define`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Data.define(:members, :clone, :to_s)
+      #   b = Bad.new(members: [], clone: true, to_s: 'bad')
+      #   b.members #=> [] (overriding `Data#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.to_s #=> "bad" (overriding `Data#to_s`)
+      #
+      #   # good
+      #   Good = Data.define(:id, :name)
+      #   g = Good.new(id: 1, name: "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<data Good id=1, name="foo">
+      #
+      class DataDefineOverride < Base
+        MSG = '`%<member_name>s` member overrides `Data#%<method_name>s` and it may be unexpected.'
+        RESTRICT_ON_SEND = %i[define].freeze
+
+        # This is based on `Data.define.instance_methods.sort` in Ruby 4.0.0.
+        DATA_METHOD_NAMES = %i[
+          ! != !~ <=> == === __id__ __send__ class clone deconstruct deconstruct_keys
+          define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash
+          inspect instance_eval instance_exec instance_of? instance_variable_defined?
+          instance_variable_get instance_variable_set instance_variables is_a? itself kind_of?
+          members method methods nil? object_id private_methods protected_methods
+          public_method public_methods public_send remove_instance_variable respond_to? send
+          singleton_class singleton_method singleton_methods tap then to_enum to_h to_s with
+          yield_self
+        ].freeze
+        MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        # @!method data_define(node)
+        def_node_matcher :data_define, <<~PATTERN
+          (send
+            (const {nil? cbase} :Data) :define ...)
+        PATTERN
+
+        def on_send(node)
+          return unless data_define(node)
+
+          node.arguments.each do |arg|
+            next unless MEMBER_NAME_TYPES.include?(arg.type)
+
+            member_name = arg.value
+
+            next unless DATA_METHOD_NAMES.include?(member_name.to_sym)
+
+            message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
+            add_offense(arg, message: message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -73,12 +73,12 @@ module RuboCop
       #   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 unless debugger_method?(node) || debugger_require?(node)
           return if assumed_usage_context?(node)
 
-          add_offense(node) if debugger_method?(node) || debugger_require?(node)
+          add_offense(node)
         end
 
         private
@@ -102,11 +102,20 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
-          return false if send_node.parent&.send_type? && send_node.parent.receiver == send_node
+          return false unless debugger_method_names.include?(send_node.method_name)
 
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        # The last segment of each configured debugger method, used to cheaply
+        # rule out the vast majority of `send` nodes before building the
+        # chained method name.
+        def debugger_method_names
+          @debugger_method_names ||= debugger_methods.to_set do |method|
+            method.to_s.split('.').last&.to_sym
+          end
+        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?
@@ -120,7 +129,7 @@ module RuboCop
           return true if assumed_argument?(node)
 
           node.each_ancestor.none? do |ancestor|
-            BLOCK_TYPES.include?(ancestor.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
 

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

@@ -14,7 +14,7 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException`, `Random::DEFAULT`,
       # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
@@ -49,7 +49,7 @@ 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) : node.source
+          constant = node.source.delete_prefix('::')
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -63,12 +63,6 @@ module RuboCop
 
         private
 
-        def constant_name(node, nested_constant_name)
-          return nested_constant_name.to_s unless node.namespace.const_type?
-
-          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
-        end
-
         def message(good, bad, deprecated_version)
           deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
 

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

@@ -118,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
@@ -134,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_match_pattern.rb

@@ -25,17 +25,17 @@ module RuboCop
       #
       #   # bad - repeated alternate patterns with the same conditions don't depend on the order
       #   case x
-      #   in foo | bar
+      #   in 0 | 1
       #     first_method
-      #   in bar | foo
+      #   in 1 | 0
       #     second_method
       #   end
       #
       #   # good
       #   case x
-      #   in foo | bar
+      #   in 0 | 1
       #     first_method
-      #   in bar | baz
+      #   in 2 | 3
       #     second_method
       #   end
       #