rubocop 1.69.2 → 1.75.4

data/lib/rubocop/plugin/loader.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../feature_loader'
+require_relative 'load_error'
+
+module RuboCop
+  module Plugin
+    # A class for loading and resolving plugins.
+    # @api private
+    class Loader
+      # rubocop:disable Layout/LineLength
+      DEFAULT_PLUGIN_CONFIG = {
+        'enabled' => true,
+        'require_path' => nil, # If not set, will be set to the plugin name
+        'plugin_class_name' => nil # If not set, looks for gemspec `spec.metadata["default_lint_roller_plugin"]`
+      }.freeze
+
+      # rubocop:enable Layout/LineLength
+      class << self
+        def load(plugins)
+          normalized_plugin_configs = normalize(plugins)
+          normalized_plugin_configs.filter_map do |plugin_name, plugin_config|
+            next unless plugin_config['enabled']
+
+            plugin_class = constantize_plugin_from(plugin_name, plugin_config)
+
+            plugin_class.new(plugin_config)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def normalize(plugin_configs)
+          plugin_configs.to_h do |plugin_config|
+            if plugin_config == Plugin::OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+              warn Rainbow(<<~MESSAGE).yellow
+                Specify `rubocop-internal_affairs` instead of `rubocop/cop/internal_affairs` in your configuration.
+              MESSAGE
+              plugin_config = Plugin::INTERNAL_AFFAIRS_PLUGIN_NAME
+            end
+
+            if plugin_config.is_a?(Hash)
+              plugin_name = plugin_config.keys.first
+
+              [
+                plugin_name, DEFAULT_PLUGIN_CONFIG.merge(
+                  { 'require_path' => plugin_name }, plugin_config.values.first
+                )
+              ]
+            # NOTE: Compatibility is maintained when `require: rubocop/cop/internal_affairs` remains
+            # specified in `.rubocop.yml`.
+            elsif (builtin_plugin_config = Plugin::BUILTIN_INTERNAL_PLUGINS[plugin_config])
+              [plugin_config, builtin_plugin_config]
+            else
+              [plugin_config, DEFAULT_PLUGIN_CONFIG.merge('require_path' => plugin_config)]
+            end
+          end
+        end
+
+        def constantize_plugin_from(plugin_name, plugin_config)
+          if plugin_name.is_a?(String) || plugin_name.is_a?(Symbol)
+            constantize(plugin_name, plugin_config)
+          else
+            plugin_name
+          end
+        end
+
+        # rubocop:enable Metrics/MethodLength
+        def constantize(plugin_name, plugin_config)
+          require_plugin(plugin_config['require_path'])
+
+          if (constant_name = plugin_config['plugin_class_name'])
+            begin
+              Kernel.const_get(constant_name)
+            rescue StandardError
+              raise <<~MESSAGE
+                Failed while configuring plugin `#{plugin_name}': no constant with name `#{constant_name}' was found.
+              MESSAGE
+            end
+          else
+            constantize_plugin_from_gemspec_metadata(plugin_name)
+          end
+        end
+
+        def require_plugin(require_path)
+          FeatureLoader.load(config_directory_path: Dir.pwd, feature: require_path)
+        end
+
+        def constantize_plugin_from_gemspec_metadata(plugin_name)
+          plugin_class_name = Gem.loaded_specs[plugin_name].metadata['default_lint_roller_plugin']
+
+          Kernel.const_get(plugin_class_name)
+        rescue LoadError, StandardError
+          raise Plugin::LoadError, plugin_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/not_supported_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Plugin
+    # An exception raised when a plugin is not supported by the RuboCop engine.
+    # @api private
+    class NotSupportedError < Error
+      def initialize(unsupported_plugins)
+        super
+
+        @unsupported_plugins = unsupported_plugins
+      end
+
+      def message
+        if @unsupported_plugins.one?
+          about = @unsupported_plugins.first.about
+
+          "#{about.name} #{about.version} is not a plugin supported by RuboCop engine."
+        else
+          unsupported_plugin_names = @unsupported_plugins.map do |plugin|
+            "#{plugin.about.name} #{plugin.about.version}"
+          end.join(', ')
+
+          "#{unsupported_plugin_names} are not plugins supported by RuboCop engine."
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'plugin/configuration_integrator'
+require_relative 'plugin/loader'
+
+module RuboCop
+  # Provides a plugin for RuboCop extensions that conform to lint_roller.
+  # https://github.com/standardrb/lint_roller
+  # @api private
+  module Plugin
+    BUILTIN_INTERNAL_PLUGINS = {
+      'rubocop-internal_affairs' => {
+        'enabled' => true,
+        'require_path' => 'rubocop/cop/internal_affairs/plugin',
+        'plugin_class_name' => 'RuboCop::InternalAffairs::Plugin'
+      }
+    }.freeze
+    INTERNAL_AFFAIRS_PLUGIN_NAME = Plugin::BUILTIN_INTERNAL_PLUGINS.keys.first
+    OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME = 'rubocop/cop/internal_affairs'
+
+    class << self
+      def plugin_capable?(feature_name)
+        return true if BUILTIN_INTERNAL_PLUGINS.key?(feature_name)
+        return true if feature_name == OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+
+        begin
+          # When not using Bundler. Makes the spec available but does not require it.
+          gem feature_name
+        rescue Gem::LoadError
+          # The user requested a gem that they do not have installed
+        end
+        return false unless (spec = Gem.loaded_specs[feature_name])
+
+        !!spec.metadata['default_lint_roller_plugin']
+      end
+
+      def integrate_plugins(rubocop_config, plugins)
+        plugins = Plugin::Loader.load(plugins)
+
+        ConfigurationIntegrator.integrate_plugins_into_rubocop_config(rubocop_config, plugins)
+
+        plugins
+      end
+    end
+  end
+end

