rubocop 1.71.1 → 1.92.0

data/lib/rubocop/config_loader.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'yaml'
+require_relative 'cache_config'
 require_relative 'config_finder'
 
 module RuboCop
@@ -22,41 +23,48 @@ module RuboCop
     class << self
       include FileFinder
 
-      PENDING_BANNER = <<~BANNER
-        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
-
-        Please also note that you can opt-in to new cops by default by adding this to your config:
-          AllCops:
-            NewCops: enable
-      BANNER
-
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops
-      attr_writer :default_configuration
-      attr_reader :loaded_features
+                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops,
+                    :preview
+      attr_writer :default_configuration, :cache_root
+      attr_reader :loaded_plugins, :loaded_features
 
       alias debug? debug
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
+      def cache_root(cache_root_override = nil)
+        @cache_root ||= CacheConfig.root_dir_from_toplevel_config(cache_root_override)
+      end
+
       def clear_options
         @debug = nil
+        @loaded_plugins = Set.new
         @loaded_features = Set.new
         @disable_pending_cops = nil
         @enable_pending_cops = nil
+        @preview = nil
+        @enabled_by_default = nil
+        @disabled_by_default = nil
         @ignore_parent_exclusion = nil
         @ignore_unrecognized_cops = nil
+        @cache_root = nil
         FileFinder.root_level = nil
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def load_file(file, check: true)
         path = file_path(file)
 
         hash = load_yaml_configuration(path)
 
+        rubocop_config = Config.create(hash, path, check: false)
+        plugins = hash.delete('plugins')
+        loaded_plugins = resolver.resolve_plugins(rubocop_config, plugins)
+        add_loaded_plugins(loaded_plugins)
+
         loaded_features = resolver.resolve_requires(path, hash)
         add_loaded_features(loaded_features)
 
-        resolver.override_department_setting_for_cops({}, hash)
         resolver.resolve_inheritance_from_gems(hash)
         resolver.resolve_inheritance(path, hash, file, debug?)
         hash.delete('inherit_from')
@@ -76,7 +84,9 @@ module RuboCop
 
         puts "configuration from #{absolute_path}" if debug?
 
-        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+        unless hash.is_a?(Hash)
+          raise(ValidationError, "Malformed configuration in #{absolute_path}")
+        end
 
         hash
       end
@@ -84,8 +94,12 @@ module RuboCop
       def add_missing_namespaces(path, hash)
         # Using `hash.each_key` will cause the
         # `can't add a new key into hash during iteration` error
+        obsoletion = ConfigObsoletion.new(hash)
+
         hash_keys = hash.keys
         hash_keys.each do |key|
+          next if obsoletion.deprecated_cop_name?(key)
+
           q = Cop::Registry.qualified_cop_name(key, path)
           next if q == key
 
@@ -110,7 +124,7 @@ module RuboCop
       end
 
       def configuration_from_file(config_file, check: true)
-        return default_configuration if config_file == DEFAULT_FILE
+        return apply_default_overrides(default_configuration) if config_file == DEFAULT_FILE
 
         config = load_file(config_file, check: check)
         config.validate_after_resolution if check
@@ -121,21 +135,7 @@ module RuboCop
           add_excludes_from_files(config, config_file)
         end
 
-        merge_with_default(config, config_file).tap do |merged_config|
-          unless possible_new_cops?(merged_config)
-            pending_cops = pending_cops_only_qualified(merged_config.pending_cops)
-            warn_on_pending_cops(pending_cops) unless pending_cops.empty?
-          end
-        end
-      end
-
-      def pending_cops_only_qualified(pending_cops)
-        pending_cops.select { |cop| Cop::Registry.qualified_cop?(cop.name) }
-      end
-
-      def possible_new_cops?(config)
-        disable_pending_cops || enable_pending_cops ||
-          config.disabled_new_cops? || config.enabled_new_cops?
+        merge_with_default(config, config_file)
       end
 
       def add_excludes_from_files(config, config_file)
@@ -155,13 +155,26 @@ module RuboCop
         end
       end
 
