mux_ruby 5.1.0 → 5.2.0

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/config_loader.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'yaml'
+require_relative 'cache_config'
+require_relative 'config_finder'
+
+module RuboCop
+  # Raised when a RuboCop configuration file is not found.
+  class ConfigNotFoundError < Error
+  end
+
+  # This class represents the configuration of the RuboCop application
+  # and all its cops. A Config is associated with a YAML configuration
+  # file from which it was read. Several different Configs can be used
+  # during a run of the rubocop program, if files in several
+  # directories are inspected.
+  class ConfigLoader
+    DOTFILE = ConfigFinder::DOTFILE
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+
+    class << self
+      include FileFinder
+
+      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
+                    :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.resolve_inheritance_from_gems(hash)
+        resolver.resolve_inheritance(path, hash, file, debug?)
+        hash.delete('inherit_from')
+
+        # Adding missing namespaces only after resolving requires & inheritance,
+        # since both can introduce new cops that need to be considered here.
+        add_missing_namespaces(path, hash)
+
+        Config.create(hash, path, check: check)
+      end
+
+      def load_yaml_configuration(absolute_path)
+        file_contents = read_file(absolute_path)
+        yaml_code = Dir.chdir(File.dirname(absolute_path)) { ERB.new(file_contents).result }
+        yaml_tree = check_duplication(yaml_code, absolute_path)
+        hash = yaml_tree_to_hash(yaml_tree) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
+
+        unless hash.is_a?(Hash)
+          raise(ValidationError, "Malformed configuration in #{absolute_path}")
+        end
+
+        hash
+      end
+
+      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
+
+          hash[q] = hash.delete(key)
+        end
+      end
+
+      # Return a recursive merge of two hashes. That is, a normal hash merge,
+      # with the addition that any value that is a hash, and occurs in both
+      # arguments, will also be merged. And so on.
+      def merge(base_hash, derived_hash)
+        resolver.merge(base_hash, derived_hash)
+      end
+
+      # Returns the path of .rubocop.yml searching upwards in the
+      # directory structure starting at the given directory where the
+      # inspected file is. If no .rubocop.yml is found there, the
+      # user's home directory is checked. If there's no .rubocop.yml
+      # there either, the path to the default file is returned.
+      def configuration_file_for(target_dir)
+        ConfigFinder.find_config_path(target_dir)
+      end
+
+      def configuration_from_file(config_file, check: true)
+        return apply_default_overrides(default_configuration) if config_file == DEFAULT_FILE
+
+        config = load_file(config_file, check: check)
+        config.validate_after_resolution if check
+
+        if ignore_parent_exclusion?
+          print 'Ignoring AllCops/Exclude from parent folders' if debug?
+        else
+          add_excludes_from_files(config, config_file)
+        end
+
+        merge_with_default(config, config_file)
+      end
+
+      def add_excludes_from_files(config, config_file)
+        exclusion_file = find_last_file_upwards(DOTFILE, config_file, ConfigFinder.project_root)
+
+        return unless exclusion_file
+        return if PathUtil.relative_path(exclusion_file) == PathUtil.relative_path(config_file)
+
+        print 'AllCops/Exclude ' if debug?
+        config.add_excludes_from_higher_level(load_file(exclusion_file))
+      end
+
+      def default_configuration
+        @default_configuration ||= begin
+          print 'Default ' if debug?
+          load_file(DEFAULT_FILE)
+        end
+      end
+
+      # 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
+      # searches will go past this directory.
+      # @deprecated Use `RuboCop::ConfigFinder.project_root` instead.
+      def project_root
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `RuboCop::ConfigLoader.project_root` is deprecated and will be removed in RuboCop 2.0. \
+          Use `RuboCop::ConfigFinder.project_root` instead.
+        WARNING
+
+        ConfigFinder.project_root
+      end
+
+      # 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
+
+      # 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
+      # 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
+      # Used to add features that were required inside a config or from
+      # the CLI using `--require`.
+      def add_loaded_features(loaded_features)
+        @loaded_features.merge(Array(loaded_features))
+      end
+
+      private
+
+      def file_path(file)
+        File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+      end
+
+      def resolver
+        @resolver ||= ConfigLoaderResolver.new
+      end
+
+      def check_duplication(yaml_code, absolute_path)
+        smart_path = PathUtil.smart_path(absolute_path)
+        YAMLDuplicationChecker.check(yaml_code, absolute_path) do |key1, key2|
+          value = key1.value
+          # .start_line is only available since ruby 2.5 / psych 3.0
+          message = if key1.respond_to? :start_line
+                      line1 = key1.start_line + 1
+                      line2 = key2.start_line + 1
+                      "#{smart_path}:#{line1}: " \
+                        "`#{value}` is concealed by line #{line2}"
+                    else
+                      "#{smart_path}: `#{value}` is concealed by duplicate"
+                    end
+          warn Rainbow(message).yellow
+        end
+      end
+
+      # Read the specified file, or exit with a friendly, concise message on
+      # stderr. Care is taken to use the standard OS exit code for a "file not
+      # found" error.
+      def read_file(absolute_path)
+        File.read(absolute_path, encoding: Encoding::UTF_8)
+      rescue Errno::ENOENT
+        raise ConfigNotFoundError, "Configuration file not found: #{absolute_path}"
+      end
+
+      def yaml_tree_to_hash(yaml_tree)
+        yaml_tree_to_hash!(yaml_tree)
+      rescue ::StandardError
+        if defined?(::SafeYAML)
+          raise 'SafeYAML is unmaintained, no longer needed and should be removed'
+        end
+
+        raise
+      end
+
+      def yaml_tree_to_hash!(yaml_tree)
+        return nil unless yaml_tree
+
+        # Optimization: Because we checked for duplicate keys, we already have the
+        # yaml tree and don't need to parse it again.
+        # Also see https://github.com/ruby/psych/blob/v5.1.2/lib/psych.rb#L322-L336
+        class_loader = YAML::ClassLoader::Restricted.new(%w[Regexp Symbol], [])
+        scanner = YAML::ScalarScanner.new(class_loader)
+        visitor = YAML::Visitors::ToRuby.new(scanner, class_loader)
+        visitor.accept(yaml_tree)
+      end
+    end
+
+    # Initializing class ivars
+    clear_options
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.92.2/lib/rubocop/config_loader_resolver.rb