data/lib/rubocop/rake_task.rb

@@ -12,7 +12,8 @@ module RuboCop
   # Use global Rake namespace here to avoid namespace issues with custom
   # rubocop-rake tasks
   class RakeTask < ::Rake::TaskLib
-    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :plugins, :requires,
+                  :options
 
     def initialize(name = :rubocop, *args, &task_block)
       super()
@@ -54,6 +55,7 @@ module RuboCop
 
     def full_options
       formatters.map { |f| ['--format', f] }.flatten
+                .concat(plugins.map { |plugin| ['--plugin', plugin] }.flatten)
                 .concat(requires.map { |r| ['--require', r] }.flatten)
                 .concat(options.flatten)
                 .concat(patterns)
@@ -64,6 +66,7 @@ module RuboCop
       @verbose = true
       @fail_on_error = true
       @patterns = []
+      @plugins = []
       @requires = []
       @options = []
       @formatters = []

data/lib/rubocop/result_cache.rb

@@ -25,16 +25,16 @@ module RuboCop
     # cleaning 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 = nil)
+    def self.cleanup(config_store, verbose, cache_root_override = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
 
-      cache_root ||= cache_root(config_store)
-      return unless File.exist?(cache_root)
+      rubocop_cache_dir = cache_root(config_store, cache_root_override)
+      return unless File.exist?(rubocop_cache_dir)
 
-      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      files, dirs = Find.find(rubocop_cache_dir).partition { |path| File.file?(path) }
       return unless requires_file_removal?(files.length, config_store)
 
-      remove_oldest_files(files, dirs, cache_root, verbose)
+      remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
     end
 
     class << self
@@ -49,11 +49,11 @@ module RuboCop
         file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
-      def remove_oldest_files(files, dirs, cache_root, verbose)
+      def remove_oldest_files(files, dirs, 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 #{cache_root}" if verbose
+        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
@@ -72,9 +72,9 @@ module RuboCop
       end
     end
 
-    def self.cache_root(config_store)
+    def self.cache_root(config_store, cache_root_override = nil)
       CacheConfig.root_dir do
-        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+        cache_root_override || config_store.for_pwd.for_all_cops['CacheRootDirectory']
       end
     end
 
@@ -84,12 +84,12 @@ module RuboCop
 
     attr_reader :path
 
-    def initialize(file, team, options, config_store, cache_root = nil)
-      cache_root ||= File.join(options[:cache_root], 'rubocop_cache') if options[:cache_root]
-      cache_root ||= ResultCache.cache_root(config_store)
+    def initialize(file, team, options, config_store, cache_root_override = nil)
+      cache_root_override ||= options[:cache_root] if options[:cache_root]
+      rubocop_cache_dir = ResultCache.cache_root(config_store, cache_root_override)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root,
+      @path = File.join(rubocop_cache_dir,
                         rubocop_checksum,
                         context_checksum(team, options),
                         file_checksum(file, config_store))

data/lib/rubocop/rspec/cop_helper.rb

@@ -10,9 +10,21 @@ module CopHelper
     # 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']
+
+    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)
+  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

@@ -190,7 +190,10 @@ module RuboCop
       def expect_no_offenses(source, file = nil)
         offenses = inspect_source(source, file)
 
-        expected_annotations = AnnotatedSource.parse(source)
+        # Since source given `expect_no_offenses` does not have annotations, we do not need to parse
+        # for them, and can just build an `AnnotatedSource` object from the source lines.
+        # This also prevents treating source lines that begin with a caret as an annotation.
+        expected_annotations = AnnotatedSource.new(source.each_line.to_a, [])
         actual_annotations = expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
@@ -221,7 +224,8 @@ module RuboCop
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) ?/.freeze
+        # Ignore escaped carets, don't treat as annotations
+        ANNOTATION_PATTERN = /\A\s*((?<!\\)\^+|\^{}) ?/.freeze
         ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers

data/lib/rubocop/rspec/shared_contexts.rb

@@ -80,6 +80,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
@@ -98,6 +113,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
   let(:cop_options) { {} }
 
+  let(:gem_versions) { {} }
+
   ### Utilities
 
   def source_range(range, buffer: source_buffer)
@@ -138,7 +155,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
     allow(config).to receive(:gem_versions_in_target).and_return(
       {
-        'railties' => rails_version_in_gemfile
+        'railties' => rails_version_in_gemfile,
+        **gem_versions.transform_values { |value| Gem::Version.new(value) }
       }
     )
 
@@ -160,6 +178,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
@@ -232,3 +265,7 @@ end
 RSpec.shared_context 'ruby 3.4' do
   let(:ruby_version) { 3.4 }
 end
+
+RSpec.shared_context 'ruby 3.5' do
+  let(:ruby_version) { 3.5 }
+end

data/lib/rubocop/rspec/support.rb

@@ -4,18 +4,19 @@
 
 require_relative 'cop_helper'
 require_relative 'expect_offense'
-require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
 require_relative 'shared_contexts'
 
 RSpec.configure do |config|
   config.include CopHelper
-  config.include HostEnvironmentSimulatorHelper
+  config.include RuboCop::RSpec::ExpectOffense
   config.include_context 'config', :config
   config.include_context 'isolated environment', :isolated_environment
   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
@@ -29,4 +30,5 @@ 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 3.5', :ruby35
 end

data/lib/rubocop/runner.rb

@@ -20,11 +20,7 @@ module RuboCop
         message = 'Infinite loop detected'
         message += " in #{path}" if path
         message += " and caused by #{root_cause}" if root_cause
-        message += "\n"
-        hint = 'Hint: Please update to the latest RuboCop version if not already in use, ' \
-               "and report a bug if the issue still occurs on this version.\n" \
-               'Please check the latest version at https://rubygems.org/gems/rubocop.'
-        super(Rainbow(message).red + Rainbow(hint).yellow)
+        super(message)
       end
     end
 
@@ -157,8 +153,11 @@ module RuboCop
       file_started(file)
       offenses = 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
-      raise
     ensure
       file_finished(file, offenses || [])
     end
@@ -490,7 +489,11 @@ module RuboCop
 
       processed_source = if @options[:stdin]
                            ProcessedSource.new(
-                             @options[:stdin], ruby_version, file, parser_engine: parser_engine
+                             @options[:stdin],
+                             ruby_version,
+                             file,
+                             parser_engine: parser_engine,
+                             prism_result: @prism_result
                            )
                          else
                            begin

data/lib/rubocop/server/cache.rb

@@ -2,8 +2,10 @@
 
 require 'digest'
 require 'pathname'
+require 'yaml'
 require_relative '../cache_config'
 require_relative '../config_finder'
+require_relative '../path_util'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -50,9 +52,12 @@ module RuboCop
           end.find(&:exist?)
           version_data = lockfile_path&.read || RuboCop::Version::STRING
           config_data = Pathname(ConfigFinder.find_config_path(Dir.pwd)).read
-          todo_data = (rubocop_todo = Pathname('.rubocop_todo.yml')).exist? ? rubocop_todo.read : ''
+          yaml = load_erb_templated_yaml(config_data)
 
