rubocop 1.57.1 → 1.81.6

data/lib/rubocop/config.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 # FIXME: Moving Rails department code to RuboCop Rails will remove
 # the following rubocop:disable comment.
 # rubocop:disable Metrics/ClassLength
@@ -14,10 +12,11 @@ module RuboCop
   class Config
     include PathUtil
     include FileFinder
-    extend Forwardable
+    extend SimpleForwardable
 
     CopConfig = Struct.new(:name, :metadata)
 
+    EMPTY_CONFIG = {}.freeze
     DEFAULT_RAILS_VERSION = 5.0
     attr_reader :loaded_path
 
@@ -28,14 +27,43 @@ module RuboCop
       config
     end
 
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable 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|
         cop_name = cop.respond_to?(:cop_name) ? cop.cop_name : cop
-        qualified_cop_name = Cop::Registry.qualified_cop_name(cop_name, loaded_path)
-        cop_options = self[qualified_cop_name].dup || {}
-        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+
+        if ConfigObsoletion.deprecated_cop_name?(cop)
+          # Since a deprecated cop will no longer have a qualified name (as the badge is no
+          # longer valid), and since we do not want to automatically enable the cop, we just
+          # set the configuration to an empty hash if it is unset.
+          # This is necessary to allow a renamed cop have its old configuration merged in
+          # before being used (which is necessary to allow it to be disabled via config).
+          cop_options = self[cop_name].dup || {}
+        else
+          qualified_cop_name = Cop::Registry.qualified_cop_name(cop_name, loaded_path, warn: false)
+          cop_options = self[qualified_cop_name].dup || {}
+          cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+
+          # If the cop has deprecated names (ie. it has been renamed), it is possible that
+          # users will still have old configuration for the cop's old name. In this case,
+          # if `ConfigObsoletion` is configured to warn rather than error (and therefore
+          # RuboCop runs), we want to respect the old configuration, so merge it in.
+          #
+          # NOTE: If there is configuration for both the cop and a deprecated names, the old
+          # configuration will be merged on top of the new configuration!
+          ConfigObsoletion.deprecated_names_for(cop).each do |deprecated_cop_name|
+            deprecated_config = @for_cop[deprecated_cop_name]
+            next if deprecated_config.empty?
+
+            warn Rainbow(<<~WARNING).yellow
+              Warning: Using `#{deprecated_cop_name}` configuration in #{loaded_path} for `#{cop}`.
+            WARNING
+
+            cop_options.merge!(@for_cop[deprecated_cop_name])
+          end
+        end
+
         h[cop] = h[cop_name] = cop_options
       end
       @hash = hash
@@ -44,7 +72,11 @@ module RuboCop
       @badge_config_cache = {}.compare_by_identity
       @clusivity_config_exists_cache = {}
     end
-    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def loaded_plugins
+      @loaded_plugins ||= ConfigLoader.loaded_plugins
+    end
 
     def loaded_features
       @loaded_features ||= ConfigLoader.loaded_features
@@ -82,10 +114,7 @@ module RuboCop
 
     def make_excludes_absolute
       each_key do |key|
-        @validator.validate_section_presence(key)
-        next unless self[key]['Exclude']
-
-        self[key]['Exclude'].map! do |exclude_elem|
+        dig(key, 'Exclude')&.map! do |exclude_elem|
           if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
             File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
           else
@@ -125,6 +154,13 @@ module RuboCop
       @for_cop[cop]
     end
 
+    # @return [Config, Hash] for the given cop / cop name.
+    # If the given cop is enabled, returns its configuration hash.
+    # Otherwise, returns an empty hash.
+    def for_enabled_cop(cop)
+      cop_enabled?(cop) ? for_cop(cop) : EMPTY_CONFIG
+    end
+
     # @return [Config] for the given cop merged with that of its department (if any)
     # Note: the 'Enabled' attribute is same as that returned by `for_cop`
     def for_badge(badge)
@@ -161,6 +197,10 @@ module RuboCop
       @for_all_cops ||= self['AllCops'] || {}
     end
 
+    def cop_enabled?(name)
+      !!for_cop(name)['Enabled']
+    end
+
     def disabled_new_cops?
       for_all_cops['NewCops'] == 'disable'
     end
