rubocop 1.79.2 → 1.87.0

data/lib/rubocop/runner.rb

@@ -62,14 +62,21 @@ module RuboCop
       @errors = []
       @warnings = []
       @aborting = false
+      @inspected_files = []
+      @report_queue = {}
     end
 
     def run(paths)
+      # Compute the cache source checksum once to avoid potential
+      # inconsistencies between workers.
+      ResultCache.source_checksum
+
       target_files = find_target_files(paths)
+      @project_index = ProjectIndexLoader.build_index(target_files) if project_index_enabled?
+
       if @options[:list_target_files]
         list_files(target_files)
       else
-        warm_cache(target_files) if @options[:parallel]
         inspect_files(target_files)
       end
     rescue Interrupt
@@ -86,21 +93,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]
@@ -112,12 +104,26 @@ module RuboCop
       target_files.each(&:freeze).freeze
     end
 
-    def inspect_files(files)
-      inspected_files = []
+    def project_index_enabled?
+      return false unless @config_store.for_pwd.for_all_cops['UseProjectIndex']
 
+      unless ProjectIndexLoader.available?
+        ProjectIndexLoader.warn_unavailable
+        return false
+      end
+
+      true
+    end
+
+    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
@@ -125,23 +131,88 @@ 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
+
+    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
 
-        all_passed
+    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
+
+      return false if project_index_disables_parallel?
+
+      puts 'Running parallel inspection' if @options[:debug]
+
+      true
+    end
+
+    def project_index_disables_parallel?
+      return false if @project_index.nil? || !Gem.win_platform?
+
+      if @options[:debug]
+        puts 'Skipping parallel inspection: the project index is enabled and parallel ' \
+             'inspection is not yet supported on Windows.'
+      end
+
+      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
 
@@ -150,16 +221,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)
@@ -190,7 +258,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
@@ -246,6 +314,7 @@ module RuboCop
     end
 
     def file_finished(file, offenses)
+      @inspected_files << file
       offenses = offenses_to_report(offenses)
       formatter_set.file_finished(file, offenses)
     end
@@ -254,10 +323,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
@@ -273,7 +338,8 @@ module RuboCop
     end
 
     def do_inspection_loop(file)
-      processed_source = get_processed_source(file)
+      # We can reuse the prism result since the source did not change yet.
+      processed_source = get_processed_source(file, @prism_result)
       # This variable is 2d array used to track corrected offenses after each
       # inspection iteration. This is used to output meaningful infinite loop
       # error message.
@@ -295,7 +361,8 @@ module RuboCop
         # loop if we find any.
         break unless updated_source_file
 
-        processed_source = get_processed_source(file)
+        # Autocorrect has happened, don't use the prism result since it is stale.
+        processed_source = get_processed_source(file, nil)
       end
 
       # Return summary of corrected offenses after all iterations
@@ -344,16 +411,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
 
@@ -373,7 +433,15 @@ module RuboCop
 
     def mobilize_team(processed_source)
       config = @config_store.for_file(processed_source.path)
-      Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+      team = Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+
+      if @project_index
+        team.cops.each do |cop|
+          cop.project_index = @project_index
+        end
+      end
+
+      team
     end
 
     def mobilized_cop_classes(config) # rubocop:disable Metrics/AbcSize
@@ -482,7 +550,7 @@ module RuboCop
     end
 
     # rubocop:disable Metrics/MethodLength
-    def get_processed_source(file)
+    def get_processed_source(file, prism_result)
       config = @config_store.for_file(file)
       ruby_version = config.target_ruby_version
       parser_engine = config.parser_engine
@@ -493,7 +561,7 @@ module RuboCop
                              ruby_version,
                              file,
                              parser_engine: parser_engine,
-                             prism_result: @prism_result
+                             prism_result: prism_result
                            )
                          else
                            begin
@@ -516,8 +584,17 @@ module RuboCop
     # level caching in ResultCache.
     def standby_team(config)
       @team_by_config ||= {}.compare_by_identity
-      @team_by_config[config] ||=
-        Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+      @team_by_config[config] ||= begin
+        team = Cop::Team.mobilize(mobilized_cop_classes(config), config, @options)
+
+        if @project_index
+          team.cops.each do |cop|
+            cop.project_index = @project_index
+          end
+        end
+
+        team
+      end
     end
   end
 end

data/lib/rubocop/server/cache.rb

@@ -73,33 +73,12 @@ module RuboCop
           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
@@ -135,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,18 +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)
-      # 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 = if base_dir.include?(HIDDEN_PATH_SUBSTRING)
+      target_files = if hidden_dir?(base_dir)
                        all_files.select { |file| ruby_file?(file) }
                      else
-                       all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+                       all_files.select { |file| to_inspect?(file, base_dir, base_dir_config) }
                      end
 
       target_files.sort_by!(&order)
@@ -74,18 +72,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
 

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 = {
@@ -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/version.rb

@@ -3,12 +3,13 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.79.2'
+    STRING = '1.87.0'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'analyzing as Ruby %<target_ruby_version>s, ' \
-          'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
+          'running on %<ruby_engine>s %<ruby_version>s)' \
+          '%<rubydex_indicator>s%<server_mode>s [%<ruby_platform>s]'
 
     MINIMUM_PARSABLE_PRISM_VERSION = 3.3
 
@@ -31,6 +32,7 @@ module RuboCop
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
                                       target_ruby_version: target_ruby_version,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                                      rubydex_indicator: rubydex_indicator(env),
                                       server_mode: server_mode,
                                       ruby_platform: RUBY_PLATFORM)
         return verbose_version unless env
@@ -55,7 +57,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
@@ -152,6 +154,22 @@ module RuboCop
       STRING.match('\d+\.\d+').to_s
     end
 
+    # @api private
+    def self.rubydex_indicator(env)
+      env && rubydex_enabled?(env) && ProjectIndexLoader.available? ? ' +Rubydex' : ''
+    end
+
+    # @api private
+    def self.rubydex_enabled?(env)
+      config_for_pwd(env).for_all_cops['UseProjectIndex']
+    rescue StandardError
+      # Keep `rubocop -V` usable when the config cannot be loaded (broken YAML,
+      # missing `inherit_from` target, etc). It is the first command users run to
+      # diagnose a broken setup, so the indicator just hides rather than letting
+      # the version banner crash.
+      false
+    end
+
     # @api private
     def self.server_mode
       RuboCop.const_defined?(:Server) && Server.running? ? ' +server' : ''