rubocop 1.26.1 → 1.35.1

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,12 @@ 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
       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 +147,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 +211,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 +244,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 +382,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

data/lib/rubocop/server/cache.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../cache_config'
+require_relative '../config_finder'
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # Caches the states of server process.
+    # @api private
+    class Cache
+      GEMFILE_NAMES = %w[Gemfile gems.rb].freeze
+
+      class << self
+        attr_accessor :cache_root_path
+
+        # Searches for Gemfile or gems.rb in the current dir or any parent dirs
+        def project_dir
+          current_dir = Dir.pwd
+          while current_dir != '/'
+            return current_dir if GEMFILE_NAMES.any? do |gemfile|
+              File.exist?(File.join(current_dir, gemfile))
+            end
+
+            current_dir = File.expand_path('..', current_dir)
+          end
+          # If we can't find a Gemfile, just use the current directory
+          Dir.pwd
+        end
+
+        def project_dir_cache_key
+          @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
+        end
+
+        def dir
+          Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
+            d.mkpath unless d.exist?
+          end
+        end
+
+        def cache_path
+          cache_root_dir = if cache_root_path
+                             File.join(cache_root_path, 'rubocop_cache')
+                           else
+                             cache_root_dir_from_config
+                           end
+
+          File.expand_path(File.join(cache_root_dir, 'server'))
+        end
+
+        def cache_root_dir_from_config
+          CacheConfig.root_dir do
+            # `RuboCop::ConfigStore` has heavy dependencies, this is a lightweight implementation
+            # so that only the necessary `CacheRootDirectory` can be obtained.
+            require 'yaml'
+            config_path = ConfigFinder.find_config_path(Dir.pwd)
+
+            require 'erb'
+            file_contents = File.read(config_path)
+            yaml_code = ERB.new(file_contents).result
+
+            config_yaml = YAML.safe_load(yaml_code, permitted_classes: [Regexp, Symbol])
+
+            # For compatibility with Ruby 3.0 or lower.
+            if Gem::Version.new(Psych::VERSION) < Gem::Version.new('4.0.0')
+              config_yaml == false ? nil : config_yaml
+            end
+
+            config_yaml&.dig('AllCops', 'CacheRootDirectory')
+          end
+        end
+
+        def port_path
+          dir.join('port')
+        end
+
+        def token_path
+          dir.join('token')
+        end
+
+        def pid_path
+          dir.join('pid')
+        end
+
+        def lock_path
+          dir.join('lock')
+        end
+
+        def status_path
+          dir.join('status')
+        end
+
+        def version_path
+          dir.join('version')
+        end
+
+        def pid_running?
+          Process.kill(0, pid_path.read.to_i) == 1
+        rescue Errno::ESRCH
+          false
+        end
+
+        def acquire_lock
+          lock_file = File.open(lock_path, File::CREAT)
+          # flock returns 0 if successful, and false if not.
+          flock_result = lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+          yield flock_result != false
+        ensure
+          lock_file.flock(File::LOCK_UN)
+          lock_file.close
+        end
+
+        def write_port_and_token_files(port:, token:)
+          port_path.write(port)
+          token_path.write(token)
+        end
+
+        def write_pid_file
+          pid_path.write(Process.pid)
+          yield
+        ensure
+          dir.rmtree
+        end
+
+        def write_status_file(status)
+          status_path.write(status)
+        end
+
+        def write_version_file(version)
+          version_path.write(version)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/cli.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # The CLI is a class responsible of handling server command line interface logic.
+    # @api private
+    class CLI
+      # Same exit status value as `RuboCop::CLI`.
+      STATUS_SUCCESS = 0
+      STATUS_ERROR = 2
+
+      SERVER_OPTIONS = %w[
+        --server --no-server --server-status --restart-server --start-server --stop-server
+      ].freeze
+      EXCLUSIVE_OPTIONS = (SERVER_OPTIONS - %w[--server --no-server]).freeze
+
+      def initialize
+        @exit = false
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def run(argv = ARGV)
+        unless Server.support_server?
+          return error('RuboCop server is not supported by this Ruby.') if use_server_option?(argv)
+
+          return STATUS_SUCCESS
+        end
+
+        Cache.cache_root_path = fetch_cache_root_path_from(argv)
+        deleted_server_arguments = delete_server_argument_from(argv)
+
+        if deleted_server_arguments.size >= 2
+          return error("#{deleted_server_arguments.join(', ')} cannot be specified together.")
+        end
+
+        server_command = deleted_server_arguments.first
+
+        if EXCLUSIVE_OPTIONS.include?(server_command) && argv.count > allowed_option_count
+          return error("#{server_command} cannot be combined with other options.")
+        end
+
+        run_command(server_command)
+
+        STATUS_SUCCESS
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def exit?
+        @exit
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      def run_command(server_command)
+        case server_command
+        when '--server'
+          Server::ClientCommand::Start.new.run unless Server.running?
+        when '--no-server'
+          Server::ClientCommand::Stop.new.run if Server.running?
+        when '--restart-server'
+          @exit = true
+          Server::ClientCommand::Restart.new.run
+        when '--start-server'
+          @exit = true
+          Server::ClientCommand::Start.new.run
+        when '--stop-server'
+          @exit = true
+          Server::ClientCommand::Stop.new.run
+        when '--server-status'
+          @exit = true
+          Server::ClientCommand::Status.new.run
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+
+      def fetch_cache_root_path_from(arguments)
+        cache_root = arguments.detect { |argument| argument.start_with?('--cache-root') }
+        return unless cache_root
+
+        if cache_root.start_with?('--cache-root=')
+          cache_root.split('=')[1]
+        else
+          arguments[arguments.index(cache_root) + 1]
+        end
+      end
+
+      def delete_server_argument_from(all_arguments)
+        SERVER_OPTIONS.each_with_object([]) do |server_option, server_arguments|
+          server_arguments << all_arguments.delete(server_option)
+        end.compact
+      end
+
+      def use_server_option?(argv)
+        (argv & SERVER_OPTIONS).any?
+      end
+
+      def allowed_option_count
+        Cache.cache_root_path ? 2 : 1
+      end
+
+      def error(message)
+        @exit = true
+        warn Rainbow(message).red
+
+        STATUS_ERROR
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'socket'
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # Abstract base class for server client command.
+      # @api private
+      class Base
+        def run
+          raise NotImplementedError
+        end
+
+        private
+
+        def send_request(command:, args: [], body: '')
+          TCPSocket.open('127.0.0.1', Cache.port_path.read) do |socket|
+            socket.puts [Cache.token_path.read, Dir.pwd, command, *args].shelljoin
+            socket.write body
+            socket.close_write
+            $stdout.write socket.readpartial(4096) until socket.eof?
+          end
+        end
+
+        def check_running_server
+          Server.running?.tap do |running|
+            warn 'RuboCop server is not running.' unless running
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/exec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to execute server process.
+      # @api private
+      class Exec < Base
+        def run
+          ensure_server!
+          Cache.status_path.delete if Cache.status_path.file?
+          send_request(
+            command: 'exec',
+            args: ARGV.dup,
+            body: $stdin.tty? ? '' : $stdin.read
+          )
+          status
+        end
+
+        private
+
+        def ensure_server!
+          if incompatible_version?
+            puts 'RuboCop version incompatibility found, RuboCop server restarting...'
+            ClientCommand::Stop.new.run
+          elsif check_running_server
+            return
+          end
+
+          ClientCommand::Start.new.run
+        end
+
+        def incompatible_version?
+          RuboCop::Version::STRING != Cache.version_path.read
+        end
+
+        def status
+          unless Cache.status_path.file?
+            raise "RuboCop server: Could not find status file at: #{Cache.status_path}"
+          end
+
+          status = Cache.status_path.read
+          raise "RuboCop server: '#{status}' is not a valid status!" if (status =~ /^\d+$/).nil?
+
+          status.to_i
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/restart.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to restart server process.
+      # @api private
+      class Restart < Base
+        def run
+          ClientCommand::Stop.new.run
+          ClientCommand::Start.new.run
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/start.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to start server process.
+      # @api private
+      class Start < Base
+        def run
+          if Server.running?
+            warn "RuboCop server (#{Cache.pid_path.read}) is already running."
+            return
+          end
+
+          Cache.acquire_lock do |locked|
+            unless locked
+              # Another process is already starting server,
+              # so wait for it to be ready.
+              Server.wait_for_running_status!(true)
+              exit 0
+            end
+
+            Cache.write_version_file(RuboCop::Version::STRING)
+
+            host = ENV.fetch('RUBOCOP_SERVER_HOST', '127.0.0.1')
+            port = ENV.fetch('RUBOCOP_SERVER_PORT', 0)
+
+            Server::Core.new.start(host, port)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to show server process status.
+      # @api private
+      class Status < Base
+        def run
+          if Server.running?
+            puts "RuboCop server (#{Cache.pid_path.read}) is running."
+          else
+            puts 'RuboCop server is not running.'
+          end
+        end
+      end
+    end
+  end
+end