@@ -173,6 +213,10 @@ module RuboCop
       for_all_cops['ActiveSupportExtensionsEnabled']
     end
 
+    def string_literals_frozen_by_default?
+      for_all_cops['StringLiteralsFrozenByDefault']
+    end
+
     def file_to_include?(file)
       relative_file_path = path_relative_to_config(file)
 
@@ -246,6 +290,10 @@ module RuboCop
         end
     end
 
+    def parser_engine
+      @parser_engine ||= for_all_cops.fetch('ParserEngine', :default).to_sym
+    end
+
     def target_rails_version
       @target_rails_version ||=
         if for_all_cops['TargetRailsVersion']
@@ -261,6 +309,7 @@ module RuboCop
       PathUtil.smart_path(@loaded_path)
     end
 
+    # @return [String, nil]
     def bundler_lock_file_path
       return nil unless loaded_path
 
@@ -284,27 +333,48 @@ module RuboCop
       end
     end
 
+    # Returns target's locked gem versions (i.e. from Gemfile.lock or gems.locked)
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions_in_target
+      @gem_versions_in_target ||= read_gem_versions_from_target_lockfile
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{object_id} @loaded_path=#{loaded_path}>"
     end
 
     private
 
+    # @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
     end
 
+    # @return [Float, nil] The Rails version as a `major.minor` Float.
     def read_rails_version_from_bundler_lock_file
-      lock_file_path = bundler_lock_file_path
-      return nil unless lock_file_path
-
-      File.foreach(lock_file_path) do |line|
-        # If Rails (or one of its frameworks) is in Gemfile.lock or gems.lock, there should be
-        # a line like:
-        #         railties (X.X.X)
-        result = line.match(/^\s+railties\s+\((\d+\.\d+)/)
-        return result.captures.first.to_f if result
-      end
+      return nil unless gem_versions_in_target
+
+      # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
+      # See https://github.com/rubocop/rubocop/pull/11289
+      rails_version_in_target = gem_versions_in_target['railties']
+      return nil unless rails_version_in_target
+
+      gem_version_to_major_minor_float(rails_version_in_target)
+    end
+
+    # @param [Gem::Version] gem_version an object like `Gem::Version.new("7.1.2.3")`
+    # @return [Float] The major and minor version, like `7.1`
+    def gem_version_to_major_minor_float(gem_version)
+      segments = gem_version.segments
+      Float("#{segments[0]}.#{segments[1]}")
+    end
+
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def read_gem_versions_from_target_lockfile
+      lockfile_path = bundler_lock_file_path
+      return nil unless lockfile_path
+
+      Lockfile.new(lockfile_path).gem_versions
     end
 
     def enable_cop?(qualified_cop_name, cop_options)

data/lib/rubocop/config_finder.rb

@@ -17,8 +17,8 @@ module RuboCop
       attr_writer :project_root
 
       def find_config_path(target_dir)
-        find_project_dotfile(target_dir) || find_user_dotfile || find_user_xdg_config ||
-          DEFAULT_FILE
+        find_project_dotfile(target_dir) || find_project_root_dot_config ||
+          find_user_dotfile || find_user_xdg_config || DEFAULT_FILE
       end
 
       # Returns the path RuboCop inferred as the root of the project. No file
@@ -41,6 +41,16 @@ module RuboCop
         find_file_upwards(DOTFILE, target_dir, project_root)
       end
 
+      def find_project_root_dot_config
+        return unless project_root
+
+        dotfile = File.join(project_root, '.config', DOTFILE)
+        return dotfile if File.exist?(dotfile)
+
+        xdg_config = File.join(project_root, '.config', 'rubocop', XDG_CONFIG)
+        xdg_config if File.exist?(xdg_config)
+      end
+
       def find_user_dotfile
         return unless ENV.key?('HOME')
 

data/lib/rubocop/config_loader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'erb'
-require 'pathname'
 require 'yaml'
 require_relative 'config_finder'
 
@@ -23,37 +22,39 @@ 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
+      attr_reader :loaded_plugins, :loaded_features
 
       alias debug? debug
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
         @debug = nil
+        @loaded_plugins = Set.new
         @loaded_features = Set.new
+        @disable_pending_cops = nil
+        @enable_pending_cops = nil
+        @ignore_parent_exclusion = nil
+        @ignore_unrecognized_cops = nil
         FileFinder.root_level = nil
       end
 
+      # rubocop:disable 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')
@@ -64,16 +65,19 @@ 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)
         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) || {}