-      # @api private
-      def inject_defaults!(project_root)
-        path = File.join(project_root, 'config', 'default.yml')
-        config = load_file(path)
-        new_config = ConfigLoader.merge_with_default(config, path)
-        puts "configuration from #{path}" if debug?
-        @default_configuration = new_config
+      # This API is primarily intended for testing and documenting plugins.
+      # When testing a plugin using `rubocop/rspec/support`, the plugin is loaded automatically,
+      # so this API is usually not needed. It is intended to be used only when implementing tests
+      # that do not use `rubocop/rspec/support`.
+      def inject_defaults!(config_yml_path)
+        if Pathname(config_yml_path).directory?
+          warn Rainbow(<<~MESSAGE).yellow, uplevel: 1
+            Use config YAML file path instead of project root directory.
+            e.g., `path/to/config/default.yml`
+          MESSAGE
+          raise ArgumentError,
+                'Passing a project root directory to `inject_defaults!` is no longer supported.'
+        end
+
+        path = config_yml_path.to_s
+        hash = ConfigLoader.load_yaml_configuration(path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+
+        @default_configuration =
+          ConfigLoader.merge_with_default(config, path, resolve_preview: false)
       end
 
       # Returns the path RuboCop inferred as the root of the project. No file
@@ -176,24 +189,37 @@ module RuboCop
         ConfigFinder.project_root
       end
 
-      def warn_on_pending_cops(pending_cops)
-        warn Rainbow(PENDING_BANNER).yellow
-
-        pending_cops.each { |cop| warn_pending_cop cop }
-
-        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
+      # Merges the given configuration with the default one.
+      def merge_with_default(config, config_file, unset_nil: true, resolve_preview: true)
+        resolver.merge_with_default(
+          config, config_file, unset_nil: unset_nil, resolve_preview: resolve_preview
+        )
       end
 
-      def warn_pending_cop(cop)
-        version = cop.metadata['VersionAdded'] || 'N/A'
+      # Applies CLI overrides for `AllCops/EnabledByDefault` and
+      # `AllCops/DisabledByDefault` to the given configuration. Used when the
+      # configuration would otherwise be returned without going through
+      # `merge_with_default` (e.g. there is no user-supplied `.rubocop.yml`).
+      # Used when there is no configuration file, so the defaults are the whole
+      # configuration and still need the same treatment `merge_with_default`
+      # would have given them.
+      def apply_default_overrides(config)
+        hash = resolver.apply_preview_defaults(config, preview == true)
+
+        unless @enabled_by_default.nil? && @disabled_by_default.nil?
+          hash = hash.transform_values do |params|
+            params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+          end
+        end
 
-        warn Rainbow("#{cop.name}: # new in #{version}").yellow
-        warn Rainbow('  Enabled: true').yellow
+        Config.new(hash, config.loaded_path)
       end
 
-      # Merges the given configuration with the default one.
-      def merge_with_default(config, config_file, unset_nil: true)
-        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
+      # @api private
+      # Used to add plugins that were required inside a config or from
+      # the CLI using `--plugin`.
+      def add_loaded_plugins(loaded_plugins)
+        @loaded_plugins.merge(Array(loaded_plugins))
       end
 
       # @api private

data/lib/rubocop/config_loader_resolver.rb

@@ -2,38 +2,59 @@
 
 require 'pathname'
 require 'yaml'
+require_relative 'plugin'
 
 module RuboCop
   # A help class for ConfigLoader that handles configuration resolution.
   # @api private
   class ConfigLoaderResolver # rubocop:disable Metrics/ClassLength
+    def resolve_plugins(rubocop_config, plugins)
+      plugins = Array(plugins) - ConfigLoader.loaded_plugins.map { |plugin| plugin.about.name }
+      return if plugins.empty?
+
+      Plugin.integrate_plugins(rubocop_config, plugins)
+    end
+
     def resolve_requires(path, hash)
       config_dir = File.dirname(path)
       hash.delete('require').tap do |loaded_features|
         Array(loaded_features).each do |feature|
-          FeatureLoader.load(config_directory_path: config_dir, feature: feature)
+          if Plugin.plugin_capable?(feature)
+            # NOTE: Compatibility for before plugins style.
+            warn Rainbow(<<~MESSAGE).yellow
+              #{feature} extension supports plugin, specify `plugins: #{feature}` instead of `require: #{feature}` in #{path}.
+              For more information, see https://docs.rubocop.org/rubocop/plugin_migration_guide.html.
+            MESSAGE
+            rubocop_config = Config.create(hash, path, check: false)
+
+            resolve_plugins(rubocop_config, feature)
+          else
+            FeatureLoader.load(config_directory_path: config_dir, feature: feature)
+          end
         end
       end
     end
 
     def resolve_inheritance(path, hash, file, debug) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       inherited_files = Array(hash['inherit_from'])
-      base_configs(path, inherited_files, file)
-        .each_with_index.reverse_each do |base_config, index|
+      base_configs = base_configs(path, inherited_files, file)
+      preview = inherited_preview?(hash, base_configs)
+      base_configs.each_with_index.reverse_each do |base_config, index|
         override_department_setting_for_cops(base_config, hash)
         override_enabled_for_disabled_departments(base_config, hash)
 
         base_config.each do |k, v|
           next unless v.is_a?(Hash)
 
+          only_base_has_include = v.key?('Include') && !hash.dig(k, 'Include')
           if hash.key?(k)
             v = merge(v, hash[k],
                       cop_name: k, file: file, debug: debug,
                       inherited_file: inherited_files[index],
-                      inherit_mode: determine_inherit_mode(hash, k))
+                      inherit_mode: determine_inherit_mode(hash, k, preview))
           end
           hash[k] = v
