rubocop 0.82.0 → 1.18.4

data/lib/rubocop/cli/command/version.rb

@@ -4,12 +4,13 @@ module RuboCop
   class CLI
     module Command
       # Display version.
+      # @api private
       class Version < Base
         self.command_name = :version
 
         def run
-          puts RuboCop::Version.version(false) if @options[:version]
-          puts RuboCop::Version.version(true) if @options[:verbose_version]
+          puts RuboCop::Version.version(debug: false) if @options[:version]
+          puts RuboCop::Version.version(debug: true, env: env) if @options[:verbose_version]
         end
       end
     end

data/lib/rubocop/cli/environment.rb

@@ -3,6 +3,7 @@
 module RuboCop
   class CLI
     # Execution environment for a CLI command.
+    # @api private
     class Environment
       attr_reader :options, :config_store, :paths
 

data/lib/rubocop/comment_config.rb

@@ -4,17 +4,6 @@ module RuboCop
   # This class parses the special `rubocop:disable` comments in a source
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
-    REDUNDANT_DISABLE = 'Lint/RedundantCopDisableDirective'
-
-    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'
-    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
-    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
-
-    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      ('# rubocop : ((?:disable|enable|todo))\b ' + COPS_PATTERN)
-        .gsub(' ', '\s*')
-    )
-
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
 
     attr_reader :processed_source
@@ -36,31 +25,37 @@ module RuboCop
     end
 
     def extra_enabled_comments
-      extra_enabled_comments_with_names([], {})
+      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: Hash.new(0))
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none?(line_number)
     end
 
     private
 
-    def extra_enabled_comments_with_names(extras, names)
-      each_directive do |comment, cop_names, disabled|
-        next unless comment_only_line?(comment.loc.expression.line)
+    def extra_enabled_comments_with_names(extras:, names:)
+      each_directive do |directive|
+        next unless comment_only_line?(directive.line_number)
 
-        if !disabled && enable_all?(comment)
-          handle_enable_all(names, extras, comment)
+        if directive.enabled_all?
+          handle_enable_all(directive, names, extras)
         else
-          handle_switch(cop_names, names, disabled, extras, comment)
+          handle_switch(directive, names, extras)
         end
       end
 
       extras
     end
 
-    def analyze
+    def analyze # rubocop:todo Metrics/AbcSize
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
 
-      each_mentioned_cop do |cop_name, disabled, line, single_line|
-        analyses[cop_name] =
-          analyze_cop(analyses[cop_name], disabled, line, single_line)
+      each_directive do |directive|
+        directive.cop_names.each do |cop_name|
+          cop_name = qualified_cop_name(cop_name)
+          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        end
       end
 
       analyses.each_with_object({}) do |element, hash|
@@ -69,37 +64,42 @@ module RuboCop
       end
     end
 
-    def analyze_cop(analysis, disabled, line, single_line)
-      if single_line
-        analyze_single_line(analysis, line, disabled)
-      elsif disabled
-        analyze_disabled(analysis, line)
+    def analyze_cop(analysis, directive)
+      # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
+      if !comment_only_line?(directive.line_number) || directive.single_line?
+        analyze_single_line(analysis, directive)
+      elsif directive.disabled?
+        analyze_disabled(analysis, directive)
       else
-        analyze_rest(analysis, line)
+        analyze_rest(analysis, directive)
       end
     end
 
-    def analyze_single_line(analysis, line, disabled)
-      return analysis unless disabled
+    def analyze_single_line(analysis, directive)
+      return analysis unless directive.disabled?
 
-      CopAnalysis.new(analysis.line_ranges + [(line..line)],
-                      analysis.start_line_number)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
     end
 
