rubocop 1.26.0 → 1.36.0

data/lib/rubocop/options.rb

@@ -63,6 +63,7 @@ module RuboCop
 
         add_check_options(opts)
         add_cache_options(opts)
+        add_server_options(opts)
         add_output_options(opts)
         add_autocorrection_options(opts)
         add_config_generation_options(opts)
@@ -80,7 +81,7 @@ module RuboCop
         option(opts, '-x', '--fix-layout') do
           @options[:only] ||= []
           @options[:only] << 'Layout'
-          @options[:auto_correct] = true
+          @options[:autocorrect] = true
         end
         option(opts, '--safe')
         add_cop_selection_csv_option('except', opts)
@@ -93,6 +94,7 @@ module RuboCop
         option(opts, '--force-exclusion')
         option(opts, '--only-recognized-file-types')
         option(opts, '--ignore-parent-exclusion')
+        option(opts, '--ignore-unrecognized-cops')
         option(opts, '--force-default-config')
         option(opts, '-s', '--stdin FILE')
         option(opts, '-P', '--[no-]parallel')
@@ -123,20 +125,40 @@ module RuboCop
         option(opts, '--display-time')
         option(opts, '--display-only-failed')
         option(opts, '--display-only-fail-level-offenses')
+        option(opts, '--display-only-correctable')
+        option(opts, '--display-only-safe-correctable')
       end
     end
 
-    def add_autocorrection_options(opts)
-      section(opts, 'Auto-correction') do
-        option(opts, '-a', '--auto-correct') { @options[:safe_auto_correct] = true }
+    # rubocop:todo Naming/InclusiveLanguage
+    # the autocorrect command-line arguments map to the autocorrect @options values like so:
+    #                            :fix_layout  :autocorrect  :safe_autocorrect  :autocorrect_all
+    # -x, --fix-layout           true         true          -                  -
+    # -a, --auto-correct         -            true          true               -
+    #     --safe-auto-correct    -            true          true               -
+    # -A, --auto-correct-all     -            true          -                  true
+    def add_autocorrection_options(opts) # rubocop:disable Metrics/MethodLength
+      section(opts, 'Autocorrection') do
+        option(opts, '-a', '--autocorrect') { @options[:safe_autocorrect] = true }
+        option(opts, '--auto-correct') do
+          handle_deprecated_option('--auto-correct', '--autocorrect')
+          @options[:safe_autocorrect] = true
+        end
         option(opts, '--safe-auto-correct') do
-          warn '--safe-auto-correct is deprecated; use --auto-correct'
-          @options[:safe_auto_correct] = @options[:auto_correct] = true
+          handle_deprecated_option('--safe-auto-correct', '--autocorrect')
+          @options[:safe_autocorrect] = true
+        end
+
+        option(opts, '-A', '--autocorrect-all') { @options[:autocorrect] = true }
+        option(opts, '--auto-correct-all') do
+          handle_deprecated_option('--auto-correct-all', '--autocorrect-all')
+          @options[:autocorrect] = true
         end
-        option(opts, '-A', '--auto-correct-all') { @options[:auto_correct] = true }
+
         option(opts, '--disable-uncorrectable')
       end
     end
+    # rubocop:enable Naming/InclusiveLanguage
 
     def add_config_generation_options(opts)
       section(opts, 'Config Generation') do
@@ -182,6 +204,16 @@ module RuboCop
       end
     end
 
+    def add_server_options(opts)
+      section(opts, 'Server Options') do
+        option(opts, '--[no-]server')
+        option(opts, '--restart-server')
+        option(opts, '--start-server')
+        option(opts, '--stop-server')
+        option(opts, '--server-status')
+      end
+    end
+
     def add_additional_modes(opts)
       section(opts, 'Additional Modes') do
         option(opts, '-L', '--list-target-files')
@@ -206,6 +238,11 @@ module RuboCop
       end
     end
 
+    def handle_deprecated_option(old_option, new_option)
+      warn rainbow.wrap("#{old_option} is deprecated; use #{new_option} instead.").yellow
+      @options[long_opt_symbol([new_option])] = @options.delete(long_opt_symbol([old_option]))
+    end
+
     def rainbow
       @rainbow ||= begin
         rainbow = Rainbow.new