+        yaml_tree = check_duplication(yaml_code, absolute_path)
+        hash = yaml_tree_to_hash(yaml_tree) || {}
 
         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
@@ -81,8 +85,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
 
@@ -118,21 +126,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)
@@ -152,20 +146,41 @@ 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`.
+      # 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)
+        end
+
+        @default_configuration = ConfigLoader.merge_with_default(config, path)
       end
+      # rubocop:enable Metrics/MethodLength
 
       # 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
+        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
@@ -173,26 +188,18 @@ 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
-      end
-
-      def warn_pending_cop(cop)
-        version = cop.metadata['VersionAdded'] || 'N/A'
-
-        warn Rainbow("#{cop.name}: # new in #{version}").yellow
-        warn Rainbow('  Enabled: true').yellow
-      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)
       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`.
@@ -236,8 +243,8 @@ module RuboCop
         raise ConfigNotFoundError, "Configuration file not found: #{absolute_path}"
       end
 
-      def yaml_safe_load(yaml_code, filename)
-        yaml_safe_load!(yaml_code, filename)
+      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'
@@ -246,10 +253,16 @@ module RuboCop
         raise
       end
 
-      def yaml_safe_load!(yaml_code, filename)
-        YAML.safe_load(
-          yaml_code, permitted_classes: [Regexp, Symbol], aliases: true, filename: filename
-        )
+      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
 

data/lib/rubocop/config_loader_resolver.rb

@@ -2,16 +2,35 @@
 
 require 'pathname'
 require 'yaml'
+require_relative 'plugin'
 
 module RuboCop
   # A help class for ConfigLoader that handles configuration resolution.
   # @api private
-  class ConfigLoaderResolver
+  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
@@ -105,7 +124,7 @@ 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
@@ -157,20 +176,27 @@ 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
 
     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 && inherit_mode.include?(key)
+      return if base_hash[key].is_a?(Array) && inherit_mode&.include?(key)
+
+      puts duplicate_setting_warning(opts, key)
+    end
 
-      puts "#{PathUtil.smart_path(opts[:file])}: " \
-           "#{opts[:cop_name]}:#{key} overrides " \
-           "the same parameter in #{opts[:inherited_file]}"
+    def duplicate_setting_warning(opts, key)
+      "#{PathUtil.smart_path(opts[:file])}: " \
+        "#{opts[:cop_name]}:#{key} overrides " \
+        "the same parameter in #{opts[:inherited_file]}"
     end
 
     def determine_inherit_mode(hash, key)
@@ -180,7 +206,7 @@ module RuboCop
     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)
@@ -194,11 +220,11 @@ module RuboCop
     end
 
     def should_merge?(mode, key)
-      mode && mode['merge'] && mode['merge'].include?(key)
+      mode && mode['merge']&.include?(key)
     end
 
     def should_override?(mode, key)
-      mode && mode['override'] && mode['override'].include?(key)
+      mode && mode['override']&.include?(key)
     end
 
     def merge_hashes?(base_hash, derived_hash, key)
@@ -218,7 +244,7 @@ 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))
       elsif Pathname.new(inherit_from).absolute?
@@ -238,9 +264,8 @@ module RuboCop
       end
     end
 
-    def remote_file?(uri)
-      regex = URI::DEFAULT_PARSER.make_regexp(%w[http https])
-      /\A#{regex}\z/.match?(uri)
+    def remote_config?(file)
+      file.is_a?(RemoteConfig)
     end
 
     def handle_disabled_by_default(config, new_default_configuration)
@@ -267,8 +292,14 @@ module RuboCop
 
     def gem_config_path(gem_name, relative_config_path)
       if defined?(Bundler)
-        gem = Bundler.load.specs[gem_name].first
-        gem_path = gem.full_gem_path if gem
+        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
+        end
       end
 
       gem_path ||= Gem::Specification.find_by_name(gem_name).gem_dir

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