-    def analyze_disabled(analysis, line)
-      if (start_line = analysis.start_line_number)
-        # Cop already disabled on this line, so we end the current disabled
-        # range before we start a new range.
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
-      end
+    def analyze_disabled(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      # Cop already disabled on this line, so we end the current disabled
+      # range before we start a new range.
+      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
 
       CopAnalysis.new(analysis.line_ranges, line)
     end
 
-    def analyze_rest(analysis, line)
-      if (start_line = analysis.start_line_number)
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
-      end
+    def analyze_rest(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
 
       CopAnalysis.new(analysis.line_ranges, nil)
     end
@@ -110,60 +110,15 @@ module RuboCop
       analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
     end
 
-    def each_mentioned_cop
-      each_directive do |comment, cop_names, disabled|
-        comment_line_number = comment.loc.expression.line
-        single_line = !comment_only_line?(comment_line_number) ||
-                      directive_on_comment_line?(comment)
-
-        cop_names.each do |cop_name|
-          yield qualified_cop_name(cop_name), disabled, comment_line_number,
-                single_line
-        end
-      end
-    end
-
-    def directive_on_comment_line?(comment)
-      comment.text[1..-1].match(COMMENT_DIRECTIVE_REGEXP)
-    end
-
     def each_directive
-      return if processed_source.comments.nil?
-
-      processed_source.each_comment do |comment|
-        directive = directive_parts(comment)
-        next unless directive
-
-        yield comment, *directive
+      processed_source.comments.each do |comment|
+        directive = DirectiveComment.new(comment)
+        yield directive if directive.cop_names
       end
     end
 
-    def directive_parts(comment)
-      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
-      return unless match
-
-      switch, cops_string = match.captures
-
-      cop_names =
-        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
-
-      disabled = %w[disable todo].include?(switch)
-
-      [cop_names, disabled]
-    end
-
     def qualified_cop_name(cop_name)
-      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.file_path)
-    end
-
-    def all_cop_names
-      @all_cop_names ||= Cop::Cop.registry.names - [REDUNDANT_DISABLE]
-    end
-
-    def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none? do |non_comment_line_number|
-        non_comment_line_number == line_number
-      end
+      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
     end
 
     def non_comment_token_line_numbers
@@ -173,12 +128,7 @@ module RuboCop
       end
     end
 
-    def enable_all?(comment)
-      _, cops = comment.text.match(COMMENT_DIRECTIVE_REGEXP).captures
-      cops == 'all'
-    end
-
-    def handle_enable_all(names, extras, comment)
+    def handle_enable_all(directive, names, extras)
       enabled_cops = 0
       names.each do |name, counter|
         next unless counter.positive?
@@ -187,18 +137,19 @@ module RuboCop
         enabled_cops += 1
       end
 
-      extras << [comment, 'all'] if enabled_cops.zero?
+      extras[directive.comment] << 'all' if enabled_cops.zero?
     end
 
-    def handle_switch(cop_names, names, disabled, extras, comment)
-      cop_names.each do |name|
-        names[name] ||= 0
-        if disabled
+    # Collect cops that have been disabled or enabled by name in a directive comment
+    # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
+    def handle_switch(directive, names, extras)
+      directive.cop_names.each do |name|
+        if directive.disabled?
           names[name] += 1
         elsif (names[name]).positive?
           names[name] -= 1
         else
-          extras << [comment, name]
+          extras[directive.comment] << name
         end
       end
     end

data/lib/rubocop/config.rb

@@ -24,7 +24,7 @@ module RuboCop
     def initialize(hash = {}, loaded_path = nil)
       @loaded_path = loaded_path
       @for_cop = Hash.new do |h, cop|
-        qualified_cop_name = Cop::Cop.qualified_cop_name(cop, loaded_path)
+        qualified_cop_name = Cop::Registry.qualified_cop_name(cop, loaded_path)
         cop_options = self[qualified_cop_name] || {}
         cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
         h[cop] = cop_options
@@ -33,21 +33,26 @@ module RuboCop
       @validator = ConfigValidator.new(self)
     end
 
-    def self.create(hash, path)
-      new(hash, path).check
+    def self.create(hash, path, check: true)
+      config = new(hash, path)
+      config.check if check
+
+      config
+    end
+
+    def loaded_features
+      @loaded_features ||= ConfigLoader.loaded_features
     end
 
     def check
-      deprecation_check do |deprecation_message|
-        warn("#{loaded_path} - #{deprecation_message}")
-      end
+      deprecation_check { |deprecation_message| warn("#{loaded_path} - #{deprecation_message}") }
       @validator.validate
       make_excludes_absolute
       self
     end
 
-    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
-                   :map, :merge, :to_h, :to_hash, :transform_values
+    def_delegators :@hash, :[], :[]=, :delete, :dig, :each, :key?, :keys, :each_key,
+                   :fetch, :map, :merge, :replace, :to_h, :to_hash, :transform_values
     def_delegators :@validator, :validate, :target_ruby_version
 
     def to_s
@@ -60,8 +65,7 @@ module RuboCop
 
     # True if this is a config file that is shipped with RuboCop
     def internal?
-      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
-                                                    'config'))
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME, 'config'))
       File.expand_path(loaded_path).start_with?(base_config_path)
     end
 
