rubocop 1.81.7 → 1.92.1

data/lib/rubocop/config.rb

@@ -2,7 +2,7 @@
 
 # FIXME: Moving Rails department code to RuboCop Rails will remove
 # the following rubocop:disable comment.
-# rubocop:disable Metrics/ClassLength
+# rubocop:disable-next Metrics/ClassLength
 module RuboCop
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
@@ -27,7 +27,7 @@ module RuboCop
       config
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
     def initialize(hash = RuboCop::ConfigLoader.default_configuration, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
@@ -72,7 +72,6 @@ module RuboCop
       @badge_config_cache = {}.compare_by_identity
       @clusivity_config_exists_cache = {}
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def loaded_plugins
       @loaded_plugins ||= ConfigLoader.loaded_plugins
@@ -168,7 +167,11 @@ module RuboCop
         department_config = self[badge.department_name]
         cop_config = for_cop(badge.to_s)
         if department_config
-          department_config.merge(cop_config)
+          merged_config = department_config.merge(cop_config)
+          if department_config['Exclude'] && cop_config['Exclude']
+            merged_config['Exclude'] = department_config['Exclude'] | cop_config['Exclude']
+          end
+          merged_config
         else
           cop_config
         end
@@ -209,6 +212,30 @@ module RuboCop
       for_all_cops['NewCops'] == 'enable'
     end
 
+    # Whether the given pending cop should be enabled, based on the `NewCops` setting of
+    # its department (if any) or of `AllCops`. A department may set `NewCops` to `enable`,
+    # `disable`, `pending`, or a version, in which case pending cops added in that version
+    # or earlier are enabled.
+    def enabled_new_cop?(qualified_cop_name)
+      setting = new_cops_setting_for(qualified_cop_name)
+
+      case setting.to_s
+      when 'enable' then true
+      when '', 'pending', 'disable' then false
+      else new_cops_version_covers?(setting, qualified_cop_name)
+      end
+    end
+
+    # Whether preview behavior is on, for cops that gate an unstable change
+    # behind it and for cops that are themselves `Enabled: preview`.
+    # `--preview` / `--no-preview` win over `AllCops: Preview`.
+    def preview?(options = {})
+      preview = options[:preview]
+      return preview unless preview.nil?
+
+      for_all_cops['Preview'] == true
+    end
+
     def active_support_extensions_enabled?
       for_all_cops['ActiveSupportExtensionsEnabled']
     end
@@ -217,6 +244,9 @@ module RuboCop
       for_all_cops['StringLiteralsFrozenByDefault']
     end
 
+    # Returns true if the file matches any include pattern. If a block is given, the block is called
+    # to determine if the pattern is relevant (true returned by the block) or should be skipped
+    # (false returned).
     def file_to_include?(file)
       relative_file_path = path_relative_to_config(file)
 
@@ -228,11 +258,9 @@ module RuboCop
       absolute_file_path = File.expand_path(file)
 
       patterns_to_include.any? do |pattern|
-        if block_given?
-          yield pattern, relative_file_path, absolute_file_path
-        else
-          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
-        end
+        next if block_given? && !yield(pattern)
+
+        match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
       end
     end
 
@@ -242,10 +270,7 @@ module RuboCop
       # `bundler-console` conveys `Bundler::Console`).
       return true if File.extname(file) == '.gemspec'
 
-      file_to_include?(file) do |pattern, relative_path, absolute_path|
-        /[A-Z]/.match?(pattern.to_s) &&
-          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
-      end
+      file_to_include?(file) { |pattern| /[A-Z]/.match?(pattern.to_s) }
     end
 
     # Returns true if there's a chance that an Include pattern matches hidden
@@ -286,7 +311,7 @@ module RuboCop
            loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
           File.expand_path(File.dirname(loaded_path))
         else
-          Dir.pwd
+          PathUtil.pwd
         end
     end
 
@@ -328,6 +353,7 @@ module RuboCop
 
         cop_metadata = self[qualified_cop_name]
         next unless cop_metadata['Enabled'] == 'pending'
+        next if new_cops_covered?(qualified_cop_name)
 
         pending_cops << CopConfig.new(qualified_cop_name, cop_metadata)
       end
@@ -339,12 +365,26 @@ module RuboCop
       @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
     end
 
+    # Returns the names of the target's gems that are sourced from a local path
+    # (i.e. `path:` dependencies and the project's own gem when the `Gemfile`
+    # uses `gemspec`), whose code therefore lives in the project itself.
+    # @returns [Array<String>, nil] The gem names, or nil without a lockfile.
+    def path_sourced_gems_in_target
+      @path_sourced_gems_in_target ||= read_path_sourced_gems_from_target_lockfile
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
     end
 
     private
 
+    def match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path)
+      should_use_absolute_path = absolute?(pattern.to_s) || pattern.to_s.start_with?('..') ||
+                                 relative_file_path.start_with?('..')
+      match_path?(pattern, should_use_absolute_path ? absolute_file_path : relative_file_path)
+    end
+
     # @return [Float, nil] The Rails version as a `major.minor` Float.
     def target_rails_version_from_bundler_lock_file
       @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
@@ -377,6 +417,14 @@ module RuboCop
       Lockfile.new(lockfile_path).gem_versions
     end
 
+    # @returns [Array<String>, nil] The names of the gems sourced from a local path.
+    def read_path_sourced_gems_from_target_lockfile
+      lockfile_path = bundler_lock_file_path
+      return nil unless lockfile_path
+
+      Lockfile.new(lockfile_path).path_sourced_gem_names
+    end
+
     def enable_cop?(qualified_cop_name, cop_options)
       # If the cop is explicitly enabled or `Lint/Syntax`, the other checks can be skipped.
       return true if cop_options['Enabled'] == true || qualified_cop_name == 'Lint/Syntax'
