rubocop 0.80.0 → 1.42.0

data/lib/rubocop/config_loader.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'yaml'
+require 'erb'
 require 'pathname'
+require 'yaml'
+require_relative 'config_finder'
 
 module RuboCop
   # Raised when a RuboCop configuration file is not found.
@@ -14,49 +16,66 @@ module RuboCop
   # during a run of the rubocop program, if files in several
   # directories are inspected.
   class ConfigLoader
-    DOTFILE = '.rubocop.yml'
-    XDG_CONFIG = 'config.yml'
+    DOTFILE = ConfigFinder::DOTFILE
     RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
     DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = '.rubocop_todo.yml'
 
     class << self
       include FileFinder
 
-      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion,
-                    :options_config
+      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
+                    :ignore_unrecognized_cops
       attr_writer :default_configuration
+      attr_reader :loaded_features
 
       alias debug? debug
-      alias auto_gen_config? auto_gen_config
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
-        @debug = @auto_gen_config = @options_config = nil
+        @debug = nil
+        @loaded_features = Set.new
         FileFinder.root_level = nil
       end
 
-      def load_file(file)
-        path = File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+      def load_file(file, check: true)
+        path = file_path(file)
 
         hash = load_yaml_configuration(path)
 
-        # Resolve requires first in case they define additional cops
-        resolver.resolve_requires(path, hash)
-
-        add_missing_namespaces(path, hash)
+        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')
 
-        Config.create(hash, path)
+        # 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 }
+        check_duplication(yaml_code, absolute_path)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
+
+        raise(TypeError, "Malformed configuration in #{absolute_path}") unless hash.is_a?(Hash)
+
+        hash
       end
 
       def add_missing_namespaces(path, hash)
-        hash.keys.each do |key|
-          q = Cop::Cop.qualified_cop_name(key, path)
+        # Using `hash.each_key` will cause the
+        # `can't add a new key into hash during iteration` error
+        hash_keys = hash.keys
+        hash_keys.each do |key|
+          q = Cop::Registry.qualified_cop_name(key, path)
           next if q == key
 
           hash[q] = hash.delete(key)
@@ -76,150 +95,116 @@ module RuboCop
       # 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)
-        find_project_dotfile(target_dir) ||
-          find_user_dotfile ||
-          find_user_xdg_config ||
-          DEFAULT_FILE
+        ConfigFinder.find_config_path(target_dir)
       end
 
-      def configuration_from_file(config_file)
-        config = load_file(config_file)
-        return config if config_file == DEFAULT_FILE
+      def configuration_from_file(config_file, check: true)
+        return 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).tap do |merged_config|
-          warn_on_pending_cops(merged_config)
+          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(merged_config)
         end
       end
 
+      def possible_new_cops?(config)
+        disable_pending_cops || enable_pending_cops ||
+          config.disabled_new_cops? || config.enabled_new_cops?
+      end
+
       def add_excludes_from_files(config, config_file)
-        found_files =
-          find_files_upwards(DOTFILE, config_file) +
-          [find_user_dotfile, find_user_xdg_config].compact
+        exclusion_file = find_last_file_upwards(DOTFILE, config_file, ConfigFinder.project_root)
 
-        return if found_files.empty?
-        return if PathUtil.relative_path(found_files.last) ==
-                  PathUtil.relative_path(config_file)
+        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(found_files.last))
+        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
-
-      def warn_on_pending_cops(config)
-        pending_cops = config.keys.select do |key|
-          config[key]['Enabled'] == 'pending'
-        end
-
-        return if pending_cops.none?
-
-        warn Rainbow('The following cops were added to RuboCop, but are not ' \
-                     'configured. Please set Enabled to either `true` or ' \
-                     '`false` in your `.rubocop.yml` file:').yellow
-
-        pending_cops.each do |cop|
-          warn Rainbow(" - #{cop}").yellow
+          print 'Default ' if debug?
+          load_file(DEFAULT_FILE)
         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.
-      def merge_with_default(config, config_file, unset_nil: true)
-        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
+      # @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
       end
 
-      def add_inheritance_from_auto_generated_file
-        file_string = " #{AUTO_GENERATED_FILE}"
+      # 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
+          `RuboCop::ConfigLoader.project_root` is deprecated and will be removed in RuboCop 2.0. \
+          Use `RuboCop::ConfigFinder.project_root` instead.
+        WARNING
 
-        config_file = options_config || DOTFILE
+        ConfigFinder.project_root
+      end
 
-        if File.exist?(config_file)
-          files = Array(load_yaml_configuration(config_file)['inherit_from'])
+      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.
 
-          return if files.include?(AUTO_GENERATED_FILE)
+        Please also note that you can opt-in to new cops by default by adding this to your config:
+          AllCops:
+            NewCops: enable
+      BANNER
 
-          files.unshift(AUTO_GENERATED_FILE)
-          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
-          rubocop_yml_contents = existing_configuration(config_file)
-        end
+      def warn_on_pending_cops(pending_cops)
+        return if pending_cops.empty?
 
-        write_config_file(config_file, file_string, rubocop_yml_contents)
+        warn Rainbow(PENDING_BANNER).yellow
 