@@ -72,8 +76,7 @@ module RuboCop
 
         self[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))
+            File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
           else
             exclude_elem
           end
@@ -104,12 +107,26 @@ module RuboCop
       end
     end
 
+    # @return [Config] for the given cop / cop name.
+    # Note: the 'Enabled' attribute is calculated according to the department's
+    # and 'AllCops' configuration; other attributes are not inherited.
     def for_cop(cop)
       @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
     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)
+      cop_config = for_cop(badge.to_s)
+      fetch(badge.department.to_s) { return cop_config }.merge(cop_config)
+    end
+
+    # @return [Config] for the given department name.
+    # Note: the 'Enabled' attribute will be present only if specified
+    # at the department's level
     def for_department(department_name)
-      @for_cop[department_name]
+      @for_department ||= Hash.new { |h, dept| h[dept] = self[dept] || {} }
+      @for_department[department_name.to_s]
     end
 
     def for_all_cops
@@ -129,8 +146,7 @@ module RuboCop
 
       # Optimization to quickly decide if the given file is hidden (on the top
       # level) and cannot be matched by any pattern.
-      is_hidden = relative_file_path.start_with?('.') &&
-                  !relative_file_path.start_with?('..')
+      is_hidden = relative_file_path.start_with?('.') && !relative_file_path.start_with?('..')
       return false if is_hidden && !possibly_include_hidden?
 
       absolute_file_path = File.expand_path(file)
@@ -139,8 +155,7 @@ module RuboCop
         if block_given?
           yield pattern, relative_file_path, absolute_file_path
         else
-          match_path?(pattern, relative_file_path) ||
-            match_path?(pattern, absolute_file_path)
+          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
         end
       end
     end
@@ -152,9 +167,8 @@ module RuboCop
       return true if File.extname(file) == '.gemspec'
 
       file_to_include?(file) do |pattern, relative_path, absolute_path|
-        pattern.to_s =~ /[A-Z]/ &&
-          (match_path?(pattern, relative_path) ||
-           match_path?(pattern, absolute_path))
+        /[A-Z]/.match?(pattern.to_s) &&
+          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
       end
     end
 
@@ -170,9 +184,7 @@ module RuboCop
 
     def file_to_exclude?(file)
       file = File.expand_path(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file)
-      end
+      patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
     end
 
     def patterns_to_include
@@ -243,8 +255,7 @@ module RuboCop
     private
 
     def target_rails_version_from_bundler_lock_file
-      @target_rails_version_from_bundler_lock_file ||=
-        read_rails_version_from_bundler_lock_file
+      @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
     end
 
     def read_rails_version_from_bundler_lock_file
@@ -260,17 +271,22 @@ module RuboCop
     end
 
     def enable_cop?(qualified_cop_name, cop_options)
+      # If the cop is explicitly enabled, the other checks can be skipped.
+      return true if cop_options['Enabled'] == true
+
       department = department_of(qualified_cop_name)
+      cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+      return true if cop_enabled == 'override_department'
       return false if department && department['Enabled'] == false
 
-      cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+      cop_enabled
     end
 
     def department_of(qualified_cop_name)
-      cop_department, cop_name = qualified_cop_name.split('/')
-      return nil if cop_name.nil?
+      *cop_department, _ = qualified_cop_name.split('/')
+      return nil if cop_department.empty?
 
-      self[cop_department]
+      self[cop_department.join('/')]
     end
   end
 end

data/lib/rubocop/config_loader.rb

@@ -18,40 +18,54 @@ module RuboCop
     XDG_CONFIG = 'config.yml'
     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, :disable_pending_cops, :enable_pending_cops
