rubocop 1.81.7 → 1.92.1

data/lib/rubocop/server/cache.rb

@@ -45,15 +45,15 @@ module RuboCop
           @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # 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(
-            args_config_file_path || ConfigFinder.find_config_path(Dir.pwd)
-          ).read
+          config_path = Pathname(args_config_file_path || ConfigFinder.find_config_path(Dir.pwd))
+          # NOTE: A missing config file is reported by `RuboCop::CLI` with a friendly message.
+          config_data = config_path.exist? ? config_path.read : ''
           yaml = load_erb_templated_yaml(config_data)
 
           inherit_from_data = inherit_from_data(yaml)
@@ -61,45 +61,27 @@ module RuboCop
 
           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
 
-        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')
-
-            config_yaml = load_erb_templated_yaml(file_contents)
-
-            # 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
-
         def port_path
           dir.join('port')
         end
@@ -108,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
@@ -129,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::EPERM, 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:)
@@ -200,7 +181,7 @@ module RuboCop
           yaml_code = ERB.new(content).result
 
           require 'yaml'
-          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true) || {}
         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/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,16 +41,16 @@ 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)
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = if hidden_path?(base_dir)
+      target_files = if hidden_dir?(base_dir)
                        all_files.select { |file| ruby_file?(file) }
                      else
-                       all_files.select { |file| to_inspect?(file, base_dir_config) }
+                       all_files.select { |file| to_inspect?(file, base_dir, base_dir_config) }
                      end
 
       target_files.sort_by!(&order)
@@ -72,15 +75,22 @@ module RuboCop
 
     private
 
-    def to_inspect?(file, 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_path?(file) && 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_path?(path)
-      path.include?(HIDDEN_PATH_SUBSTRING)
+    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)

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, 3.5].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 = {
@@ -98,15 +100,23 @@ module RuboCop
       def gemspec_filepath
         return @gemspec_filepath if defined?(@gemspec_filepath)
 
-        @gemspec_filepath =
-          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
-            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
-            # https://github.com/jruby/jruby/issues/8358
-            candidates = Pathname.glob("#{dir}/*.gemspec")
-            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
-            # the folder.
-            break candidates.first if candidates.one?
-          end
+        @gemspec_filepath = @config.traverse_directories_upwards(
+          @config.base_dir_for_path_parameters, ConfigFinder.project_root
+        ) do |dir|
+          candidates = gemspec_candidates(dir)
+
+          # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+          # the folder.
+          break candidates.first if candidates.one?
+        end
+      end
+
+      def gemspec_candidates(dir)
+        # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/8358
+        Pathname.glob("#{dir}/*.gemspec")
+      rescue SystemCallError
+        []
       end
 
       def version_from_gemspec_file(file)
@@ -158,21 +168,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
@@ -180,6 +187,8 @@ module RuboCop
         return unless file && File.file?(file)
 
         File.read(file).match(pattern) { |md| md[:version].to_f }
+      rescue SystemCallError
+        nil
       end
 
       def version_file
@@ -191,21 +200,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
 
@@ -243,6 +260,8 @@ module RuboCop
           result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
           return result.captures.first.to_f if result
         end
+      rescue SystemCallError
+        nil
       end
 
       def bundler_lock_file_path
@@ -273,6 +292,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