-        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
-      end
+        pending_cops.each { |cop| warn_pending_cop cop }
 
-      private
-
-      def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir)
+        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
       end
 
-      def find_user_dotfile
-        return unless ENV.key?('HOME')
+      def warn_pending_cop(cop)
+        version = cop.metadata['VersionAdded'] || 'N/A'
 
-        file = File.join(Dir.home, DOTFILE)
-        return file if File.exist?(file)
+        warn Rainbow("#{cop.name}: # new in #{version}").yellow
+        warn Rainbow('  Enabled: true').yellow
       end
 
-      def find_user_xdg_config
-        xdg_config_home = expand_path(ENV.fetch('XDG_CONFIG_HOME', '~/.config'))
-        xdg_config = File.join(xdg_config_home, 'rubocop', XDG_CONFIG)
-        return xdg_config if File.exist?(xdg_config)
+      # 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)
       end
 
-      def expand_path(path)
-        File.expand_path(path)
-      rescue ArgumentError
-        # Could happen because HOME or ID could not be determined. Fall back on
-        # using the path literally in that case.
-        path
+      # @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
 
-      def existing_configuration(config_file)
-        IO.read(config_file, encoding: Encoding::UTF_8)
-          .sub(/^inherit_from: *[^\n]+/, '')
-          .sub(/^inherit_from: *(\n *- *[^\n]+)+/, '')
-      end
+      private
 
-      def write_config_file(file_name, file_string, rubocop_yml_contents)
-        File.open(file_name, 'w') do |f|
-          f.write "inherit_from:#{file_string}\n"
-          f.write "\n#{rubocop_yml_contents}" if rubocop_yml_contents =~ /\S/
-        end
+      def file_path(file)
+        File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
       end
 
       def resolver
         @resolver ||= ConfigLoaderResolver.new
       end
 
-      def load_yaml_configuration(absolute_path)
-        yaml_code = read_file(absolute_path)
-        check_duplication(yaml_code, absolute_path)
-        hash = yaml_safe_load(yaml_code, absolute_path) || {}
-
-        puts "configuration from #{absolute_path}" if debug?
-
-        unless hash.is_a?(Hash)
-          raise(TypeError, "Malformed configuration in #{absolute_path}")
-        end
-
-        hash
-      end
-
       def check_duplication(yaml_code, absolute_path)
         smart_path = PathUtil.smart_path(absolute_path)
         YAMLDuplicationChecker.check(yaml_code, absolute_path) do |key1, key2|
@@ -229,10 +214,9 @@ module RuboCop
                       line1 = key1.start_line + 1
                       line2 = key2.start_line + 1
                       "#{smart_path}:#{line1}: " \
-                      "`#{value}` is concealed by line #{line2}"
+                        "`#{value}` is concealed by line #{line2}"
                     else
-                      "#{smart_path}: " \
-                        "`#{value}` is concealed by duplicate"
+                      "#{smart_path}: `#{value}` is concealed by duplicate"
                     end
           warn Rainbow(message).yellow
         end
@@ -242,26 +226,31 @@ module RuboCop
       # stderr. Care is taken to use the standard OS exit code for a "file not
       # found" error.
       def read_file(absolute_path)
-        IO.read(absolute_path, encoding: Encoding::UTF_8)
+        File.read(absolute_path, encoding: Encoding::UTF_8)
       rescue Errno::ENOENT
-        raise ConfigNotFoundError,
-              "Configuration file not found: #{absolute_path}"
+        raise ConfigNotFoundError, "Configuration file not found: #{absolute_path}"
       end
 
       def yaml_safe_load(yaml_code, filename)
-        if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
-          SafeYAML.load(yaml_code, filename,
-                        whitelisted_tags: %w[!ruby/regexp])
-        # Ruby 2.6+
-        elsif Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
-          YAML.safe_load(
-            yaml_code,
-            permitted_classes: [Regexp, Symbol],
-            permitted_symbols: [],
-            aliases: true,
-            filename: filename
-          )
-        else
+        yaml_safe_load!(yaml_code, filename)
+      rescue ::StandardError
+        if defined?(::SafeYAML)
+          raise 'SafeYAML is unmaintained, no longer needed and should be removed'
+        end
+
+        raise
+      end
+
+      if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
+        def yaml_safe_load!(yaml_code, filename)
+          YAML.safe_load(yaml_code,
+                         permitted_classes: [Regexp, Symbol],
+                         permitted_symbols: [],
+                         aliases: true,
+                         filename: filename)
+        end
+      else # Ruby < 2.6
+        def yaml_safe_load!(yaml_code, filename)
           YAML.safe_load(yaml_code, [Regexp, Symbol], [], true, filename)
         end
       end

data/lib/rubocop/config_loader_resolver.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
 
-require 'yaml'
 require 'pathname'
+require 'yaml'
 
 module RuboCop
   # A help class for ConfigLoader that handles configuration resolution.
+  # @api private
   class ConfigLoaderResolver
     def resolve_requires(path, hash)
       config_dir = File.dirname(path)