-      attr_writer :default_configuration
+      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops
+      attr_writer :default_configuration, :project_root
+      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)
+        loaded_features = resolver.resolve_requires(path, hash)
+        add_loaded_features(loaded_features)
 
         add_missing_namespaces(path, hash)
 
+        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)
+        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)
@@ -59,7 +73,7 @@ module RuboCop
         # `can't add a new key into hash during iteration` error
         hash_keys = hash.keys
         hash_keys.each do |key|
-          q = Cop::Cop.qualified_cop_name(key, path)
+          q = Cop::Registry.qualified_cop_name(key, path)
           next if q == key
 
           hash[q] = hash.delete(key)
@@ -83,10 +97,10 @@ module RuboCop
           find_user_xdg_config || DEFAULT_FILE
       end
 
-      def configuration_from_file(config_file)
-        return ConfigLoader.default_configuration 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)
+        config = load_file(config_file, check: check)
         if ignore_parent_exclusion?
           print 'Ignoring AllCops/Exclude from parent folders' if debug?
         else
@@ -94,9 +108,7 @@ module RuboCop
         end
 
         merge_with_default(config, config_file).tap do |merged_config|
-          unless possible_new_cops?(config)
-            warn_on_pending_cops(merged_config.pending_cops)
-          end
+          warn_on_pending_cops(merged_config.pending_cops) unless possible_new_cops?(merged_config)
         end
       end
 
@@ -106,74 +118,81 @@ module RuboCop
       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, 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
+          print 'Default ' if debug?
+          load_file(DEFAULT_FILE)
+        end
+      end
+
+      # Returns the path rubocop inferred as the root of the project. No file
+      # searches will go past this directory.
+      def project_root
+        @project_root ||= find_project_root
       end
 
+      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 can also opt-in to new cops by default by adding this to your config:
+          AllCops:
+            NewCops: enable
+      BANNER
+
       def warn_on_pending_cops(pending_cops)
         return if pending_cops.empty?
 
-        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
+        warn Rainbow(PENDING_BANNER).yellow
 
-        pending_cops.each do |cop|
-          warn Rainbow(
-            " - #{cop.name} (#{cop.metadata['VersionAdded']})"
-          ).yellow
-        end
+        pending_cops.each { |cop| warn_pending_cop cop }
 
-        warn Rainbow('For more information: https://docs.rubocop.org/en/latest/versioning/').yellow
+        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
       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 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
 
-      def add_inheritance_from_auto_generated_file
-        file_string = " #{AUTO_GENERATED_FILE}"
-
-        config_file = options_config || DOTFILE
-
-        if File.exist?(config_file)
-          files = Array(load_yaml_configuration(config_file)['inherit_from'])
-
-          return if files.include?(AUTO_GENERATED_FILE)
+      # @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
 
-          files.unshift(AUTO_GENERATED_FILE)
-          file_string = "\n  - " + files.join("\n  - ") if files.size > 1
-          rubocop_yml_contents = existing_configuration(config_file)
-        end
+      private
 
-        write_config_file(config_file, file_string, rubocop_yml_contents)
+      def file_path(file)
+        File.absolute_path(file.is_a?(RemoteConfig) ? file.file : file)
+      end
 
-        puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
+      def find_project_dotfile(target_dir)
+        find_file_upwards(DOTFILE, target_dir, project_root)
       end
 
-      private
+      def find_project_root
+        pwd = Dir.pwd
+        gems_file = find_last_file_upwards('Gemfile', pwd) || find_last_file_upwards('gems.rb', pwd)
+        return unless gems_file
 
-      def find_project_dotfile(target_dir)
-        find_file_upwards(DOTFILE, target_dir)
+        File.dirname(gems_file)
       end
 
       def find_user_dotfile
@@ -197,39 +216,10 @@ module RuboCop
         path
       end
 
-      def existing_configuration(config_file)
-        IO.read(config_file, encoding: Encoding::UTF_8)
-          .sub(/^inherit_from: *[^\n]+/, '')
-          .sub(/^inherit_from: *(\n *- *[^\n]+)+/, '')
-      end
-
-      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"
-          if /\S/.match?(rubocop_yml_contents)
-            f.write "\n#{rubocop_yml_contents}"
-          end
-        end
-      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|
@@ -239,10 +229,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
@@ -252,25 +241,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