rubocop 1.71.1 → 1.92.0

data/lib/rubocop/result_cache.rb

@@ -9,7 +9,7 @@ module RuboCop
   # Provides functionality for caching RuboCop runs.
   # @api private
   class ResultCache
-    NON_CHANGING = %i[color format formatters out debug fail_level
+    NON_CHANGING = %i[color format formatters out debug display_time fail_level
                       fix_layout autocorrect safe_autocorrect autocorrect_all
                       cache fail_fast stdin parallel].freeze
 
@@ -22,19 +22,22 @@ module RuboCop
     # Remove old files so that the cache doesn't grow too big. When the
     # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
     # files in the cache are removed. The reason for removing so much is that
-    # cleaning should be done relatively seldom, since there is a slight risk
+    # removing should be done relatively seldom, since there is a slight risk
     # that some other RuboCop process was just about to read the file, when
     # 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)
 
-      files, dirs = Find.find(rubocop_cache_dir).partition { |path| File.file?(path) }
+      # We know the cache entries are 3 level deep, so globing
+      # for `*/*/*` only returns files.
+      files = Dir[File.join(rubocop_cache_dir, '*/*/*')]
       return unless requires_file_removal?(files.length, config_store)
 
-      remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
+      remove_oldest_files(files, rubocop_cache_dir, verbose)
     end
 
     class << self
@@ -49,39 +52,57 @@ module RuboCop
         file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
-      def remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
+      def remove_oldest_files(files, rubocop_cache_dir, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
         remove_count = (files.length / 2) + 1
         puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
-        remove_files(sorted, dirs, remove_count)
-      rescue Errno::ENOENT
+        remove_files(sorted, remove_count)
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EPERM, Errno::EROFS
         # This can happen if parallel RuboCop invocations try to remove the
-        # same files. No problem.
+        # same files, or if the cache can't be written to. No problem.
         puts $ERROR_INFO if verbose
       end
 
-      def remove_files(files, dirs, remove_count)
+      def remove_files(files, remove_count)
         # Batch file deletions, deleting over 130,000+ files will crash
         # File.delete.
         files[0, remove_count].each_slice(10_000).each do |files_slice|
           File.delete(*files_slice)
         end
-        dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
+
+        dirs = files.map { |f| File.dirname(f) }.uniq
+        until dirs.empty?
+          dirs.select! do |dir|
+            Dir.rmdir(dir)
+            true
+          rescue SystemCallError # ENOTEMPTY etc
+            false
+          end
+          dirs = dirs.map { |f| File.dirname(f) }.uniq
+        end
       end
     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)
@@ -90,7 +111,7 @@ module RuboCop
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
       @path = File.join(rubocop_cache_dir,
-                        rubocop_checksum,
+                        self.class.source_checksum,
                         context_checksum(team, options),
                         file_checksum(file, config_store))
       @cached_data = CachedData.new(file)
@@ -102,7 +123,7 @@ module RuboCop
     end
 
     def valid?
-      File.exist?(@path)
+      !@checksum_unavailable && File.exist?(@path)
     end
 
     def load
@@ -111,30 +132,23 @@ module RuboCop
     end
 
     def save(offenses)
+      return if @checksum_unavailable
+
       dir = File.dirname(@path)
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES, Errno::EROFS => e
+      rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache.\n  #{e.message}"
         return
       end
 
-      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
       # RuboCop must be in control of where its cached data is stored. A
       # symbolic link anywhere in the cache directory tree can be an
       # indication that a symlink attack is being waged.
       return if symlink_protection_triggered?(dir)
 
-      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
-        f.write(@cached_data.to_json(offenses))
-      end
-      # The preliminary path is used so that if there are multiple RuboCop
-      # processes trying to save data for the same inspected file
-      # simultaneously, the only problem we run in to is a competition who gets
-      # to write to the final file. The contents are the same, so no corruption
-      # of data should occur.
-      FileUtils.mv(preliminary_path, @path)
+      write_cache_file(offenses)
     end
 
     private
@@ -154,26 +168,49 @@ module RuboCop
       false
     end
 
+    def write_cache_file(offenses)
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
+      FileUtils.rm_f(preliminary_path)
+      warn "Couldn't write cache file. Continuing without cache.\n  #{e.message}"
+    end
+
     def file_checksum(file, config_store)
+      stat = File.stat(file)
+      return unavailable_checksum unless stat.file?
+
       digester = Digest::SHA1.new
-      mode = File.stat(file).mode
-      digester.update("#{file}#{mode}#{config_store.for_file(file).signature}")
+      digester.update("#{file}#{stat.mode}#{config_store.for_file(file).signature}")
       digester.file(file)
       digester.hexdigest
     rescue Errno::ENOENT
-      # Spurious files that come and go should not cause a crash, at least not
-      # here.
+      # Spurious files that come and go should not cause a crash, at least not here.
+      unavailable_checksum
+    end
+
+    # Every file that fails to checksum shares this sentinel value, so the cache entry
+    # must be neither saved nor considered valid, or one file's cached results could be
+    # served as another's.
+    def unavailable_checksum
+      @checksum_unavailable = true
       '_'
     end
 
     class << self
-      attr_accessor :source_checksum, :inhibit_cleanup
-    end
+      attr_accessor :inhibit_cleanup
 
-    # The checksum of the RuboCop program running the inspection.
-    def rubocop_checksum
-      ResultCache.source_checksum ||=
-        begin
+      # The checksum of the RuboCop program running the inspection.
+      def source_checksum
+        @source_checksum ||= begin
           digest = Digest::SHA1.new
           rubocop_extra_features
             .select { |path| File.file?(path) }
@@ -184,42 +221,50 @@ module RuboCop
           digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
           digest.hexdigest
         end
-    end
+      end
 
-    def digest(path)
-      content = if path.end_with?(*DL_EXTENSIONS)
-                  # Shared libraries often contain timestamps of when
-                  # they were compiled and other non-stable data.
-                  File.basename(path)
-                else
-                  File.binread(path) # mtime not reliable
-                end
-      Zlib.crc32(content).to_s
-    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
 
-    def rubocop_extra_features
-      lib_root = File.join(File.dirname(__FILE__), '..')
-      exe_root = File.join(lib_root, '..', 'exe')
+      private
 
-      # Make sure to use an absolute path to prevent errors on Windows
-      # when traversing the relative paths with symlinks.
-      exe_root = File.absolute_path(exe_root)
+      def digest(path)
+        content = if path.end_with?(*DL_EXTENSIONS)
+                    # Shared libraries often contain timestamps of when
+                    # they were compiled and other non-stable data.
+                    File.basename(path)
+                  else
+                    File.binread(path) # mtime not reliable
+                  end
+        Zlib.crc32(content).to_s
+      end
 
-      # These are all the files we have `require`d plus everything in the
-      # exe directory. A change to any of them could affect the cop output
-      # so we include them in the cache hash.
-      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
-      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+      def rubocop_extra_features
+        lib_root = File.join(File.dirname(__FILE__), '..')
+        exe_root = File.join(lib_root, '..', 'exe')
 
-      source_files
-    end
+        # Make sure to use an absolute path to prevent errors on Windows
+        # when traversing the relative paths with symlinks.
+        exe_root = File.absolute_path(exe_root)
 
-    # 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, '_')
+        # These are all the files we have `require`d, all of RuboCop's own files whether loaded
+        # or not (cops are loaded lazily, so which of them are in `$LOADED_FEATURES` varies from
+        # run to run), plus everything in the exe directory. A change to any of them could affect
+        # the cop output so we include them in the cache hash.
+        rubocop_lib_files = Dir[File.join(File.absolute_path(lib_root), 'rubocop', '**', '*.rb')]
+        source_files = $LOADED_FEATURES | rubocop_lib_files | Find.find(exe_root).to_a
+        source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+
+        source_files
+      end
     end
 
     # We combine team and options into a single "context" checksum to avoid
@@ -227,7 +272,7 @@ module RuboCop
     # 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,13 +6,33 @@ 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
   end
-  let(:parser_engine) { ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym }
+  let(:parser_engine) do
+    # The maximum version Parser can correctly parse is 3.3.
+    ruby_version >= 3.4 ? :parser_prism : ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym
+  end
   let(:rails_version) { false }
 
+  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)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}