@@ -234,10 +271,10 @@ module RuboCop
     end
 
     # Finds the option in `args` starting with -- and converts it to a symbol,
-    # e.g. [..., '--auto-correct', ...] to :auto_correct.
+    # e.g. [..., '--autocorrect', ...] to :autocorrect.
     def long_opt_symbol(args)
       long_opt = args.find { |arg| arg.start_with?('--') }
-      long_opt[2..-1].sub('[no-]', '').sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
+      long_opt[2..].sub('[no-]', '').sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
 
     def require_feature(file)
@@ -308,11 +345,13 @@ module RuboCop
 
       if display_only_fail_level_offenses_with_autocorrect?
         raise OptionArgumentError, '--autocorrect cannot be used with ' \
-                                   '--display-only-fail-level-offenses'
+                                   '--display-only-fail-level-offenses.'
       end
       validate_auto_gen_config
-      validate_auto_correct
+      validate_autocorrect
       validate_display_only_failed
+      validate_display_only_failed_and_display_only_correctable
+      validate_display_only_correctable_and_autocorrect
       disable_parallel_when_invalid_option_combo
 
       return if incompatible_options.size <= 1
@@ -342,35 +381,49 @@ module RuboCop
             format('--display-only-failed can only be used together with --format junit.')
     end
 
-    def validate_auto_correct
-      return if @options.key?(:auto_correct)
+    def validate_display_only_correctable_and_autocorrect
+      return unless @options.key?(:autocorrect)
+      return if !@options.key?(:display_only_correctable) &&
+                !@options.key?(:display_only_safe_correctable)
+
+      raise OptionArgumentError,
+            '--autocorrect cannot be used with --display-only-[safe-]correctable.'
+    end
+
+    def validate_display_only_failed_and_display_only_correctable
+      return unless @options.key?(:display_only_failed)
+      return if !@options.key?(:display_only_correctable) &&
+                !@options.key?(:display_only_safe_correctable)
+
+      raise OptionArgumentError,
+            format('--display-only-failed cannot be used together with other display options.')
+    end
+
+    def validate_autocorrect
+      return if @options.key?(:autocorrect)
       return unless @options.key?(:disable_uncorrectable)
 
       raise OptionArgumentError,
-            format('--disable-uncorrectable can only be used together with --auto-correct.')
+            format('--disable-uncorrectable can only be used together with --autocorrect.')
     end
 
     def disable_parallel_when_invalid_option_combo
       return unless @options.key?(:parallel)
 
-      invalid_options = [
-        { name: :auto_gen_config, value: true, flag: '--auto-gen-config' },
-        { name: :fail_fast, value: true, flag: '-F/--fail-fast.' },
-        { name: :auto_correct, value: true, flag: '--auto-correct.' },
-        { name: :cache, value: 'false', flag: '--cache false' }
-      ]
-
-      invalid_flags = invalid_options.each_with_object([]) do |option, flags|
-        # `>` rather than `>=` because `@options` will also contain `parallel: true`
-        flags << option[:flag] if @options > { option[:name] => option[:value] }
-      end
+      invalid_flags = invalid_arguments_for_parallel
 
       return if invalid_flags.empty?
 
       @options.delete(:parallel)
 
       puts '-P/--parallel is being ignored because ' \
-           "it is not compatible with #{invalid_flags.join(', ')}"
+           "it is not compatible with #{invalid_flags.join(', ')}."
+    end
+
+    def invalid_arguments_for_parallel
+      [('--auto-gen-config' if @options.key?(:auto_gen_config)),
+       ('-F/--fail-fast'    if @options.key?(:fail_fast)),
+       ('--cache false'     if @options > { cache: 'false' })].compact
     end
 
     def only_includes_redundant_disable?
@@ -379,7 +432,7 @@ module RuboCop
     end
 
     def display_only_fail_level_offenses_with_autocorrect?
-      @options[:display_only_fail_level_offenses] && @options[:autocorrect]
+      @options.key?(:display_only_fail_level_offenses) && @options.key?(:autocorrect)
     end
 
     def except_syntax?
@@ -405,7 +458,7 @@ module RuboCop
     def validate_cache_enabled_for_cache_root
       return unless @options[:cache] == 'false'
 
-      raise OptionArgumentError, '--cache-root can not be used with --cache false'
+      raise OptionArgumentError, '--cache-root cannot be used with --cache false'
     end
   end
 