-      Array(hash.delete('require')).each do |r|
-        if r.start_with?('.')
-          require(File.join(config_dir, r))
-        else
-          require(r)
+      hash.delete('require').tap do |loaded_features|
+        Array(loaded_features).each do |feature|
+          FeatureLoader.load(config_directory_path: config_dir, feature: feature)
         end
       end
     end
 
-    def resolve_inheritance(path, hash, file, debug)
+    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)
-        .reverse.each_with_index do |base_config, index|
+        .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)
 
@@ -31,16 +33,30 @@ module RuboCop
                       inherit_mode: determine_inherit_mode(hash, k))
           end
           hash[k] = v
+          fix_include_paths(base_config.loaded_path, hash, path, k, v) if v.key?('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"
+          raise ArgumentError, "can't inherit configuration from the rubocop gem"
         end
 
         hash['inherit_from'] = Array(hash['inherit_from'])
@@ -54,7 +70,7 @@ module RuboCop
     # 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
+    # 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
@@ -68,12 +84,10 @@ module RuboCop
         end
       end
 
-      if disabled_by_default
-        config = handle_disabled_by_default(config, default_configuration)
-      end
+      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+      override_enabled_for_disabled_departments(default_configuration, config)
 
-      opts = { inherit_mode: config['inherit_mode'] || {},
-               unset_nil: unset_nil }
+      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
@@ -88,9 +102,9 @@ module RuboCop
       keys_appearing_in_both.each do |key|
         if opts[:unset_nil] && derived_hash[key].nil?
           result.delete(key)
-        elsif base_hash[key].is_a?(Hash)
+        elsif merge_hashes?(base_hash, derived_hash, key)
           result[key] = merge(base_hash[key], derived_hash[key], **opts)
-        elsif should_union?(base_hash, key, opts[:inherit_mode])
+        elsif should_union?(derived_hash, base_hash, opts[:inherit_mode], key)
           result[key] = base_hash[key] | derived_hash[key]
         elsif opts[:debug]
           warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
@@ -100,8 +114,45 @@ module RuboCop
     end
     # rubocop:enable Metrics/AbcSize
 
+    # 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
+
     private
 
+    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
@@ -112,13 +163,10 @@ module RuboCop
     end
 
     def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
-      return unless duplicate_setting?(base_hash, derived_hash,
-                                       key, opts[:inherited_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 && inherit_mode.include?(key)
+      inherit_mode = opts[:inherit_mode]['merge'] || opts[:inherit_mode]['override']
+      return if base_hash[key].is_a?(Array) && inherit_mode && inherit_mode.include?(key)
 
       puts "#{PathUtil.smart_path(opts[:file])}: " \
            "#{opts[:cop_name]}:#{key} overrides " \
@@ -127,19 +175,42 @@ module RuboCop
 
     def determine_inherit_mode(hash, key)
       cop_cfg = hash[key]
-      local_inherit = cop_cfg.delete('inherit_mode') if cop_cfg.is_a?(Hash)
+      local_inherit = cop_cfg['inherit_mode'] if cop_cfg.is_a?(Hash)
       local_inherit || hash['inherit_mode'] || {}
     end
 
-    def should_union?(base_hash, key, inherit_mode)
-      base_hash[key].is_a?(Array) &&
-        inherit_mode &&
-        inherit_mode['merge'] &&
-        inherit_mode['merge'].include?(key)
+    def should_union?(derived_hash, base_hash, root_mode, key)
+      return false unless base_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'] && mode['merge'].include?(key)
+    end
+
+    def should_override?(mode, key)
+      mode && mode['override'] && 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)
-      configs = Array(inherit_from).compact.map do |f|
+      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
 
@@ -148,10 +219,20 @@ module RuboCop
 
     def inherited_file(path, inherit_from, file)
       if remote_file?(inherit_from)
+        # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
         RemoteConfig.new(inherit_from, File.dirname(path))
+      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, path)
       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
@@ -159,7 +240,7 @@ module RuboCop
 
     def remote_file?(uri)
       regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
-      uri =~ /\A#{regex}\z/
+      /\A#{regex}\z/.match?(uri)
     end
 
     def handle_disabled_by_default(config, new_default_configuration)
@@ -168,7 +249,7 @@ module RuboCop
         next unless dept_params['Enabled']
 
         new_default_configuration.each do |cop, params|
-          next unless cop.start_with?(dept + '/')
+          next unless cop.start_with?("#{dept}/")
 
           # Retain original default configuration for cops in the department.
           params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
@@ -180,16 +261,21 @@ module RuboCop
       end
     end
 
-    def transform(config)
-      Hash[config.map { |cop, params| [cop, yield(params)] }]
+    def transform(config, &block)
+      config.transform_values(&block)
     end
 
     def gem_config_path(gem_name, relative_config_path)
-      spec = Gem::Specification.find_by_name(gem_name)
-      File.join(spec.gem_dir, relative_config_path)
+      if defined?(Bundler)
+        gem = Bundler.load.specs[gem_name].first
+        gem_path = gem.full_gem_path if gem
+      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}"
+      raise Gem::LoadError, "Unable to find gem #{gem_name}; is the gem installed? #{e}"
     end
   end
 end