data/lib/rubocop/rspec/expect_offense.rb

@@ -72,9 +72,15 @@ module RuboCop
     #
     #   expect_no_corrections
     #
-    # If your code has variables of different lengths, you can use `%{foo}`,
-    # `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
-    # offense messages with `[...]`:
+    # If your code has variables of different lengths, you can use the
+    # following markers to format your template by passing the variables as a
+    # keyword arguments:
+    #
+    # - `%{foo}`: Interpolates `foo`
+    # - `^{foo}`: Inserts `'^' * foo.size` for dynamic offense range length
+    # - `_{foo}`: Inserts `' ' * foo.size` for dynamic offense range indentation
+    #
+    # You can also abbreviate offense messages with `[...]`.
     #
     #   %w[raise fail].each do |keyword|
     #     expect_offense(<<~RUBY, keyword: keyword)
@@ -111,7 +117,7 @@ module RuboCop
         source
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
         expected_annotations = parse_annotations(source, **replacements)
         source = expected_annotations.plain_source
@@ -132,9 +138,8 @@ module RuboCop
 
         @offenses
       end
-      # rubocop:enable Metrics/AbcSize
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -171,7 +176,6 @@ module RuboCop
         expect(new_source).to eq(correction)
         expect(@processed_source).to be_valid_syntax, 'Expected correction to be valid syntax'
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source