-          fix_include_paths(base_config.loaded_path, hash, path, k, v) if v.key?('Include')
+          fix_include_paths(base_config.loaded_path, hash, path, k, v) if only_base_has_include
         end
       end
     end
@@ -72,22 +93,30 @@ module RuboCop
     # only cops from user configuration are enabled. If
     # AllCops:EnabledByDefault is true, it changes the Enabled params so that
     # only cops explicitly disabled in user configuration are disabled.
-    def merge_with_default(config, config_file, unset_nil:)
-      default_configuration = ConfigLoader.default_configuration
-
-      disabled_by_default = config.for_all_cops['DisabledByDefault']
-      enabled_by_default = config.for_all_cops['EnabledByDefault']
+    # When the `--disable-all-cops` or `--enable-all-cops` CLI option is given,
+    # it takes precedence over the configuration values.
+    #
+    # With `resolve_preview: false` the `Preview` sections of the default
+    # configuration are left in place and preview is treated as off. That is
+    # what extending the default configuration itself needs: preview gets
+    # applied later, when a project configuration is resolved against it.
+    def merge_with_default(config, config_file, unset_nil:, resolve_preview: true)
+      base_defaults, preview = defaults_with_preview(config, resolve_preview)
+      default_configuration = base_defaults
+      disabled_by_default, enabled_by_default = resolve_default_overrides(config)
 
       if disabled_by_default || enabled_by_default
-        default_configuration = transform(default_configuration) do |params|
+        default_configuration = transform(base_defaults) do |params|
           params.merge('Enabled' => !disabled_by_default)
         end
       end
 
-      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+      if disabled_by_default
+        config = handle_disabled_by_default(config, default_configuration, base_defaults)
+      end
       override_enabled_for_disabled_departments(default_configuration, config)
 
