rubocop 1.71.1 → 1.91.0

data/lib/rubocop/server/cache.rb

@@ -2,8 +2,10 @@
 
 require 'digest'
 require 'pathname'
+require 'yaml'
 require_relative '../cache_config'
 require_relative '../config_finder'
+require_relative '../path_util'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -43,64 +45,43 @@ module RuboCop
           @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def restart_key
+        # rubocop:disable-next Metrics/AbcSize
+        def restart_key(args_config_file_path: nil)
           lockfile_path = LOCKFILE_NAMES.map do |lockfile_name|
             Pathname(project_dir).join(lockfile_name)
           end.find(&:exist?)
           version_data = lockfile_path&.read || RuboCop::Version::STRING
-          config_data = Pathname(ConfigFinder.find_config_path(Dir.pwd)).read
-          todo_data = (rubocop_todo = Pathname('.rubocop_todo.yml')).exist? ? rubocop_todo.read : ''
+          config_data = Pathname(
+            args_config_file_path || ConfigFinder.find_config_path(Dir.pwd)
+          ).read
+          yaml = load_erb_templated_yaml(config_data)
 
-          Digest::SHA1.hexdigest(version_data + config_data + todo_data)
+          inherit_from_data = inherit_from_data(yaml)
+          require_data = require_data(yaml)
+
+          Digest::SHA1.hexdigest(version_data + config_data + inherit_from_data + require_data)
         end
-        # rubocop:enable Metrics/AbcSize
 
         def dir
-          Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
+          dir_path.tap do |d|
             d.mkpath unless d.exist?
           end
         end
 
+        def dir_path
+          Pathname.new(File.join(cache_path, project_dir_cache_key))
+        end
+
         def cache_path
           cache_root_dir = if cache_root_path
                              File.join(cache_root_path, 'rubocop_cache')
                            else
-                             cache_root_dir_from_config
+                             CacheConfig.root_dir_from_toplevel_config
                            end
 
           File.expand_path(File.join(cache_root_dir, 'server'))
         end
 
-        # rubocop:disable Metrics/MethodLength
-        def cache_root_dir_from_config
-          CacheConfig.root_dir do
-            # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
-            # so that only the necessary `CacheRootDirectory` can be obtained.
-            config_path = ConfigFinder.find_config_path(Dir.pwd)
-            file_contents = File.read(config_path)
-
-            # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
-            next unless file_contents.include?('CacheRootDirectory')
-
-            require 'erb'
-            yaml_code = ERB.new(file_contents).result
-
-            require 'yaml'
-            config_yaml = YAML.safe_load(
-              yaml_code, permitted_classes: [Regexp, Symbol], aliases: true
-            )
-
-            # For compatibility with Ruby 3.0 or lower.
-            if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
-              config_yaml == false ? nil : config_yaml
-            end
-
-            config_yaml&.dig('AllCops', 'CacheRootDirectory')
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
         def port_path
           dir.join('port')
         end
@@ -109,8 +90,8 @@ module RuboCop
           dir.join('token')
         end
 
-        def pid_path
-          dir.join('pid')
+        def pid_path(create_dir: true)
+          (create_dir ? dir : dir_path).join('pid')
         end
 
         def lock_path
@@ -130,19 +111,18 @@ module RuboCop
         end
 
         def pid_running?