@@ -395,6 +443,43 @@ module RuboCop
 
       self[cop_department.join('/')]
     end
+
+    # The effective `NewCops` setting for the given cop: the department-level
+    # setting if present, otherwise the `AllCops` setting.
+    def new_cops_setting_for(qualified_cop_name)
+      department = department_of(qualified_cop_name)
+      setting = department['NewCops'] if department
+
+      setting || for_all_cops['NewCops']
+    end
+
+    # Whether the cop's pending status is resolved by a `NewCops` setting,
+    # so that it should not appear in the pending cops warning.
+    # Unlike `enabled_new_cop?`, `disable` counts as covered.
+    def new_cops_covered?(qualified_cop_name)
+      setting = new_cops_setting_for(qualified_cop_name)
+
+      case setting.to_s
+      when 'enable', 'disable' then true
+      when '', 'pending' then false
+      else new_cops_version_covers?(setting, qualified_cop_name)
+      end
+    end
+
+    def new_cops_version_covers?(new_cops_version, qualified_cop_name)
+      cop_metadata = self[qualified_cop_name]
+      version_added = comparable_version(cop_metadata['VersionAdded']) if cop_metadata
+      pinned_version = comparable_version(new_cops_version)
+      return false if version_added.nil? || pinned_version.nil?
+
+      version_added <= pinned_version
+    end
+
+    # Returns a `Gem::Version` for values like `'1.19'` or `1.19`, and `nil`
+    # for non-version values like `'N/A'` or `'<<next>>'`.
+    def comparable_version(value)
+      value = value.to_s
+      Gem::Version.new(value) if value.match?(/\A\d/) && Gem::Version.correct?(value)
+    end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/rubocop/config_finder.rb

@@ -30,7 +30,7 @@ module RuboCop
       private
 
       def find_project_root
-        pwd = Dir.pwd
+        pwd = PathUtil.pwd
         gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
         return unless gems_file
 

data/lib/rubocop/config_loader.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'yaml'
+require_relative 'cache_config'
 require_relative 'config_finder'
 
 module RuboCop
@@ -23,25 +24,34 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops
-      attr_writer :default_configuration
+                    :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 Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def load_file(file, check: true)
         path = file_path(file)
 
@@ -65,7 +75,6 @@ module RuboCop
 
         Config.create(hash, path, check: check)
       end
-      # rubocop:enable Metrics/AbcSize
 
       def load_yaml_configuration(absolute_path)
         file_contents = read_file(absolute_path)
@@ -115,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
@@ -150,31 +159,23 @@ module RuboCop
       # 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`.
-      # rubocop:disable Metrics/MethodLength
       def inject_defaults!(config_yml_path)
         if Pathname(config_yml_path).directory?
-          # TODO: Since the warning noise is expected to be high until some time after the release,
-          # warnings will only be issued when `RUBYOPT=-w` is specified.
-          # To proceed step by step, the next step is to remove `$VERBOSE` and always issue warning.
-          # Eventually, `project_root` will no longer be accepted.
-          if $VERBOSE
-            warn Rainbow(<<~MESSAGE).yellow, uplevel: 1
-              Use config YAML file path instead of project root directory.
-              e.g., `path/to/config/default.yml`
-            MESSAGE
-          end
-          # NOTE: For compatibility.
-          project_root = config_yml_path
-          path = File.join(project_root, 'config', 'default.yml')
-          config = load_file(path)
-        else
-          hash = ConfigLoader.load_yaml_configuration(config_yml_path.to_s)
-          config = Config.new(hash, config_yml_path).tap(&:make_excludes_absolute)
+          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
 
-        @default_configuration = ConfigLoader.merge_with_default(config, path)
+        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
-      # rubocop:enable Metrics/MethodLength
 
       # Returns the path RuboCop inferred as the root of the project. No file
       # searches will go past this directory.
@@ -189,8 +190,29 @@ module RuboCop
       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)
+      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
+
+      # 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
+
+        Config.new(hash, config.loaded_path)
       end
 
       # @api private

data/lib/rubocop/config_loader_resolver.rb

@@ -37,22 +37,24 @@ module RuboCop
 
     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
@@ -91,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
 
@@ -114,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
@@ -131,7 +141,6 @@ module RuboCop
       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.
@@ -166,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
@@ -199,10 +263,21 @@ 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)
@@ -246,7 +321,7 @@ module RuboCop
     def inherited_file(path, inherit_from, file)
       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
@@ -256,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?
@@ -268,7 +343,7 @@ module RuboCop
       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']
@@ -277,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
 

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

@@ -39,8 +39,10 @@ module RuboCop
       end
 
       def plugin_loaded?
-        # Plugins loaded via `require` are included in `loaded_features`.
-        config.loaded_plugins.include?(gem) || config.loaded_features.include?(gem)
+        # 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.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

data/lib/rubocop/config_store.rb

@@ -36,7 +36,7 @@ module RuboCop
     end
 
     def force_default_config!
-      @options_config = ConfigLoader.default_configuration
+      @options_config = ConfigLoader.apply_default_overrides(ConfigLoader.default_configuration)
     end
 
     def unvalidated
@@ -49,7 +49,7 @@ module RuboCop
     end
 
     def for_pwd
-      for_dir(Dir.pwd)
+      for_dir(PathUtil.pwd)
     end
 
     # If type (file/dir) is known beforehand,