-      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
+      opts = { inherit_mode: inherit_mode_for_default(config, preview), unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
@@ -95,7 +124,7 @@ module RuboCop
     # with the addition that any value that is a hash, and occurs in both
     # arguments, will also be merged. And so on.
     #
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable-next Metrics/AbcSize
     def merge(base_hash, derived_hash, **opts)
       result = base_hash.merge(derived_hash)
       keys_appearing_in_both = base_hash.keys & derived_hash.keys
@@ -105,14 +134,13 @@ module RuboCop
         elsif merge_hashes?(base_hash, derived_hash, key)
           result[key] = merge(base_hash[key], derived_hash[key], **opts)
         elsif should_union?(derived_hash, base_hash, opts[:inherit_mode], key)
-          result[key] = base_hash[key] | derived_hash[key]
+          result[key] = Array(base_hash[key]) | Array(derived_hash[key])
         elsif opts[:debug]
           warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
         end
       end
       result
     end
-    # rubocop:enable Metrics/AbcSize
 
     # An `Enabled: true` setting in user configuration for a cop overrides an
     # `Enabled: false` setting for its department.
@@ -147,8 +175,63 @@ module RuboCop
       end
     end
 
+    # A cop's entry in the default configuration may carry a `Preview` section
+    # with the defaults it is expected to adopt in the next major release. Under
+    # `Preview` those replace the current defaults. The section is dropped either
+    # way, so the resolved configuration only ever shows what is in effect.
+    def apply_preview_defaults(default_configuration, preview)
+      transform(default_configuration) do |params|
+        next params unless params['Preview'].is_a?(Hash)
+
+        params = params.dup
+        preview_params = params.delete('Preview')
+        preview ? params.merge(preview_params) : params
+      end
+    end
+
     private
 
+    def defaults_with_preview(config, resolve_preview)
+      defaults = ConfigLoader.default_configuration
+      return [defaults, false] unless resolve_preview
+
+      preview = preview?(config)
+      [apply_preview_defaults(defaults, preview), preview]
+    end
+
+    def inherit_mode_for_default(config, preview)
+      with_preview_exclude_merge(config['inherit_mode'] || {}, preview)
+    end
+
+    # Under `Preview`, `Exclude` is merged rather than replaced, so that excluding
+    # one directory does not silently drop the excludes it would have inherited -
+    # from the default configuration or from a file named in `inherit_from`. An
+    # explicit `inherit_mode` still wins, in either direction.
+    def with_preview_exclude_merge(mode, preview)
+      return mode unless preview
+      return mode if Array(mode['override']).include?('Exclude')
+      return mode if Array(mode['merge']).include?('Exclude')
+
+      mode.merge('merge' => Array(mode['merge']) + ['Exclude'])
+    end
+
+    # `config` has already been through `handle_disabled_by_default` by this
+    # point, which returns a plain hash, so read `AllCops` directly rather than
+    # going through `Config#for_all_cops`.
+    def preview?(config)
+      return ConfigLoader.preview unless ConfigLoader.preview.nil?
+
+      (config['AllCops'] || {})['Preview'] == true
+    end
+
+    def resolve_default_overrides(config)
+      if ConfigLoader.disabled_by_default || ConfigLoader.enabled_by_default
+        [ConfigLoader.disabled_by_default, ConfigLoader.enabled_by_default]
+      else
+        [config.for_all_cops['DisabledByDefault'], config.for_all_cops['EnabledByDefault']]
+      end
+    end
+
     def disabled?(hash, department)
       hash[department].is_a?(Hash) && hash[department]['Enabled'] == false
     end
@@ -157,7 +240,7 @@ module RuboCop
       return false if inherited_file.nil? # Not inheritance resolving merge
       return false if inherited_file.start_with?('..') # Legitimate override
       return false if base_hash[key] == derived_hash[key] # Same value
-      return false if remote_file?(inherited_file) # Can't change
+      return false if PathUtil.remote_file?(inherited_file) # Can't change
 
       Gem.path.none? { |dir| inherited_file.start_with?(dir) } # Can change?
     end
@@ -180,14 +263,25 @@ module RuboCop
         "the same parameter in #{opts[:inherited_file]}"
     end
 
-    def determine_inherit_mode(hash, key)
+    # The `AllCops: Preview` in effect once inheritance is resolved: the file
+    # itself wins, then the files it inherits from, last one first. It has to be
+    # known before merging, since the keys are merged in whatever order they
+    # appear and `AllCops` may well come after the cops whose `Exclude` it affects.
+    def inherited_preview?(hash, base_configs)
+      all_cops = [hash, *base_configs.reverse].map { |config| config['AllCops'] }.find do |params|
+        params.is_a?(Hash) && params.key?('Preview')
+      end
+      preview?('AllCops' => all_cops)
+    end
+
+    def determine_inherit_mode(hash, key, preview)
       cop_cfg = hash[key]
       local_inherit = cop_cfg['inherit_mode'] if cop_cfg.is_a?(Hash)
-      local_inherit || hash['inherit_mode'] || {}
+      with_preview_exclude_merge(local_inherit || hash['inherit_mode'] || {}, preview)
     end
 
     def should_union?(derived_hash, base_hash, root_mode, key)
-      return false unless base_hash[key].is_a?(Array)
+      return false unless base_hash[key].is_a?(Array) || derived_hash[key].is_a?(Array)
 
       derived_mode = derived_hash['inherit_mode']
       return false if should_override?(derived_mode, key)
@@ -225,9 +319,9 @@ module RuboCop
     end
 
     def inherited_file(path, inherit_from, file)
-      if remote_file?(inherit_from)
+      if PathUtil.remote_file?(inherit_from)
         # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
-        RemoteConfig.new(inherit_from, File.dirname(path))
+        RemoteConfig.new(inherit_from, ConfigLoader.cache_root)
       elsif Pathname.new(inherit_from).absolute?
         # An absolute path to a config, e.g. `inherit_from: /Users/me/rubocop.yml`.
         # The path may come from `inherit_gem` option, where a gem name is expanded
@@ -237,7 +331,7 @@ module RuboCop
       elsif file.is_a?(RemoteConfig)
         # A path relative to a URL, e.g. `inherit_from: configs/default.yml`
         # in a config included with `inherit_from: http://example.com/rubocop.yml`
-        file.inherit_from_remote(inherit_from, path)
+        file.inherit_from_remote(inherit_from)
       else
         # A local relative path, e.g. `inherit_from: default.yml`
         print 'Inheriting ' if ConfigLoader.debug?
@@ -245,15 +339,11 @@ module RuboCop
       end
     end
 
-    def remote_file?(uri)
-      uri.start_with?('http://', 'https://')
-    end
-
     def remote_config?(file)
       file.is_a?(RemoteConfig)
     end
 
-    def handle_disabled_by_default(config, new_default_configuration)
+    def handle_disabled_by_default(config, new_default_configuration, base_defaults)
       department_config = config.to_hash.reject { |cop| cop.include?('/') }
       department_config.each do |dept, dept_params|
         next unless dept_params['Enabled']
@@ -262,7 +352,7 @@ module RuboCop
           next unless cop.start_with?("#{dept}/")
 
           # Retain original default configuration for cops in the department.
-          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
+          params['Enabled'] = base_defaults[cop]['Enabled']
         end
       end
 
@@ -280,10 +370,11 @@ module RuboCop
         begin
           gem = Bundler.load.specs[gem_name].first
           gem_path = gem.full_gem_path if gem
-        rescue Bundler::GemfileNotFound
-          # No Gemfile found. Bundler may be loaded manually
-        rescue Bundler::GitError
-          # The Gemfile exists but contains an uninstalled git source
+        rescue StandardError
+          # The Gemfile has a problem, which could be one of:
+          # - No Gemfile found. Bundler may be loaded manually
+          # - The Gemfile exists but contains an uninstalled git source
+          # - The Gemfile exists but cannot be loaded for some other reason
         end
       end
 

data/lib/rubocop/config_obsoletion/cop_rule.rb

@@ -20,7 +20,8 @@ module RuboCop
         rule_message + "\n(obsolete configuration found in #{smart_loaded_path}, please update it)"
       end
 
-      # Cop rules currently can only be failures, not warnings
+      # Failure by default; rules that accept `severity: warning` say so
+      # themselves.
       def warning?
         false
       end

data/lib/rubocop/config_obsoletion/extracted_cop.rb

@@ -15,7 +15,7 @@ module RuboCop
       end
 
       def violated?
-        return false if feature_loaded?
+        return false if plugin_loaded?
 
         affected_cops.any?
       end
@@ -38,8 +38,11 @@ module RuboCop
         end
       end
 
-      def feature_loaded?
-        config.loaded_features.include?(gem)
+      def plugin_loaded?
+        # Plugins loaded via `plugins` are Plugin objects with an `about.name` attribute.
+        # Plugins loaded via `require` are included in `loaded_features` as strings.
+        config.loaded_plugins.any? { |plugin| plugin.about.name == gem } ||
+          config.loaded_features.include?(gem)
       end
     end
   end

data/lib/rubocop/config_obsoletion/removed_cop.rb

@@ -20,15 +20,23 @@ module RuboCop
 
         if reason
           "#{base} since #{reason.chomp}."
-        elsif alternatives
+        elsif alternatives.any?
           "#{base}. Please use #{to_sentence(alternatives, connector: 'and/or')} instead."
         else
           "#{base}."
         end
       end
 
+      def warning?
+        severity == 'warning'
+      end
+
       private
 
+      def severity
+        metadata['severity']
+      end
+
       def reason
         metadata['reason']
       end

data/lib/rubocop/config_obsoletion/renamed_cop.rb

@@ -6,17 +6,28 @@ module RuboCop
     # a cop or moving it to a new department.
     # @api private
     class RenamedCop < CopRule
-      attr_reader :new_name
+      attr_reader :new_name, :metadata
 
-      def initialize(config, old_name, new_name)
+      def initialize(config, old_name, name_or_hash)
         super(config, old_name)
-        @new_name = new_name
+
+        if name_or_hash.is_a?(Hash)
+          @metadata = name_or_hash
+          @new_name = name_or_hash['new_name']
+        else
+          @metadata = {}
+          @new_name = name_or_hash
+        end
       end
 
       def rule_message
         "The `#{old_name}` cop has been #{verb} to `#{new_name}`."
       end
 
+      def warning?
+        severity == 'warning'
+      end
+
       private
 
       def moved?
@@ -29,6 +40,10 @@ module RuboCop
       def verb
         moved? ? 'moved' : 'renamed'
       end
+
+      def severity
+        metadata['severity']
+      end
     end
   end
 end

data/lib/rubocop/config_obsoletion.rb

@@ -15,7 +15,7 @@ module RuboCop
       'changed_parameters' => ChangedParameter,
       'changed_enforced_styles' => ChangedEnforcedStyles
     }.freeze