-          Process.kill(0, pid_path.read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG
+          Process.kill(0, pid_path(create_dir: false).read.to_i) == 1
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG,
+               Errno::ENOTDIR
           false
         end
 
         def acquire_lock
-          lock_file = File.open(lock_path, File::CREAT)
-          # flock returns 0 if successful, and false if not.
-          flock_result = lock_file.flock(File::LOCK_EX | File::LOCK_NB)
-          yield flock_result != false
-        ensure
-          lock_file.flock(File::LOCK_UN)
-          lock_file.close
+          File.open(lock_path, File::CREAT) do |lock_file|
+            # flock returns 0 if successful, and false if not.
+            flock_result = lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+            yield flock_result != false
+          end
         end
 
         def write_port_and_token_files(port:, token:)
@@ -164,6 +144,45 @@ module RuboCop
         def write_version_file(version)
           version_path.write(version)
         end
+
+        def inherit_from_data(yaml)
+          return '' unless (inherit_from_paths = yaml['inherit_from'])
+
+          Array(inherit_from_paths).map do |path|
+            next if PathUtil.remote_file?(path)
+
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        def require_data(yaml)
+          return '' unless (require_paths = yaml['require'])
+
+          Array(require_paths).map do |path|
+            # NOTE: This targets only relative or absolute path specifications.
+            # For example, specifications like `require: rubocop-performance`,
+            # which can be loaded from `$LOAD_PATH`, are ignored.
+            next unless path.start_with?('.', '/')
+
+            # NOTE: `.so` files are not typically specified, so only `.rb` files are targeted.
+            path = "#{path}.rb" unless path.end_with?('.rb')
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        private
+
+        def load_erb_templated_yaml(content)
+          require 'erb'
+          yaml_code = ERB.new(content).result
+
+          require 'yaml'
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+        end
       end
     end
   end

data/lib/rubocop/server/cli.rb

@@ -55,7 +55,7 @@ module RuboCop
 
       private
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       def process_arguments(argv)
         server_arguments = delete_server_argument_from(argv)
 
@@ -84,9 +84,8 @@ module RuboCop
 
         STATUS_SUCCESS
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength
       def run_command(server_command, detach:)
         case server_command
         when '--server'
@@ -107,7 +106,6 @@ module RuboCop
           Server::ClientCommand::Status.new.run
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
 
       def fetch_cache_root_path_from(arguments)
         cache_root = arguments.detect { |argument| argument.start_with?('--cache-root') }

data/lib/rubocop/server/client_command/base.rb

@@ -38,6 +38,16 @@ module RuboCop
             warn 'RuboCop server is not running.' unless running
           end
         end
+
+        class << self
+          def args_config_file_path
+            first_args_config_key_index = ARGV.index { |value| ['-c', '--config'].include?(value) }
+
+            return if first_args_config_key_index.nil?
+
+            ARGV[first_args_config_key_index + 1]
+          end
+        end
       end
     end
   end

data/lib/rubocop/server/client_command/exec.rb

@@ -41,7 +41,8 @@ module RuboCop
         end
 
         def incompatible_version?
-          Cache.version_path.read != Cache.restart_key
+          Cache.version_path.read !=
+            Cache.restart_key(args_config_file_path: self.class.args_config_file_path)
         end
 
         def stderr

data/lib/rubocop/server/client_command/start.rb

@@ -34,7 +34,7 @@ module RuboCop
               exit 0
             end
 
-            Cache.write_version_file(Cache.restart_key)
+            write_version_file
 
             host = ENV.fetch('RUBOCOP_SERVER_HOST', '127.0.0.1')
             port = ENV.fetch('RUBOCOP_SERVER_PORT', 0)
@@ -42,6 +42,16 @@ module RuboCop
             Server::Core.new.start(host, port, detach: @detach)
           end
         end
+
+        private
+
+        def write_version_file
+          Cache.write_version_file(
+            Cache.restart_key(
+              args_config_file_path: self.class.args_config_file_path
+            )
+          )
+        end
       end
     end
   end

data/lib/rubocop/server/core.rb

@@ -45,6 +45,8 @@ module RuboCop
         write_port_and_token_files
 
         pid = fork do
+          # NOTE: As of Ruby 4.0.0, ZJIT is still under development, while YJIT is production-ready,
+          # so support for ZJIT is deferred.
           if defined?(RubyVM::YJIT.enable)
             RubyVM::YJIT.enable
           end
@@ -55,6 +57,12 @@ module RuboCop
         end
 
         Process.waitpid(pid)
+
+        # The daemon writes its pid file asynchronously after forking, so wait until
+        # the server is actually running before returning. This prevents a race where
+        # a subsequent command (e.g. `--restart-server`) observes an inconsistent
+        # state right after `--start-server` returns.
+        Server.wait_for_running_status!(true)
       end
 
       def write_port_and_token_files

data/lib/rubocop/server.rb

@@ -17,6 +17,11 @@ module RuboCop
   module Server
     TIMEOUT = 20
 
+    # Options that start a long-lived protocol server on stdio in the current process.
+    # They must never be forwarded to the server process, which would run them as
+    # a lint request and silently produce no protocol response.
+    IN_PROCESS_PROTOCOL_OPTIONS = %w[--lsp --mcp].freeze
+
     autoload :CLI, 'rubocop/server/cli'
     autoload :Cache, 'rubocop/server/cache'
     autoload :ClientCommand, 'rubocop/server/client_command'
@@ -36,6 +41,15 @@ module RuboCop
         Cache.pid_running?
       end
 
+      # Whether the invocation should be forwarded to the running server process.
+      # `--lsp` and `--mcp` always run in the current process even when the server is running:
+      # they serve a protocol on stdio, which the server's `exec` command cannot do.
+      def forward_to_server?(argv = ARGV)
+        return false unless running?
+
+        (IN_PROCESS_PROTOCOL_OPTIONS & argv).empty?
+      end
+
       def wait_for_running_status!(expected)
         start_time = Time.now
         while Server.running? != expected

data/lib/rubocop/target_finder.rb

@@ -21,7 +21,10 @@ module RuboCop
 
       args.uniq.each do |arg|
         files += if File.directory?(arg)
-                   target_files_in_dir(arg.chomp(File::SEPARATOR))
+                   # Expand the directory so that the traversal can prune directories the
+                   # config excludes - the exclude patterns are absolute paths, and glued
+                   # onto a relative base (`rubocop .`) they never match anything.
+                   target_files_in_dir(File.expand_path(arg.chomp(File::SEPARATOR)))
                  else
                    process_explicit_path(arg, mode)
                  end
@@ -38,15 +41,17 @@ module RuboCop
     # @param base_dir Root directory under which to search for
     #   ruby source files
     # @return [Array] Array of filenames
-    def target_files_in_dir(base_dir = Dir.pwd)
+    def target_files_in_dir(base_dir = PathUtil.pwd)
       # Support Windows: Backslashes from command-line -> forward slashes
       base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      # use file.include? for performance optimization
-      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+      target_files = if hidden_dir?(base_dir)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, base_dir, base_dir_config) }
+                     end
 
       target_files.sort_by!(&order)
     end