@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+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|
+          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 = 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, preview))
+          end
+          hash[k] = v
+          fix_include_paths(base_config.loaded_path, hash, path, k, v) if only_base_has_include
+        end
+      end
+    end
+
+    # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the
+    # base configuration are relative to the directory where the base configuration file is. For the
+    # derived configuration, we need to make those paths relative to where the derived configuration
+    # file is.
+    def fix_include_paths(base_config_path, hash, path, key, value)
+      return unless File.basename(base_config_path).start_with?('.rubocop')
+
+      base_dir = File.dirname(base_config_path)
+      derived_dir = File.dirname(path)
+      hash[key]['Include'] = value['Include'].map do |include_path|
+        PathUtil.relative_path(File.join(base_dir, include_path), derived_dir)
+      end
+    end
+
+    def resolve_inheritance_from_gems(hash)
+      gems = hash.delete('inherit_gem')
+      (gems || {}).each_pair do |gem_name, config_path|
+        if gem_name == 'rubocop'
+          raise ArgumentError, "can't inherit configuration from the rubocop gem"
+        end
+
+        hash['inherit_from'] = Array(hash['inherit_from'])
+        Array(config_path).reverse_each do |path|
+          # Put gem configuration first so local configuration overrides it.
+          hash['inherit_from'].unshift gem_config_path(gem_name, path)
+        end
+      end
+    end
+
+    # Merges the given configuration with the default one. If
+    # AllCops:DisabledByDefault is true, it changes the Enabled params so that
+    # 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.
+    # 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(base_defaults) do |params|
+          params.merge('Enabled' => !disabled_by_default)
+        end
+      end
+
+      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: inherit_mode_for_default(config, preview), unset_nil: unset_nil }
+      Config.new(merge(default_configuration, config, **opts), config_file)
+    end
+
+    # Return a recursive merge of two hashes. That is, a normal hash merge,
+    # with the addition that any value that is a hash, and occurs in both
+    # arguments, will also be merged. And so on.
+    #
+    # 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
+      keys_appearing_in_both.each do |key|
+        if opts[:unset_nil] && derived_hash[key].nil?
+          result.delete(key)
+        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] = 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
+
+    # An `Enabled: true` setting in user configuration for a cop overrides an
+    # `Enabled: false` setting for its department.
+    def override_department_setting_for_cops(base_hash, derived_hash)
+      derived_hash.each_key do |key|
+        next unless key =~ %r{(.*)/.*}
+
+        department = Regexp.last_match(1)
+        next unless disabled?(derived_hash, department) || disabled?(base_hash, department)
+
+        # The `override_department` setting for the `Enabled` parameter is an
+        # internal setting that's not documented in the manual. It will cause a
+        # cop to be enabled later, when logic surrounding enabled/disabled it
+        # run, even though its department is disabled.
+        derived_hash[key]['Enabled'] = 'override_department' if derived_hash[key]['Enabled']
+      end
+    end
+
+    # If a cop was previously explicitly enabled, but then superseded by the
+    # department being disabled, disable it.
+    def override_enabled_for_disabled_departments(base_hash, derived_hash)
+      cops_to_disable = derived_hash.each_key.with_object([]) do |key, cops|
+        next unless disabled?(derived_hash, key)
+
+        cops.concat(base_hash.keys.grep(Regexp.new("^#{key}/")))
+      end
+
+      cops_to_disable.each do |cop_name|
+        next unless base_hash.dig(cop_name, 'Enabled') == true
+
+        derived_hash.replace(merge({ cop_name => { 'Enabled' => false } }, derived_hash))
+      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
+
+    def duplicate_setting?(base_hash, derived_hash, key, inherited_file)
+      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 PathUtil.remote_file?(inherited_file) # Can't change
+
+      Gem.path.none? { |dir| inherited_file.start_with?(dir) } # Can change?
+    end
+
+    def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
+      # If the file being considered is remote, don't bother checking for duplicates
+      return if remote_config?(opts[:file])
+
+      return unless duplicate_setting?(base_hash, derived_hash, key, opts[:inherited_file])
+
+      inherit_mode = opts[:inherit_mode]['merge'] || opts[:inherit_mode]['override']
+      return if base_hash[key].is_a?(Array) && inherit_mode&.include?(key)
+
+      puts duplicate_setting_warning(opts, key)
+    end
+
+    def duplicate_setting_warning(opts, key)
+      "#{PathUtil.smart_path(opts[:file])}: " \
+        "#{opts[:cop_name]}:#{key} overrides " \
+        "the same parameter in #{opts[:inherited_file]}"
+    end
+
+    # 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)
+      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) || derived_hash[key].is_a?(Array)
+
+      derived_mode = derived_hash['inherit_mode']
+      return false if should_override?(derived_mode, key)
+      return true if should_merge?(derived_mode, key)
+
+      base_mode = base_hash['inherit_mode']
+      return false if should_override?(base_mode, key)
+      return true if should_merge?(base_mode, key)
+
+      should_merge?(root_mode, key)
+    end
+
+    def should_merge?(mode, key)
+      mode && mode['merge']&.include?(key)
+    end
+
+    def should_override?(mode, key)
+      mode && mode['override']&.include?(key)
+    end
+
+    def merge_hashes?(base_hash, derived_hash, key)
+      base_hash[key].is_a?(Hash) && derived_hash[key].is_a?(Hash)
+    end
+
+    def base_configs(path, inherit_from, file)
+      inherit_froms = Array(inherit_from).compact.flat_map do |f|
+        PathUtil.glob?(f) ? Dir.glob(f) : f
+      end
+
+      configs = inherit_froms.map do |f|
+        ConfigLoader.load_file(inherited_file(path, f, file))
+      end
+
+      configs.compact
+    end
+
+    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, 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
+        # to an absolute path to that gem.
+        print 'Inheriting ' if ConfigLoader.debug?
+        inherit_from
+      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)
+      else
+        # A local relative path, e.g. `inherit_from: default.yml`
+        print 'Inheriting ' if ConfigLoader.debug?
+        File.expand_path(inherit_from, File.dirname(path))
+      end
+    end
+
+    def remote_config?(file)
+      file.is_a?(RemoteConfig)
+    end
+
+    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']
+
+        new_default_configuration.each do |cop, params|
+          next unless cop.start_with?("#{dept}/")
+
+          # Retain original default configuration for cops in the department.
+          params['Enabled'] = base_defaults[cop]['Enabled']
+        end
+      end
+
+      transform(config) do |params|
+        { 'Enabled' => true }.merge(params) # Set true if not set.
+      end
+    end
+
+    def transform(config, &block)
+      config.transform_values(&block)
+    end
+
+    def gem_config_path(gem_name, relative_config_path)
+      if defined?(Bundler)
+        begin
+          gem = Bundler.load.specs[gem_name].first
+          gem_path = gem.full_gem_path if gem
+        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
+
+      gem_path ||= Gem::Specification.find_by_name(gem_name).gem_dir
+
+      File.join(gem_path, relative_config_path)
+    rescue Gem::LoadError => e
+      raise Gem::LoadError, "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+    end
+  end
+end