-          Digest::SHA1.hexdigest(version_data + config_data + todo_data)
+          inherit_from_data = inherit_from_data(yaml)
+          require_data = require_data(yaml)
+
+          Digest::SHA1.hexdigest(version_data + config_data + inherit_from_data + require_data)
         end
         # rubocop:enable Metrics/AbcSize
 
@@ -72,7 +77,6 @@ module RuboCop
           File.expand_path(File.join(cache_root_dir, 'server'))
         end
 
-        # rubocop:disable Metrics/MethodLength
         def cache_root_dir_from_config
           CacheConfig.root_dir do
             # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
@@ -83,13 +87,7 @@ module RuboCop
             # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
             next unless file_contents.include?('CacheRootDirectory')
 
-            require 'erb'
-            yaml_code = ERB.new(file_contents).result
-
-            require 'yaml'
-            config_yaml = YAML.safe_load(
-              yaml_code, permitted_classes: [Regexp, Symbol], aliases: true
-            )
+            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')
@@ -99,7 +97,6 @@ module RuboCop
             config_yaml&.dig('AllCops', 'CacheRootDirectory')
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def port_path
           dir.join('port')
@@ -164,6 +161,45 @@ module RuboCop
         def write_version_file(version)
           version_path.write(version)
         end
+
+        def inherit_from_data(yaml)
+          return '' unless (inherit_from_paths = yaml['inherit_from'])
+
+          Array(inherit_from_paths).map do |path|
+            next if PathUtil.remote_file?(path)
+
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        def require_data(yaml)
+          return '' unless (require_paths = yaml['require'])
+
+          Array(require_paths).map do |path|
+            # NOTE: This targets only relative or absolute path specifications.
+            # For example, specifications like `require: rubocop-performance`,
+            # which can be loaded from `$LOAD_PATH`, are ignored.
+            next unless path.start_with?('.', '/')
+
+            # NOTE: `.so` files are not typically specified, so only `.rb` files are targeted.
+            path = "#{path}.rb" unless path.end_with?('.rb')
+            path = Pathname(path)
+
+            path.exist? ? path.read : ''
+          end.join
+        end
+
+        private
+
+        def load_erb_templated_yaml(content)
+          require 'erb'
+          yaml_code = ERB.new(content).result
+
+          require 'yaml'
+          YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol], aliases: true)
+        end
       end
     end
   end

data/lib/rubocop/server/cli.rb

@@ -86,7 +86,7 @@ module RuboCop
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def run_command(server_command, detach:)
         case server_command
         when '--server'
@@ -107,7 +107,7 @@ module RuboCop
           Server::ClientCommand::Status.new.run
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      # 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/target_finder.rb

@@ -46,7 +46,11 @@ module RuboCop
       hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+      target_files = if base_dir.include?(HIDDEN_PATH_SUBSTRING)
+                       all_files.select { |file| ruby_file?(file) }
+                     else
+                       all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
+                     end
 
       target_files.sort_by!(&order)
     end
@@ -127,6 +131,7 @@ module RuboCop
       if mode == :only_recognized_file_types || force_exclusion?
         files.select! { |file| included_file?(file) }
       end
+      files.reject! { |file| FileTest.directory?(file) }
 
       force_exclusion? ? without_excluded(files) : files
     end
@@ -174,7 +179,7 @@ module RuboCop
     end
 
     def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+      return false if !File.extname(file).empty? || !File.exist?(file) || File.empty?(file)
 
       first_line = File.open(file, &:readline)
       /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)

data/lib/rubocop/target_ruby.rb

@@ -4,7 +4,7 @@ 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].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, 3.5].freeze
     DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
@@ -34,6 +34,20 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be configured by setting the
+    # `RUBOCOP_TARGET_RUBY_VERSION` environment variable.
+    class RuboCopEnvVar < Source
+      def name
+        '`RUBOCOP_TARGET_RUBY_VERSION` environment variable'
+      end
+
+      private
+
+      def find_version
+        ENV.fetch('RUBOCOP_TARGET_RUBY_VERSION', nil)&.to_f
+      end
+    end
+
     # The target ruby version may be configured in RuboCop's config.
     # @api private
     class RuboCopConfig < Source
@@ -246,6 +260,7 @@ module RuboCop
     end
 
     SOURCES = [
+      RuboCopEnvVar,
       RuboCopConfig,
       GemspecFile,
       RubyVersionFile,