@@ -441,7 +494,7 @@ module RuboCop
       exclude_limit:                    ['Set the limit for how many files to explicitly exclude.',
                                          'If there are more files than the limit, the cop will',
                                          "be disabled instead. Default is #{MAX_EXCL}."],
-      disable_uncorrectable:            ['Used with --auto-correct to annotate any',
+      disable_uncorrectable:            ['Used with --autocorrect to annotate any',
                                          'offenses that do not support autocorrect',
                                          'with `rubocop:todo` comments.'],
       force_exclusion:                  ['Any files excluded by `Exclude` in configuration',
@@ -454,6 +507,7 @@ module RuboCop
                                          'by a `rubocop:disable` directive.'],
       ignore_parent_exclusion:          ['Prevent from inheriting `AllCops/Exclude` from',
                                          'parent folders.'],
+      ignore_unrecognized_cops:         ['Ignore unrecognized cops or departments in the config.'],
       force_default_config:             ['Use default configuration even if configuration',
                                          'files are present in the directory tree.'],
       format:                           ['Choose an output formatter. This option',
@@ -481,6 +535,9 @@ module RuboCop
       display_only_fail_level_offenses:
                                         ['Only output offense messages at',
                                          'the specified --fail-level or above'],
+      display_only_correctable:         ['Only output correctable offense messages.'],
+      display_only_safe_correctable:    ['Only output safe-correctable offense messages',
+                                         'when combined with --display-only-correctable.'],
       show_cops:                        ['Shows the given cops, or all cops by',
                                          'default, and their configurations for the',
                                          'current directory.'],
@@ -507,12 +564,14 @@ module RuboCop
       safe:                             'Run only safe cops.',
       stderr:                           ['Write all output to stderr except for the',
                                          'autocorrected source. This is especially useful',
-                                         'when combined with --auto-correct and --stdin.'],
+                                         'when combined with --autocorrect and --stdin.'],
       list_target_files:                'List all files RuboCop will inspect.',
-      auto_correct:                     'Auto-correct offenses (only when it\'s safe).',
+      autocorrect:                      'Autocorrect offenses (only when it\'s safe).',
+      auto_correct:                     '(same, deprecated)',
       safe_auto_correct:                '(same, deprecated)',
-      auto_correct_all:                 'Auto-correct offenses (safe and unsafe)',
-      fix_layout:                       'Run only layout cops, with auto-correct on.',
+      autocorrect_all:                  'Autocorrect offenses (safe and unsafe).',
+      auto_correct_all:                 '(same, deprecated)',
+      fix_layout:                       'Run only layout cops, with autocorrect on.',
       color:                            'Force color output on or off.',
       version:                          'Display version.',
       verbose_version:                  'Display verbose version.',
@@ -520,7 +579,17 @@ module RuboCop
                                          'parallel. Default is true.'],
       stdin:                            ['Pipe source from STDIN, using FILE in offense',
                                          'reports. This is useful for editor integration.'],
-      init:                             'Generate a .rubocop.yml file in the current directory.'
+      init:                             'Generate a .rubocop.yml file in the current directory.',
+      server:                           ['If a server process has not been started yet, start',
+                                         'the server process and execute inspection with server.',
+                                         'Default is false.',
+                                         'You can specify the server host and port with the',
+                                         '$RUBOCOP_SERVER_HOST and the $RUBOCOP_SERVER_PORT',
+                                         'environment variables.'],
+      restart_server:                   'Restart server process.',
+      start_server:                     'Start server process.',
+      stop_server:                      'Stop server process.',
+      server_status:                    'Show server status.'
     }.freeze
   end
 end

data/lib/rubocop/rake_task.rb

@@ -32,6 +32,15 @@ module RuboCop
 
     private
 
+    def perform(option)
+      options = full_options.unshift(option)
+      # `parallel` will automatically be removed from the options internally.
+      # This is a nice to have to suppress the warning message
+      # about --parallel and --autocorrect not being compatible.
+      options.delete('--parallel')
+      run_cli(verbose, options)
+    end
+
     def run_cli(verbose, options)
       # We lazy-load RuboCop so that the task doesn't dramatically impact the
       # load time of your Rakefile.
@@ -60,19 +69,35 @@ module RuboCop
       @formatters = []
     end
 