@@ -70,18 +75,27 @@ module RuboCop
 
     private
 
-    def to_inspect?(file, hidden_files, base_dir_config)
+    def to_inspect?(file, base_dir, base_dir_config)
       return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && ruby_file?(file)
+      return true if !hidden_file_in_dir?(file, base_dir) && ruby_file?(file)
 
       base_dir_config.file_to_include?(file)
     end
 
+    def hidden_dir?(dir)
+      basename = File.basename(dir)
+      basename.start_with?('.') && basename != '.' && basename != '..'
+    end
+
+    def hidden_file_in_dir?(file, base_dir)
+      base_dir = "#{base_dir}#{File::SEPARATOR}" unless base_dir.end_with?(File::SEPARATOR)
+      relative = file.delete_prefix(base_dir)
+      relative.start_with?('.') || relative.include?(HIDDEN_PATH_SUBSTRING)
+    end
+
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
       # Escape glob characters in base_dir to avoid unwanted behavior.
-      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+      base_dir = base_dir.gsub(/[\\{}\[\]*?]/) do |reserved_glob_character|
         "\\#{reserved_glob_character}"
       end
 
@@ -175,7 +189,7 @@ module RuboCop
     end
 
     def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+      return false if !File.extname(file).empty? || !File.exist?(file) || File.empty?(file)
 
       first_line = File.open(file, &:readline)
       /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)

data/lib/rubocop/target_ruby.rb

@@ -4,7 +4,9 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4].freeze
+    KNOWN_RUBIES = [
+      2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, 3.4, 4.0, 4.1
+    ].freeze
     DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
@@ -110,8 +112,17 @@ module RuboCop
       end
 
       def version_from_gemspec_file(file)
+        # When using parser_prism, we need to use a Ruby version that Prism supports (3.3+)
+        # for parsing the gemspec file. This doesn't affect the detected Ruby version,
+        # it's just for the parsing step.
+        ruby_version_for_parsing = if @config.parser_engine == :parser_prism
+                                     3.3
+                                   else
+                                     DEFAULT_VERSION
+                                   end
+
         processed_source = ProcessedSource.from_file(
-          file, DEFAULT_VERSION, parser_engine: @config.parser_engine
+          file, ruby_version_for_parsing, parser_engine: @config.parser_engine
         )
         return unless processed_source.valid_syntax?
 
@@ -149,21 +160,18 @@ module RuboCop
     # The target ruby version may be found in a .ruby-version file.
     # @api private
     class RubyVersionFile < Source
-      RUBY_VERSION_FILENAME = '.ruby-version'
-      RUBY_VERSION_PATTERN = /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
-
       def name
-        "`#{RUBY_VERSION_FILENAME}`"
+        "`#{filename}`"
       end
 
       private
 
       def filename
-        RUBY_VERSION_FILENAME
+        '.ruby-version'
       end
 
       def pattern
-        RUBY_VERSION_PATTERN
+        /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
       end
 
       def find_version
@@ -182,21 +190,29 @@ module RuboCop
     # starting with `ruby`.
     # @api private
     class ToolVersionsFile < RubyVersionFile
-      TOOL_VERSIONS_FILENAME = '.tool-versions'
-      TOOL_VERSIONS_PATTERN = /^(?:ruby )(?<version>\d+\.\d+)/.freeze
+      private
 
-      def name
-        "`#{TOOL_VERSIONS_FILENAME}`"
+      def filename
+        '.tool-versions'
       end
 
