rubocop 1.86.1 → 1.87.0

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 mcp].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
@@ -89,6 +91,8 @@ module RuboCop
         option(opts, '-F', '--fail-fast')
         option(opts, '--disable-pending-cops')
         option(opts, '--enable-pending-cops')
+        option(opts, '--disable-all-cops')
+        option(opts, '--enable-all-cops')
         option(opts, '--ignore-disable-comments')
         option(opts, '--force-exclusion')
         option(opts, '--only-recognized-file-types')
@@ -236,6 +240,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
@@ -393,6 +398,7 @@ module RuboCop
       validate_display_only_failed_and_display_only_correctable
       validate_display_only_correctable_and_autocorrect
       validate_lsp_and_editor_mode
+      validate_enable_all_cops_and_disable_all_cops
       disable_parallel_when_invalid_option_combo
 
       return if incompatible_options.size <= 1
@@ -446,6 +452,13 @@ module RuboCop
       raise OptionArgumentError, 'Do not specify `--editor-mode` as it is redundant in `--lsp`.'
     end
 
+    def validate_enable_all_cops_and_disable_all_cops
+      return if !@options.key?(:enable_all_cops) || !@options.key?(:disable_all_cops)
+
+      raise OptionArgumentError,
+            '--enable-all-cops cannot be used together with --disable-all-cops.'
+    end
+
     def validate_autocorrect
       if @options.key?(:safe_autocorrect) && @options.key?(:autocorrect_all)
         message = Rainbow(<<~MESSAGE).red
@@ -474,8 +487,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
@@ -599,7 +611,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.'],
@@ -619,8 +631,16 @@ module RuboCop
       display_cop_names:                ['Display cop names in offense messages.',
                                          'Default is true.'],
       disable_pending_cops:             'Run without pending cops.',
+      disable_all_cops:                 ['Run with all cops disabled by default,',
+                                         'except `Lint/Syntax`. Overrides',
+                                         '`AllCops/EnabledByDefault` and',
+                                         '`AllCops/DisabledByDefault` in config files.'],
       display_style_guide:              'Display style guide URLs in offense messages.',
       enable_pending_cops:              'Run with pending cops.',
+      enable_all_cops:                  ['Run with all cops enabled, including those',
+                                         'disabled by default. Overrides',
+                                         '`AllCops/EnabledByDefault` and',
+                                         '`AllCops/DisabledByDefault` in config files.'],
       extra_details:                    'Display extra details in offense messages.',
       lint:                             'Run only lint cops.',
       safe:                             'Run only safe cops.',
@@ -628,6 +648,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)',

data/lib/rubocop/project_index_loader.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Defensive loader for the optional `rubydex` gem.
+  #
+  # When `AllCops/UseProjectIndex` is enabled in the user's configuration, RuboCop builds
+  # a project-wide index using `Rubydex::Graph` and exposes it to cops that opt in.
+  # The gem is intentionally not a runtime dependency; if it is not installed,
+  # or if the running Ruby is older than what `rubydex` supports, RuboCop falls back to
+  # its standard file-local behavior.
+  module ProjectIndexLoader
+    MINIMUM_RUBY_VERSION = '3.2'
+
+    module_function
+
+    # Returns whether the `rubydex` gem can be loaded. The result is memoized
+    # for the lifetime of the process.
+    def available?
+      return @available if defined?(@available)
+
+      @available = supported_ruby? && try_require
+    end
+
+    def supported_ruby?
+      RUBY_VERSION >= MINIMUM_RUBY_VERSION
+    end
+
+    def warn_unavailable
+      return if @warned
+
+      @warned = true
+
+      if supported_ruby?
+        warn Rainbow(<<~MSG).yellow
+          `AllCops/UseProjectIndex` is enabled but the `rubydex` gem is not installed.
+          Analyses that use the project index will be skipped. Add `gem 'rubydex'` to your Gemfile.
+        MSG
+      else
+        warn Rainbow(<<~MSG).yellow
+          `AllCops/UseProjectIndex` is enabled but `rubydex` requires Ruby #{MINIMUM_RUBY_VERSION} or later (current: #{RUBY_VERSION}).
+          Analyses that use the project index will be skipped.
+        MSG
+      end
+    end
+
+    def try_require
+      require 'rubydex'
+      true
+    rescue LoadError
+      false
+    end
+
+    # Builds and resolves a `Rubydex::Graph` for the given file paths. Returns the resolved graph,
+    # or `nil` if the build fails. This is the only place in RuboCop that depends on the concrete
+    # `Rubydex::Graph` API, so callers (e.g. `Runner`) do not need to know which Rubydex classes
+    # or methods are involved.
+    def build_index(paths)
+      graph = Rubydex::Graph.new
+      graph.index_all(paths.map(&:to_s))
+      graph.resolve
+      graph
+    rescue StandardError => e
+      warn Rainbow("rubydex index build failed: #{e.message}. Continuing without it.").yellow
+    end
+  end
+end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -212,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)
@@ -70,10 +72,11 @@ module RuboCop
       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
@@ -90,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]
@@ -116,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
@@ -129,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
 
@@ -154,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)
@@ -250,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
@@ -258,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
@@ -350,21 +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.each 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)
-        offenses.concat(report.offenses)
-
-        break if team.updated_source_file?
-      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
 
@@ -384,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
@@ -527,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/target_finder.rb

@@ -44,10 +44,10 @@ module RuboCop
       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/version.rb

@@ -3,12 +3,13 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.86.1'
+    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
@@ -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' : ''