-    def setup_subtasks(name, *args, &task_block)
+    def setup_subtasks(name, *args, &task_block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       namespace(name) do
-        desc 'Auto-correct RuboCop offenses'
+        # rubocop:todo Naming/InclusiveLanguage
+        task(:auto_correct, *args) do
+          require 'rainbow'
+          warn Rainbow(
+            'rubocop:auto_correct task is deprecated; ' \
+            'use rubocop:autocorrect task or rubocop:autocorrect_all task instead.'
+          ).yellow
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
+        end
+        # rubocop:enable Naming/InclusiveLanguage
+
+        desc "Autocorrect RuboCop offenses (only when it's safe)."
+        task(:autocorrect, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
+        end
 
-        task(:auto_correct, *args) do |_, task_args|
+        desc 'Autocorrect RuboCop offenses (safe and unsafe).'
+        task(:autocorrect_all, *args) do |_, task_args|
           RakeFileUtils.verbose(verbose) do
             yield(*[self, task_args].slice(0, task_block.arity)) if task_block
-            options = full_options.unshift('--auto-correct-all')
-            # `parallel` will automatically be removed from the options internally.
-            # This is a nice to have to suppress the warning message
-            # about parallel and auto-correct not being compatible.
-            options.delete('--parallel')
-            run_cli(verbose, options)
+            perform('--autocorrect-all')
           end
         end
       end

data/lib/rubocop/result_cache.rb

@@ -4,14 +4,22 @@ require 'digest/sha1'
 require 'find'
 require 'etc'
 require 'zlib'
+require_relative 'cache_config'
 
 module RuboCop
   # Provides functionality for caching RuboCop runs.
   # @api private
   class ResultCache
-    NON_CHANGING = %i[color format formatters out debug fail_level auto_correct
+    NON_CHANGING = %i[color format formatters out debug fail_level
+                      fix_layout autocorrect safe_autocorrect autocorrect_all
                       cache fail_fast stdin parallel].freeze
 
+    DL_EXTENSIONS = ::RbConfig::CONFIG
+                    .values_at('DLEXT', 'DLEXT2')
+                    .reject { |ext| !ext || ext.empty? }
+                    .map    { |ext| ".#{ext}" }
+                    .freeze
+
     # Remove old files so that the cache doesn't grow too big. When the
     # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
     # files in the cache are removed. The reason for removing so much is that
@@ -66,16 +74,9 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = ENV['RUBOCOP_CACHE_ROOT']
-      root ||= config_store.for_pwd.for_all_cops['CacheRootDirectory']
-      root ||= if ENV.key?('XDG_CACHE_HOME')
-                 # Include user ID in the path to make sure the user has write
-                 # access.
-                 File.join(ENV['XDG_CACHE_HOME'], Process.uid.to_s)
-               else
-                 File.join(ENV['HOME'], '.cache')
-               end
-      File.join(root, 'rubocop_cache')
+      CacheConfig.root_dir do
+        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      end
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
@@ -179,14 +180,24 @@ module RuboCop
             .select { |path| File.file?(path) }
             .sort!
             .each do |path|
-              content = File.binread(path)
-              digest << Zlib.crc32(content).to_s # mtime not reliable
+              digest << digest(path)
             end
           digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
           digest.hexdigest
         end
     end
 
+    def digest(path)
+      content = if path.end_with?(*DL_EXTENSIONS)
+                  # Shared libraries often contain timestamps of when
+                  # they were compiled and other non-stable data.
+                  File.basename(path)
+                else
+                  File.binread(path) # mtime not reliable
+                end
+      Zlib.crc32(content).to_s
+    end
+
     def rubocop_extra_features
       lib_root = File.join(File.dirname(__FILE__), '..')
       exe_root = File.join(lib_root, '..', 'exe')

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,7 +6,7 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { 2.5 }
+  let(:ruby_version) { 2.6 }
   let(:rails_version) { false }
 
   def inspect_source(source, file = nil)
@@ -38,7 +38,7 @@ module CopHelper
   def autocorrect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-    cop.instance_variable_get(:@options)[:auto_correct] = true
+    cop.instance_variable_get(:@options)[:autocorrect] = true
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -38,7 +38,7 @@ module RuboCop
     #       'Avoid chaining a method call on a do...end block.'
     #     )
     #
-    # Auto-correction can be tested using `expect_correction` after
+    # Autocorrection can be tested using `expect_correction` after
     # `expect_offense`.
     #
     # @example `expect_offense` and `expect_correction`
@@ -58,7 +58,7 @@ module RuboCop
     # that there were no offenses. The `expect_offense` method has
     # to do more work by parsing out lines that contain carets.
     #
-    # If the code produces an offense that could not be auto-corrected, you can
+    # If the code produces an offense that could not be autocorrected, you can
     # use `expect_no_corrections` after `expect_offense`.
     #
     # @example `expect_offense` and `expect_no_corrections`
@@ -205,7 +205,7 @@ module RuboCop
       def set_formatter_options
         RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
         RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-        cop.instance_variable_get(:@options)[:auto_correct] = true
+        cop.instance_variable_get(:@options)[:autocorrect] = true
       end
 
       # Parsed representation of code annotated with the `^^^ Message` style

data/lib/rubocop/rspec/parallel_formatter.rb

@@ -65,7 +65,7 @@ module RuboCop
       # removed!
       def output_rerun_commands(summary)
         output.puts '# RERUN BEGIN'
-        output.puts summary.colorized_rerun_commands.lines[3..-1].join
+        output.puts summary.colorized_rerun_commands.lines[3..].join
         output.puts '# RERUN END'
       end
 

data/lib/rubocop/rspec/shared_contexts.rb

@@ -2,11 +2,11 @@
 
 require 'tmpdir'
 
-RSpec.shared_context 'isolated environment', :isolated_environment do
+RSpec.shared_context 'isolated environment' do
   around do |example|
     Dir.mktmpdir do |tmpdir|
-      original_home = ENV['HOME']
-      original_xdg_config_home = ENV['XDG_CONFIG_HOME']
+      original_home = Dir.home
+      original_xdg_config_home = ENV.fetch('XDG_CONFIG_HOME', nil)
 
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
@@ -38,7 +38,7 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
   end
 end
 
-RSpec.shared_context 'maintain registry', :restore_registry do
+RSpec.shared_context 'maintain registry' do
   around(:each) { |example| RuboCop::Cop::Registry.with_temporary_global { example.run } }
 
   def stub_cop_class(name, inherit: RuboCop::Cop::Base, &block)
@@ -49,7 +49,7 @@ RSpec.shared_context 'maintain registry', :restore_registry do
 end
 
 # This context assumes nothing and defines `cop`, among others.
-RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
+RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
   ### Meant to be overridden at will
 
   let(:cop_class) do
@@ -116,26 +116,46 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
-RSpec.shared_context 'ruby 2.5', :ruby25 do
+RSpec.shared_context 'ruby 2.0' do
+  let(:ruby_version) { 2.0 }
+end
+
+RSpec.shared_context 'ruby 2.1' do
+  let(:ruby_version) { 2.1 }
+end
+
+RSpec.shared_context 'ruby 2.2' do
+  let(:ruby_version) { 2.2 }
+end
+
+RSpec.shared_context 'ruby 2.3' do
+  let(:ruby_version) { 2.3 }
+end
+
+RSpec.shared_context 'ruby 2.4' do
+  let(:ruby_version) { 2.4 }
+end
+
+RSpec.shared_context 'ruby 2.5' do
   let(:ruby_version) { 2.5 }
 end
 
-RSpec.shared_context 'ruby 2.6', :ruby26 do
+RSpec.shared_context 'ruby 2.6' do
   let(:ruby_version) { 2.6 }
 end
 
-RSpec.shared_context 'ruby 2.7', :ruby27 do
+RSpec.shared_context 'ruby 2.7' do
   let(:ruby_version) { 2.7 }
 end
 
-RSpec.shared_context 'ruby 3.0', :ruby30 do
+RSpec.shared_context 'ruby 3.0' do
   let(:ruby_version) { 3.0 }
 end
 
-RSpec.shared_context 'ruby 3.1', :ruby31 do
+RSpec.shared_context 'ruby 3.1' do
   let(:ruby_version) { 3.1 }
 end
 
-RSpec.shared_context 'ruby 3.2', :ruby32 do
+RSpec.shared_context 'ruby 3.2' do
   let(:ruby_version) { 3.2 }
 end

data/lib/rubocop/rspec/support.rb

@@ -11,4 +11,18 @@ require_relative 'parallel_formatter'
 RSpec.configure do |config|
   config.include CopHelper
   config.include HostEnvironmentSimulatorHelper
+  config.include_context 'config', :config
+  config.include_context 'isolated environment', :isolated_environment
+  config.include_context 'maintain registry', :restore_registry
+  config.include_context 'ruby 2.0', :ruby20
+  config.include_context 'ruby 2.1', :ruby21
+  config.include_context 'ruby 2.2', :ruby22
+  config.include_context 'ruby 2.3', :ruby23
+  config.include_context 'ruby 2.4', :ruby24
+  config.include_context 'ruby 2.5', :ruby25
+  config.include_context 'ruby 2.6', :ruby26
+  config.include_context 'ruby 2.7', :ruby27
+  config.include_context 'ruby 3.0', :ruby30
+  config.include_context 'ruby 3.1', :ruby31
+  config.include_context 'ruby 3.2', :ruby32
 end

data/lib/rubocop/runner.rb

@@ -13,7 +13,7 @@ module RuboCop
 
       def initialize(path, offenses_by_iteration, loop_start: -1)
         @offenses = offenses_by_iteration.flatten.uniq
-        root_cause = offenses_by_iteration[loop_start..-1]
+        root_cause = offenses_by_iteration[loop_start..]
                      .map { |x| x.map(&:cop_name).uniq.join(', ') }
                      .join(' -> ')
 
@@ -63,8 +63,16 @@ module RuboCop
     # Warms up the RuboCop cache by forking a suitable number of RuboCop
     # instances that each inspects its allotted group of files.
     def warm_cache(target_files)
+      saved_options = @options.dup
+      if target_files.length <= 1
+        puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
+        return
+      end
       puts 'Running parallel inspection' if @options[:debug]
+      %i[autocorrect safe_autocorrect].each { |opt| @options[opt] = false }
       Parallel.each(target_files) { |target_file| file_offenses(target_file) }
+    ensure
+      @options = saved_options
     end
 
     def find_target_files(paths)
@@ -143,10 +151,10 @@ module RuboCop
 
       if cache&.valid?
         offenses = cache.load
-        # If we're running --auto-correct and the cache says there are
+        # If we're running --autocorrect and the cache says there are
         # offenses, we need to actually inspect the file. If the cache shows no
         # offenses, we're good.
-        real_run_needed = @options[:auto_correct] && offenses.any?
+        real_run_needed = @options[:autocorrect] && offenses.any?
       else
         real_run_needed = true
       end
@@ -207,9 +215,7 @@ module RuboCop
     end
 
     def file_finished(file, offenses)
-      if @options[:display_only_fail_level_offenses]
-        offenses = offenses.select { |o| considered_failure?(o) }
-      end
+      offenses = offenses_to_report(offenses)
       formatter_set.file_finished(file, offenses)
     end
 
@@ -242,7 +248,7 @@ module RuboCop
       # error message.
       offenses_by_iteration = []
 
-      # When running with --auto-correct, we need to inspect the file (which
+      # When running with --autocorrect, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
@@ -380,6 +386,34 @@ module RuboCop
       !offense.corrected? && offense.severity >= minimum_severity_to_fail
     end
 
+    def offenses_to_report(offenses)
+      if @options[:display_only_fail_level_offenses]
+        offenses.select { |o| considered_failure?(o) }
+      elsif @options[:display_only_safe_correctable]
+        offenses.select { |o| supports_safe_autocorrect?(o) }
+      elsif @options[:display_only_correctable]
+        offenses.select(&:correctable?)
+      else
+        offenses
+      end
+    end
+
+    def supports_safe_autocorrect?(offense)
+      cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
+      default_cfg = default_config(offense.cop_name)
+
+      offense.correctable? &&
+        cop_class&.support_autocorrect? && mark_as_safe_by_config?(default_cfg)
+    end
+
+    def mark_as_safe_by_config?(config)
+      config.nil? || (config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true))
+    end
+
+    def default_config(cop_name)
+      RuboCop::ConfigLoader.default_configuration[cop_name]
+    end
+
     def minimum_severity_to_fail
       @minimum_severity_to_fail ||= begin
         # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail