rubocop 1.84.2 → 1.86.2

data/lib/rubocop/options.rb

@@ -16,7 +16,9 @@ module RuboCop
                       'root of the project. RuboCop will use this path to determine which ' \
                       'cops are enabled (via eg. Include/Exclude), and so that certain cops ' \
                       'like Naming/FileName can be checked.'
-    EXITING_OPTIONS = %i[version verbose_version show_cops show_docs_url lsp].freeze
+    EXITING_OPTIONS = %i[
+      version verbose_version show_cops list_enabled_cops_for show_docs_url lsp mcp
+    ].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -57,6 +59,7 @@ module RuboCop
         add_check_options(opts)
         add_cache_options(opts)
         add_lsp_option(opts)
+        add_mcp_option(opts)
         add_server_options(opts)
         add_output_options(opts)
         add_autocorrection_options(opts)
@@ -215,6 +218,12 @@ module RuboCop
       end
     end
 
+    def add_mcp_option(opts)
+      section(opts, 'MCP Option') do
+        option(opts, '--mcp')
+      end
+    end
+
     def add_server_options(opts)
       section(opts, 'Server Options') do
         option(opts, '--[no-]server')
@@ -229,6 +238,7 @@ module RuboCop
     def add_additional_modes(opts)
       section(opts, 'Additional Modes') do
         option(opts, '-L', '--list-target-files')
+        option(opts, '--list-enabled-cops-for PATH')
         option(opts, '--show-cops [COP1,COP2,...]') do |list|
           @options[:show_cops] = list.nil? ? [] : list.split(',')
         end
@@ -467,8 +477,7 @@ module RuboCop
     end
 
     def invalid_arguments_for_parallel
-      [('--auto-gen-config' if @options.key?(:auto_gen_config)),
-       ('-F/--fail-fast'    if @options.key?(:fail_fast)),
+      [('-F/--fail-fast'    if @options.key?(:fail_fast)),
        ('--profile'         if @options[:profile]),
        ('--memory'          if @options[:memory]),
        ('--cache false'     if @options > { cache: 'false' })].compact
@@ -592,7 +601,7 @@ module RuboCop
       display_only_correctable:         ['Only output correctable offense messages.'],
       display_only_safe_correctable:    ['Only output safe-correctable offense messages',
                                          'when combined with --display-only-correctable.'],
-      show_cops:                        ['Shows the given cops, or all cops by',
+      show_cops:                        ['Show the given cops, or all cops by',
                                          'default, and their configurations for the',
                                          'current directory.',
                                          'You can use `*` as a wildcard.'],
@@ -621,6 +630,8 @@ module RuboCop
                                          'autocorrected source. This is especially useful',
                                          'when combined with --autocorrect and --stdin.'],
       list_target_files:                'List all files RuboCop will inspect.',
+      list_enabled_cops_for:            ['List which cops will inspect a given file or',
+                                         'directory.'],
       autocorrect:                      'Autocorrect offenses (only when it\'s safe).',
       auto_correct:                     '(same, deprecated)',
       safe_auto_correct:                '(same, deprecated)',
@@ -651,6 +662,8 @@ module RuboCop
       server_status:                    'Show server status.',
       no_detach:                        'Run the server process in the foreground.',
       lsp:                              'Start a language server listening on STDIN.',
+      mcp:                              ['Start an MCP (Model Context Protocol) server that',
+                                         'communicates over stdio.'],
       raise_cop_error:                  ['Raise cop-related errors with cause and location.',
                                          'This is used to prevent cops from failing silently.',
                                          'Default is false.'],

data/lib/rubocop/path_util.rb

@@ -10,7 +10,19 @@ module RuboCop
 
     module_function
 
-    def relative_path(path, base_dir = Dir.pwd)
+    # Returns the current working directory, cached for the duration of a run.
+    # Dir.pwd is a syscall; caching it avoids repeated overhead since RuboCop
+    # never changes the working directory during a run.
+    def pwd
+      @pwd ||= Dir.pwd
+    end
+
+    # Reset the cached pwd. Only needed in tests that use Dir.chdir.
+    def reset_pwd
+      @pwd = nil
+    end
+
+    def relative_path(path, base_dir = PathUtil.pwd)
       PathUtil.relative_paths_cache[base_dir][path] ||=
         # Optimization for the common case where path begins with the base
         # dir. Just cut off the first part.
@@ -41,7 +53,7 @@ module RuboCop
           path.uri.to_s
         else
           # Ideally, we calculate this relative to the project root.
-          base_dir = Dir.pwd
+          base_dir = PathUtil.pwd
 
           if path.start_with? base_dir
             relative_path(path, base_dir)

data/lib/rubocop/plugin/loader.rb

@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def require_plugin(require_path)
-          FeatureLoader.load(config_directory_path: Dir.pwd, feature: require_path)
+          FeatureLoader.load(config_directory_path: PathUtil.pwd, feature: require_path)
         end
 
         def constantize_plugin_from_gemspec_metadata(plugin_name)

data/lib/rubocop/result_cache.rb

@@ -27,6 +27,7 @@ module RuboCop
     # there's parallel execution and the cache is shared.
     def self.cleanup(config_store, verbose, cache_root_override = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
+      return unless config_store.for_pwd.for_all_cops['MaxFilesInCache']
 
       rubocop_cache_dir = cache_root(config_store, cache_root_override)
       return unless File.exist?(rubocop_cache_dir)
@@ -85,15 +86,23 @@ module RuboCop
     end
 
     def self.cache_root(config_store, cache_root_override = nil)
-      CacheConfig.root_dir do
+      return @cache_root if @cache_root && !cache_root_override
+
+      result = CacheConfig.root_dir do
         cache_root_override || config_store.for_pwd.for_all_cops['CacheRootDirectory']
       end
+      @cache_root = result unless cache_root_override
+      result
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
       config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
+    def self.reset_config_cache
+      @cache_root = nil
+    end
+
     attr_reader :path
 
     def initialize(file, team, options, config_store, cache_root_override = nil)
@@ -196,6 +205,17 @@ module RuboCop
         end
       end
 
+      # Return a hash of the options given at invocation, minus the ones that have
+      # no effect on which offenses and disabled line ranges are found, and thus
+      # don't affect caching.
+      def relevant_options_digest(options)
+        @relevant_options_digest ||= {}
+        @relevant_options_digest[options] ||= begin
+          options = options.reject { |key, _| NON_CHANGING.include?(key) }
+          options.to_s.gsub(/[^a-z]+/i, '_')
+        end
+      end
+
       private
 
       def digest(path)
@@ -227,20 +247,12 @@ module RuboCop
       end
     end
 
-    # Return a hash of the options given at invocation, minus the ones that have
-    # no effect on which offenses and disabled line ranges are found, and thus
-    # don't affect caching.
-    def relevant_options_digest(options)
-      options = options.reject { |key, _| NON_CHANGING.include?(key) }
-      options.to_s.gsub(/[^a-z]+/i, '_')
-    end
-
     # We combine team and options into a single "context" checksum to avoid
     # making file names that are too long for some filesystems to handle.
     # This context is for anything that's not (1) the RuboCop executable
     # checksum or (2) the inspected file checksum.
     def context_checksum(team, options)
-      keys = [team.external_dependency_checksum, relevant_options_digest(options)]
+      keys = [team.external_dependency_checksum, self.class.relevant_options_digest(options)]
       Digest::SHA1.hexdigest(keys.join)
     end
   end

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,6 +6,12 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
+  @integrated_plugins = false
+
+  class << self
+    attr_accessor :integrated_plugins
+  end
+
   let(:ruby_version) do
     # The minimum version Prism can parse is 3.3.
     ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : RuboCop::TargetRuby::DEFAULT_VERSION
@@ -18,11 +24,13 @@ module CopHelper
 
   before(:all) do
     next if ENV['RUBOCOP_CORE_DEVELOPMENT']
+    next if CopHelper.integrated_plugins
 
     plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
       feature_name if feature_specification.metadata['default_lint_roller_plugin']
     end
     RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
+    CopHelper.integrated_plugins = true
   end
 
   def inspect_source(source, file = nil)

data/lib/rubocop/rspec/shared_contexts.rb

@@ -2,8 +2,12 @@
 
 require 'tmpdir'
 
+# Reset cached PathUtil.pwd before each example so that tests using Dir.chdir
+# or stubbing Dir.pwd get a fresh value.
+RSpec.configure { |c| c.before { RuboCop::PathUtil.reset_pwd } }
+
 RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLength
-  around do |example|
+  around do |example| # rubocop:disable Metrics/BlockLength
     Dir.mktmpdir do |tmpdir|
       original_home = Dir.home
       original_xdg_config_home = ENV.fetch('XDG_CONFIG_HOME', nil)
@@ -26,11 +30,16 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       begin
         FileUtils.mkdir_p(working_dir)
 
-        Dir.chdir(working_dir) { example.run }
+        Dir.chdir(working_dir) do
+          RuboCop::PathUtil.reset_pwd
+          RuboCop::ResultCache.reset_config_cache
+          example.run
+        end
       ensure
         ENV['HOME'] = original_home
         ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
 
+        RuboCop::ResultCache.reset_config_cache
         RuboCop::ConfigLoader.clear_options # This also resets RuboCop::FileFinder.root_level
       end
     end
@@ -203,6 +212,27 @@ RSpec.shared_context 'lsp' do
   end
 end
 
+RSpec.shared_context 'with exclude limit tracking' do
+  around do |example|
+    Dir.mktmpdir('rubocop-exclude-limit') do |dir|
+      RuboCop::ExcludeLimit.tmp_dir = Pathname.new(dir)
+      example.run
+    ensure
+      RuboCop::ExcludeLimit.tmp_dir = nil
+    end
+  end
+
+  # Reads exclude_limit values from the tmp files written by ExcludeLimit.
+  # Returns a hash like { 'Max' => 81 } or nil if no values were written.
+  def read_exclude_limit(cop, parameter_name = nil)
+    if parameter_name
+      read_exclude_limit(cop)[parameter_name]
+    else
+      RuboCop::ExcludeLimit.read_limits(cop.class.badge.to_s)
+    end
+  end
+end
+
 RSpec.shared_context 'ruby 2.0' do
   # Prism supports parsing Ruby 3.3+.
   let(:ruby_version) { ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : 2.0 }

data/lib/rubocop/runner.rb

@@ -62,6 +62,8 @@ module RuboCop
       @errors = []
       @warnings = []
       @aborting = false
+      @inspected_files = []
+      @report_queue = {}
     end
 
     def run(paths)
@@ -73,7 +75,6 @@ module RuboCop
       if @options[:list_target_files]
         list_files(target_files)
       else
-        warm_cache(target_files) if @options[:parallel]
         inspect_files(target_files)
       end
     rescue Interrupt
@@ -90,21 +91,6 @@ module RuboCop
 
     private
 
-    # Warms up the RuboCop cache by forking a suitable number of RuboCop
-    # instances that each inspects its allotted group of files.
-    def warm_cache(target_files)
-      saved_options = @options.dup
-      if target_files.length <= 1
-        puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
-        return
-      end
-      puts 'Running parallel inspection' if @options[:debug]
-      %i[autocorrect safe_autocorrect].each { |opt| @options[opt] = false }
-      Parallel.each(target_files) { |target_file| file_offenses(target_file) }
-    ensure
-      @options = saved_options
-    end
-
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
       mode = if @options[:only_recognized_file_types]
@@ -116,12 +102,15 @@ module RuboCop
       target_files.each(&:freeze).freeze
     end
 
-    def inspect_files(files)
-      inspected_files = []
-
+    def inspect_files(files) # rubocop:disable Metrics/AbcSize
       formatter_set.started(files)
+      file_iterator(files) do |file|
+        offenses = process_file(file)
+        succeeded = offenses.none? { |o| considered_failure?(o) && offense_displayed?(o) }
+        raise Parallel::Break if @options[:fail_fast] && !succeeded
 
-      each_inspected_file(files) { |file| inspected_files << file }
+        [offenses, succeeded]
+      end
     ensure
       # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
       # mainly targets editors that integrates RuboCop. When RuboCop is run
@@ -129,23 +118,74 @@ module RuboCop
       if files.size > 1 && cached_run?
         ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
       end
-
-      formatter_set.finished(inspected_files.freeze)
+      formatter_set.finished(@inspected_files.freeze)
       formatter_set.close_output_files
     end
 
-    def each_inspected_file(files)
-      files.reduce(true) do |all_passed, file|
-        offenses = process_file(file)
-        yield file
+    def file_iterator(files, &block)
+      all_passed = true
 
-        if offenses.any? { |o| considered_failure?(o) && offense_displayed?(o) }
-          break false if @options[:fail_fast]
+      on_start = ->(file, _index) { file_started(file) }
+      on_finish = lambda do |file, index, (offenses, passed)|
+        all_passed &&= passed
+        finished_report(file, index, offenses)
+      end
 
-          next false
-        end
+      if run_in_parallel?(files)
+        parallel_file_iterator(files, on_start, on_finish, &block)
+      else
+        serial_file_iterator(files, on_start, on_finish, &block)
+      end
+
+      process_remaining_report_queue
+
+      all_passed
+    end
+
+    def finished_report(file, index, offenses)
+      @report_queue[index] = [file, offenses]
+      @next_index_to_report ||= 0
+      while @report_queue.key?(@next_index_to_report)
+        process_report_queue_entry(@next_index_to_report)
+        @next_index_to_report += 1
+      end
+    end
 
-        all_passed
+    def process_report_queue_entry(index)
+      file, offenses = @report_queue.delete(index)
+      file_finished(file, offenses)
+    end
+
+    def process_remaining_report_queue
+      @report_queue.keys.sort.each do |index|
+        process_report_queue_entry(index)
+      end
+    end
+
+    def run_in_parallel?(files)
+      return false if @options[:auto_gen_config]
+      return false unless @options[:parallel]
+
+      if files.size <= 1
+        puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
+        return false
+      end
+
+      puts 'Running parallel inspection' if @options[:debug]
+      true
+    end
+
+    def parallel_file_iterator(files, on_start, on_finish, &block)
+      Parallel.each(files, start: on_start, finish: on_finish, &block)
+    end
+
+    def serial_file_iterator(files, on_start, on_finish, &block)
+      files.each_with_index do |file, index|
+        on_start.call(file, index)
+        result = yield file
+        on_finish.call(file, index, result)
+      rescue Parallel::Break
+        break
       end
     end
 
@@ -154,16 +194,13 @@ module RuboCop
     end
 
     def process_file(file)
-      file_started(file)
-      offenses = file_offenses(file)
+      file_offenses(file)
     rescue InfiniteCorrectionLoop => e
       raise e if @options[:raise_cop_error]
 
       errors << e
       warn Rainbow(e.message).red
-      offenses = e.offenses.compact.sort.freeze
-    ensure
-      file_finished(file, offenses || [])
+      e.offenses.compact.sort.freeze
     end
 
     def file_offenses(file)
@@ -194,7 +231,7 @@ module RuboCop
 
       if real_run_needed
         offenses = yield
-        save_in_cache(cache, offenses)
+        save_in_cache(cache, offenses) unless Cop::Registry.global.warnings?(file)
       end
 
       offenses
@@ -250,6 +287,7 @@ module RuboCop
     end
 
     def file_finished(file, offenses)
+      @inspected_files << file
       offenses = offenses_to_report(offenses)
       formatter_set.file_finished(file, offenses)
     end
@@ -258,10 +296,6 @@ module RuboCop
       @cached_run ||=
         (@options[:cache] == 'true' ||
          (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
-        # When running --auto-gen-config, there's some processing done in the
-        # cops related to calculating the Max parameters for Metrics cops. We
-        # need to do that processing and cannot use caching.
-        !@options[:auto_gen_config] &&
         # We can't cache results from code which is piped in to stdin
         !@options[:stdin]
     end
@@ -350,16 +384,9 @@ module RuboCop
 
     def inspect_file(processed_source, team = mobilize_team(processed_source))
       extracted_ruby_sources = extract_ruby_sources(processed_source)
-      offenses = extracted_ruby_sources.flat_map do |extracted_ruby_source|
-        report = team.investigate(
-          extracted_ruby_source[:processed_source],
-          offset: extracted_ruby_source[:offset],
-          original: processed_source
-        )
-        @errors.concat(team.errors)
-        @warnings.concat(team.warnings)
-        report.offenses
-      end
+      offenses = team.investigate_fragments(extracted_ruby_sources, original: processed_source)
+      @errors.concat(team.errors)
+      @warnings.concat(team.warnings)
       [offenses, team.updated_source_file?]
     end
 

data/lib/rubocop/server/cache.rb

@@ -114,13 +114,11 @@ module RuboCop
         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:)

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

data/lib/rubocop/target_finder.rb

@@ -38,16 +38,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 +72,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

@@ -160,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
@@ -193,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
 
@@ -275,6 +280,7 @@ module RuboCop
       RuboCopConfig,
       GemspecFile,
       RubyVersionFile,
+      MiseTomlFile,
       ToolVersionsFile,
       BundlerLockFile,
       Default

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.84.2'
+    STRING = '1.86.2'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
@@ -55,7 +55,7 @@ module RuboCop
 
     # @api private
     def self.parser_version(target_ruby_version)
-      config_path = ConfigFinder.find_config_path(Dir.pwd)
+      config_path = ConfigFinder.find_config_path(PathUtil.pwd)
       yaml = Util.silence_warnings do
         ConfigLoader.load_yaml_configuration(config_path)
       end