+      def pattern
+        /^(?:ruby )(?<version>\d+\.\d+)/.freeze
+      end
+    end
+
+    # The target ruby version may be found in a mise.toml file, in a line
+    # starting with `ruby = "`.
+    # @api private
+    class MiseTomlFile < RubyVersionFile
       private
 
       def filename
-        TOOL_VERSIONS_FILENAME
+        'mise.toml'
       end
 
       def pattern
-        TOOL_VERSIONS_PATTERN
+        /^ruby = ["'](?<version>\d+\.\d+)/.freeze
       end
     end
 
@@ -264,6 +280,7 @@ module RuboCop
       RuboCopConfig,
       GemspecFile,
       RubyVersionFile,
+      MiseTomlFile,
       ToolVersionsFile,
       BundlerLockFile,
       Default

data/lib/rubocop/todo_audit.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Audits `.rubocop_todo.yml` for `Exclude` entries that are no longer
+  # needed: files a cop would not flag anymore, or files that no longer
+  # exist. Used by the `--report-unused-todo-entries` option.
+  # @api private
+  class TodoAudit
+    Entry = Struct.new(:cop_name, :path)
+
+    def initialize(config_store, options)
+      @config_store = config_store
+      @options = options
+    end
+
+    # @return [Array<Entry>, nil] the unused entries, or `nil` when there is
+    #   no todo file to audit
+    def unused_entries
+      return nil unless todo_path
+
+      entries = todo_exclude_entries
+      return [] if entries.empty?
+
+      offending_cops = offending_cops_without_todo(entries)
+      entries.reject { |entry| offending_cops[absolute(entry.path)]&.include?(entry.cop_name) }
+    end
+
+    def todo_file
+      CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+    end
+
+    private
+
+    def todo_path
+      return @todo_path if defined?(@todo_path)
+
+      path = File.expand_path(todo_file)
+      @todo_path = File.exist?(path) ? path : nil
+    end
+
+    def todo_exclude_entries
+      yaml = YAML.safe_load_file(todo_path, permitted_classes: [Regexp, Symbol], aliases: true)
+      return [] unless yaml.is_a?(Hash)
+
+      yaml.flat_map do |cop_name, cop_config|
+        next [] unless auditable_cop?(cop_name, cop_config)
+
+        cop_config['Exclude'].grep(String).map { |path| Entry.new(cop_name, path) }
+      end
+    end
+
+    # Only registered cops with an `Exclude` list can be audited - for an
+    # unknown cop (e.g. from an extension that is not loaded in this run)
+    # the absence of offenses proves nothing.
+    def auditable_cop?(cop_name, cop_config)
+      cop_name.include?('/') &&
+        cop_config.is_a?(Hash) &&
+        cop_config['Exclude'].is_a?(Array) &&
+        Cop::Registry.global.contains_cop_matching?([cop_name])
+    end
+
+    # Inspects every file the todo entries mention, with the todo exclusions
+    # subtracted from the configuration, and returns the names of the cops
+    # that still report offenses, keyed by absolute file path.
+    def offending_cops_without_todo(entries)
+      files = entries.map { |entry| absolute(entry.path) }.uniq.select { |file| File.file?(file) }
+
+      files.to_h do |file|
+        offenses = inspect_file(file, entries)
+        [file, offenses.to_set(&:cop_name)]
+      end
+    end
+
+    def inspect_file(file, entries)
+      config = audit_config(@config_store.for_file(file), entries)
+      team = Cop::Team.mobilize(Cop::Registry.global, config, @options.merge(autocorrect: false))
+
+      processed_source = ProcessedSource.from_file(
+        file, config.target_ruby_version, parser_engine: config.parser_engine
+      )
+      processed_source.config = config
+      processed_source.registry = Cop::Registry.global
+
+      team.investigate(processed_source).offenses.reject(&:disabled?)
+    end
+
+    # A copy of the configuration with the todo exclusions removed for the
+    # audited cops, so their offenses in the listed files become visible.
+    def audit_config(config, entries)
+      hash = config.to_hash.dup
+
+      entries.group_by(&:cop_name).each do |cop_name, cop_entries|
+        cop_config = hash[cop_name]
+        next unless cop_config.is_a?(Hash) && cop_config['Exclude'].is_a?(Array)
+
+        hash[cop_name] = subtract_excludes(cop_config, cop_entries)
+      end
+
+      Config.create(hash, config.loaded_path, check: false)
+    end
+
+    def subtract_excludes(cop_config, cop_entries)
+      removals = cop_entries.map { |entry| absolute(entry.path) }
+      cop_config.merge('Exclude' => cop_config['Exclude'] - removals)
+    end
+
+    def absolute(path)
+      File.expand_path(path, File.dirname(todo_path))
+    end
+  end
+end