data/lib/rubocop/rspec/shared_contexts.rb

@@ -2,11 +2,18 @@
 
 require 'tmpdir'
 
-RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLength
+# 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 } }
+
+# rubocop:disable-next Metrics/BlockLength
+RSpec.shared_context 'isolated environment' do
   around do |example|
     Dir.mktmpdir do |tmpdir|
       original_home = Dir.home
       original_xdg_config_home = ENV.fetch('XDG_CONFIG_HOME', nil)
+      original_xdg_cache_home = ENV.fetch('XDG_CACHE_HOME', nil)
+      original_rubocop_cache_root = ENV.fetch('RUBOCOP_CACHE_ROOT', nil)
 
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
@@ -19,6 +26,12 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       ENV['HOME'] = virtual_home
       ENV.delete('XDG_CONFIG_HOME')
 
+      # `XDG_CACHE_HOME` and `RUBOCOP_CACHE_ROOT` are set on some CI runners and
+      # would otherwise point the result cache at a fixed directory shared across examples
+      # and parallel test-queue workers, letting one example's cache leak into another.
+      ENV.delete('XDG_CACHE_HOME')
+      ENV.delete('RUBOCOP_CACHE_ROOT')
+
       base_dir = example.metadata[:project_inside_home] ? virtual_home : tmpdir
       root = example.metadata[:root]
       working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
@@ -26,12 +39,19 @@ 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
+        ENV['XDG_CACHE_HOME'] = original_xdg_cache_home
+        ENV['RUBOCOP_CACHE_ROOT'] = original_rubocop_cache_root
 
-        RuboCop::FileFinder.root_level = nil
+        RuboCop::ResultCache.reset_config_cache
+        RuboCop::ConfigLoader.clear_options # This also resets RuboCop::FileFinder.root_level
       end
     end
   end
@@ -80,6 +100,21 @@ RSpec.shared_context 'maintain registry' do
   end
 end
 
+RSpec.shared_context 'maintain default configuration' do
+  around(:each) do |example|
+    # Make a copy of the current configuration that will not change when source hash changes
+    default_configuration = RuboCop::ConfigLoader.default_configuration
+    config = RuboCop::Config.create(
+      default_configuration.to_h.clone,
+      default_configuration.loaded_path
+    )
+
+    example.run
+
+    RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+  end
+end
+
 # This context assumes nothing and defines `cop`, among others.
 RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
   ### Meant to be overridden at will
@@ -100,6 +135,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
   let(:gem_versions) { {} }
 
+  let(:path_sourced_gems) { [] }
+
   ### Utilities
 
   def source_range(range, buffer: source_buffer)
@@ -144,6 +181,7 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
         **gem_versions.transform_values { |value| Gem::Version.new(value) }
       }
     )
+    allow(config).to receive(:path_sourced_gems_in_target).and_return(path_sourced_gems)
 
     config
   end
@@ -163,6 +201,21 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
+RSpec.shared_context 'mock obsoletion' do
+  include_context 'mock console output'
+
+  let(:obsoletion_configuration_path) { 'obsoletions.yml' }
+
+  before do
+    RuboCop::ConfigObsoletion.reset!
+    allow(RuboCop::ConfigObsoletion).to receive(:files).and_return([obsoletion_configuration_path])
+  end
+
+  after do
+    RuboCop::ConfigObsoletion.reset!
+  end
+end
+
 RSpec.shared_context 'lsp' do
   before do
     RuboCop::LSP.enable
@@ -173,6 +226,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 }
@@ -235,3 +309,11 @@ end
 RSpec.shared_context 'ruby 3.4' do
   let(:ruby_version) { 3.4 }
 end
+
+RSpec.shared_context 'ruby 4.0' do
+  let(:ruby_version) { 4.0 }
+end
+
+RSpec.shared_context 'ruby 4.1' do
+  let(:ruby_version) { 4.1 }
+end

data/lib/rubocop/rspec/support.rb

@@ -15,6 +15,8 @@ RSpec.configure do |config|
   config.include_context 'isolated bundler', :isolated_bundler
   config.include_context 'lsp', :lsp
   config.include_context 'maintain registry', :restore_registry
+  config.include_context 'maintain default configuration', :restore_configuration
+  config.include_context 'mock obsoletion', :mock_obsoletion
   config.include_context 'ruby 2.0', :ruby20
   config.include_context 'ruby 2.1', :ruby21
   config.include_context 'ruby 2.2', :ruby22
@@ -28,4 +30,6 @@ RSpec.configure do |config|
   config.include_context 'ruby 3.2', :ruby32
   config.include_context 'ruby 3.3', :ruby33
   config.include_context 'ruby 3.4', :ruby34
+  config.include_context 'ruby 4.0', :ruby40
+  config.include_context 'ruby 4.1', :ruby41
 end