rubocop 1.71.1 → 1.91.0

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

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+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 - only the first directive takes effect
+      #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:wrongmode Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength comment
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength -- comment
+      #
+      #   # bad
+      #   # rucocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLenght
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      class CopDirectiveSyntax < Base
+        extend AutoCorrector
+
+        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`, `disable-next`, `enable-next`, `todo`, `todo-next`, `next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength -- the message lists every mode and does not wrap
+        MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MULTIPLE_DIRECTIVES_MSG = 'Only the first directive on a line takes effect. ' \
+                                  'List the cop names in a single directive instead.'
+        MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
+                                  'Comment in the directive must start with `--`.'
+        INVALID_SIGNED_ARGS_MSG = '`push` and `next` arguments must be `+`- or `-`-prefixed ' \
+                                  'cop names, and `pop` takes no arguments.'
+        NEXT_DIRECTIVE_AT_EOL_MSG = 'A `-next` directive must be on its own line, above the ' \
+                                    'statement it applies to.'
+        INVALID_KEYWORD_MSG = 'The directive keyword must be `rubocop`, not `%<keyword>s`.'
+        UNKNOWN_COP_MSG = 'Unknown cop name `%<name>s`%<suggestion>s.'
+
+        # A comment that looks like an attempted directive: any keyword
+        # followed by a colon and a valid mode name.
+        NEAR_MISS_KEYWORD_REGEXP = /
+          \A\#+\s*(?<keyword>[A-Za-z][\w-]*)\s*:\s*
+          (?:#{DirectiveComment::MODES_PATTERN})\b
+        /x.freeze
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive_comment = DirectiveComment.new(comment)
+            if directive_comment.start_with_marker?
+              check_directive(comment, directive_comment)
+            elsif (keyword = near_miss_keyword(comment))
+              message = format("#{COMMON_MSG} #{INVALID_KEYWORD_MSG}", keyword: keyword)
+              add_offense(comment, message: message)
+            end
+          end
+        end
+
+        private
+
+        def check_directive(comment, directive_comment)
+          if (directives = multiple_directives(comment, directive_comment))
+            add_offense(comment, message: "#{COMMON_MSG} #{MULTIPLE_DIRECTIVES_MSG}") do |corrector|
+              merge_directives(corrector, comment, directives)
+            end
+          elsif directive_comment.malformed?
+            add_offense(comment, message: offense_message(directive_comment))
+          elsif misplaced_next_directive?(directive_comment)
+            add_offense(comment, message: NEXT_DIRECTIVE_AT_EOL_MSG)
+          elsif (name = unknown_cop_name(directive_comment))
+            add_offense(comment, message: unknown_cop_message(directive_comment, name))
+          end
+        end
+
+        # Everything after the first directive in a comment is trailing text as
+        # far as the parser is concerned, so a second directive written on the
+        # same line disables nothing at all. A valid `--` reason may mention a
+        # directive as plain text, which should not be treated as another one.
+        def multiple_directives(comment, directive_comment)
+          matches = comment.text.to_enum(:scan, DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+                           .map { Regexp.last_match }
+          matches = filter_reason_matches(matches, directive_comment)
+
+          matches if matches.size > 1
+        end
+
+        def filter_reason_matches(matches, directive_comment)
+          return matches unless directive_comment.reason
+
+          [matches.first, *matches.drop(1).reject { |match| match.post_match.match?(/\S/) }]
+        end
+
+        def merge_directives(corrector, comment, directives)
+          return unless directives_adjacent?(comment, directives)
+          return unless (mode = merged_mode(directives))
+          return unless (cops = merged_cops(directives))
+
+          corrector.replace(comment, "# rubocop:#{mode} #{cops.join(', ')}")
+        end
+
+        # `all` covers every cop already, so folding it into a list of names
+        # would be a rewrite rather than a merge.
+        def merged_cops(directives)
+          cops = directives.flat_map { |match| match[2].to_s.split(',').map(&:strip) }
+          cops = cops.reject(&:empty?).uniq
+          cops unless cops.empty? || cops.include?('all')
+        end
+
+        # Anything written between the directives is a `--` reason or prose,
+        # and merging around it would either move it or drop it.
+        def directives_adjacent?(comment, directives)
+          text = comment.text
+          bounds = directives.map { |match| match.end(0) }
+                             .zip(directives.map { |match| match.begin(0) }[1..] + [text.length])
+          bounds.all? { |from, to| text[from...to].strip.empty? }
+        end
+
+        # `todo` is an alias of `disable`, so those two combine. Anything else
+        # (an `enable` beside a `disable`, or directives of different scopes)
+        # means different things per directive and can't be folded into one.
+        def merged_mode(directives)
+          modes = directives.map { |match| match[1] }.uniq
+          return modes.first if modes.size == 1
+          return modes.first if (modes - %w[disable todo]).empty?
+
+          nil
+        end
+
+        # An EOL next-statement directive is not honored - it must fail
+        # loudly instead of silently doing nothing.
+        def misplaced_next_directive?(directive_comment)
+          next_statement_directive?(directive_comment) &&
+            !processed_source.comment_config.comment_only_line?(directive_comment.line_number)
+        end
+
+        def next_statement_directive?(directive_comment)
+          directive_comment.disable_next? || directive_comment.enable_next? ||
+            directive_comment.next?
+        end
+
+        # rubocop:disable-next 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
+                           elsif directive_comment.invalid_signed_args?
+                             INVALID_SIGNED_ARGS_MSG
+                           else
+                             MALFORMED_COP_NAMES_MSG
+                           end
+
+          "#{COMMON_MSG} #{additional_msg}"
+        end
+
+        def near_miss_keyword(comment)
+          match = comment.text.match(NEAR_MISS_KEYWORD_REGEXP)
+          return unless match
+
+          keyword = match[:keyword]
+          return if keyword == 'rubocop'
+
+          keyword if similar_to_rubocop?(keyword)
+        end
+
+        def similar_to_rubocop?(keyword)
+          return true if keyword.casecmp?('rubocop')
+          # `DidYouMean` is not always available - see `NameSimilarity`.
+          return false unless defined?(DidYouMean::Levenshtein)
+
+          DidYouMean::Levenshtein.distance(keyword.downcase, 'rubocop') <= 2
+        end
+
+        def unknown_cop_name(directive_comment)
+          return if directive_comment.pop? || directive_comment.all_cops?
+
+          registry = directive_comment.cop_registry
+          directive_names(directive_comment).find do |name|
+            next false if registry.department?(name)
+
+            qualified = registry.qualified_cop_name(name, nil, warn: false)
+            !registry.contains_cop_matching?([qualified])
+          end
+        end
+
+        def directive_names(directive_comment)
+          if directive_comment.push? || directive_comment.next?
+            directive_comment.signed_args.values.flatten
+          else
+            directive_comment.raw_cop_names
+          end
+        end
+
+        def unknown_cop_message(directive_comment, name)
+          similar = NameSimilarity.find_similar_name(name, directive_comment.cop_registry.names)
+          suggestion = similar ? " (did you mean `#{similar}`?)" : ''
+          format(UNKNOWN_COP_MSG, name: name, suggestion: suggestion)
+        end
+      end
+    end
+  end
+end

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/deprecated_reference.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to methods and references to constants that are documented
+      # as deprecated with a YARD `@deprecated` tag.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only references that can be resolved without type inference are checked:
+      # constants, method calls without an explicit receiver (or with `self`),
+      # which are looked up in the enclosing class or module and its ancestry,
+      # and calls whose receiver is a constant, which are looked up in that
+      # namespace's singleton class. Calls on arbitrary objects are not checked.
+      #
+      # References made from a definition that is itself deprecated are allowed,
+      # so deprecated implementations can keep calling each other.
+      #
+      # @example
+      #   # Given a deprecated method and constant:
+      #   #
+      #   #   class Api
+      #   #     # @deprecated Use `#new_method` instead.
+      #   #     def old_method
+      #   #     end
+      #   #
+      #   #     # @deprecated
+      #   #     OLD_TIMEOUT = 10
+      #   #   end
+      #
+      #   # bad
+      #   class Client < Api
+      #     def call
+      #       old_method
+      #     end
+      #
+      #     def timeout
+      #       OLD_TIMEOUT
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Client < Api
+      #     def call
+      #       new_method
+      #     end
+      #
+      #     def timeout
+      #       NEW_TIMEOUT
+      #     end
+      #   end
+      #
+      class DeprecatedReference < Base
+        include ProjectIndexHelp
+
+        METHOD_MSG = 'Method `%<name>s` is deprecated%<detail>s'
+        CONSTANT_MSG = 'Constant `%<name>s` is deprecated%<detail>s'
+
+        DEPRECATED_TAG = '@deprecated'
+        DEPRECATION_DETAIL = /#{DEPRECATED_TAG}\s+(.+)/.freeze
+
+        def on_new_investigation
+          @namespace_cache = {}
+          super
+        end
+
+        def on_send(node)
+          return unless project_index
+
+          declaration = method_declaration_for(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(METHOD_MSG, name: node.method_name, detail: detail_for(declaration))
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_const(node)
+          return unless project_index
+          return if node.parent&.defined_module
+
+          declaration = resolve_constant_in_index(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(CONSTANT_MSG, name: node.const_name, detail: detail_for(declaration))
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def method_declaration_for(node)
+          receiver = node.receiver
+
+          if receiver.nil? || receiver.self_type?
+            implicit_receiver_declaration(node)
+          elsif receiver.const_type?
+            const_receiver_declaration(node, receiver)
+          end
+        end
+
+        def implicit_receiver_declaration(node)
+          namespace = enclosing_namespace(node)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          if singleton_context?(node)
+            indexed_singleton_member(namespace, "#{node.method_name}()")
+          else
+            namespace.find_member("#{node.method_name}()")
+          end
+        end
+
+        def const_receiver_declaration(node, receiver)
+          namespace = resolve_constant_in_index(receiver)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          indexed_singleton_member(namespace, "#{node.method_name}()")
+        end
+
+        def enclosing_namespace(node)
+          namespace_node = node.each_ancestor(:class, :module).first
+          return project_index['Object'] unless namespace_node
+
+          @namespace_cache.fetch(namespace_node) do
+            @namespace_cache[namespace_node] = resolve_constant_in_index(namespace_node.identifier)
+          end
+        end
+
+        # Whether an implicit-receiver call runs with the class or module itself
+        # as `self` (directly in a namespace body, in a singleton method, or
+        # inside `class << self`) rather than inside an instance method.
+        def singleton_context?(node)
+          instance_def_seen = false
+
+          node.each_ancestor do |ancestor|
+            case ancestor.type
+            when :defs, :sclass
+              return true
+            when :def
+              instance_def_seen = true
+            when :class, :module
+              return !instance_def_seen
+            end
+          end
+
+          false
+        end
+
+        # Enumerated in a single pass that stops at the first non-deprecated
+        # definition, since materializing every definition of a declaration
+        # that is almost never deprecated dominates the cop's cost.
+        def deprecated?(declaration)
+          any = false
+
+          declaration.definitions.each do |definition|
+            return false unless definition.deprecated?
+
+            any = true
+          end
+
+          any
+        end
+
+        # References from a definition that is itself documented as deprecated
+        # are allowed.
+        def within_deprecated_definition?(node)
+          node.each_ancestor(:any_def, :class, :module).any? do |ancestor|
+            comments = processed_source.ast_with_comments[ancestor]
+            comments.any? { |comment| comment.text.include?(DEPRECATED_TAG) }
+          end
+        end
+
+        def detail_for(declaration)
+          text = deprecation_text(declaration)
+          return '.' if text.nil? || text.empty?
+
+          text.end_with?('.') ? ": #{text}" : ": #{text}."
+        end
+
+        def deprecation_text(declaration)
+          tag_comment = declaration.definitions.to_a.filter_map do |definition|
+            definition.comments.to_a.map(&:string).find { |string| string.include?(DEPRECATED_TAG) }
+          end.first
+
+          tag_comment && tag_comment[DEPRECATION_DETAIL, 1]&.strip
+        end
+      end
+    end
+  end
+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
       #