-    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant
+    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
     private_constant :LOAD_RULES_CACHE
 
     attr_reader :rules, :warnings
@@ -23,9 +23,40 @@ module RuboCop
     class << self
       attr_accessor :files
 
+      def global
+        @global ||= new(Config.new)
+      end
+
+      def reset!
+        @global = nil
+        @deprecated_names = {}
+        LOAD_RULES_CACHE[rules_cache_key] = nil
+      end
+
+      def rules_cache_key
+        files.hash
+      end
+
       def legacy_cop_names
         # Used by DepartmentName#qualified_legacy_cop_name
-        new(Config.new).rules.select(&:cop_rule?).map(&:old_name)
+        global.legacy_cop_names
+      end
+
+      def deprecated_cop_name?(name)
+        global.deprecated_cop_name?(name)
+      end
+
+      def deprecated_names_for(cop)
+        @deprecated_names ||= {}
+        return @deprecated_names[cop] if @deprecated_names.key?(cop)
+
+        @deprecated_names[cop] = global.rules.filter_map do |rule|
+          next unless rule.cop_rule?
+          next unless rule.respond_to?(:new_name)
+          next unless rule.new_name == cop
+
+          rule.old_name
+        end
       end
     end
 
@@ -45,12 +76,21 @@ module RuboCop
       raise ValidationError, messages.join("\n")
     end
 
+    def legacy_cop_names
+      # Used by DepartmentName#qualified_legacy_cop_name
+      cop_rules.map(&:old_name)
+    end
+
+    def deprecated_cop_name?(name)
+      legacy_cop_names.include?(name)
+    end
+
     private
 
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
     def load_rules # rubocop:disable Metrics/AbcSize
-      rules = LOAD_RULES_CACHE[self.class.files] ||=
+      rules = LOAD_RULES_CACHE[self.class.rules_cache_key] ||=
         self.class.files.each_with_object({}) do |filename, hash|
           hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
             case first
@@ -107,5 +147,9 @@ module RuboCop
         rule.message
       end
     end
+
+    def cop_rules
+      rules.select(&:cop_rule?)
+    end
   end
 end