rubocop 1.29.1 → 1.45.1

data/lib/rubocop/rspec/expect_offense.rb

@@ -6,7 +6,7 @@ module RuboCop
     #
     # This mixin makes it easier to specify strict offense expectations
     # in a declarative and visual fashion. Just type out the code that
-    # should generate a offense, annotate code by writing '^'s
+    # should generate an offense, annotate code by writing '^'s
     # underneath each character that should be highlighted, and follow
     # the carets with a string (separated by a space) that is the
     # message of the offense. You can include multiple offenses in
@@ -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`
@@ -126,7 +126,7 @@ module RuboCop
         @offenses
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -138,6 +138,8 @@ module RuboCop
 
         source = @processed_source.raw_source
 
+        raise 'Use `expect_no_corrections` if the code will not change' if correction == source
+
         iteration = 0
         new_source = loop do
           iteration += 1
@@ -157,11 +159,11 @@ module RuboCop
           _investigate(cop, @processed_source)
         end
 
-        raise 'Use `expect_no_corrections` if the code will not change' if new_source == source
+        raise 'Expected correction but no corrections were made' if new_source == source
 
         expect(new_source).to eq(correction)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
@@ -205,7 +207,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/shared_contexts.rb

@@ -2,7 +2,7 @@
 
 require 'tmpdir'
 
-RSpec.shared_context 'isolated environment', :isolated_environment do
+RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLength
   around do |example|
     Dir.mktmpdir do |tmpdir|
       original_home = Dir.home
@@ -36,9 +36,22 @@ RSpec.shared_context 'isolated environment', :isolated_environment do
       end
     end
   end
+
+  if RuboCop.const_defined?(:Server)
+    around do |example|
+      RuboCop::Server::Cache.cache_root_path = nil
+      RuboCop::Server::Cache.instance_variable_set(:@project_dir_cache_key, nil)
+      begin
+        example.run
+      ensure
+        RuboCop::Server::Cache.cache_root_path = nil
+        RuboCop::Server::Cache.instance_variable_set(:@project_dir_cache_key, nil)
+      end
+    end
+  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 +62,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 +129,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

@@ -3,12 +3,26 @@
 # Require this file to load code that supports testing using RSpec.
 
 require_relative 'cop_helper'
-require_relative 'host_environment_simulation_helper'
-require_relative 'shared_contexts'
 require_relative 'expect_offense'
+require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
+require_relative 'shared_contexts'
 
 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

@@ -24,9 +24,35 @@ module RuboCop
       end
     end
 
+    class << self
+      # @return [Array<#call>]
+      def ruby_extractors
+        @ruby_extractors ||= [default_ruby_extractor]
+      end
+
+      private
+
+      # @return [#call]
+      def default_ruby_extractor
+        lambda do |processed_source|
+          [
+            {
+              offset: 0,
+              processed_source: processed_source
+            }
+          ]
+        end
+      end
+    end
+
     # @api private
     MAX_ITERATIONS = 200
 
+    # @api private
+    REDUNDANT_COP_DISABLE_DIRECTIVE_RULES = %w[
+      Lint/RedundantCopDisableDirective RedundantCopDisableDirective Lint
+    ].freeze
+
     attr_reader :errors, :warnings
     attr_writer :aborting
 
@@ -63,8 +89,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 +177,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
@@ -186,7 +220,9 @@ module RuboCop
     end
 
     def check_for_redundant_disables?(source)
-      !source.disabled_line_ranges.empty? && !filtered_run?
+      return false if source.disabled_line_ranges.empty? || except_redundant_cop_disable_directive?
+
+      !@options[:only]
     end
 
     def redundant_cop_disable_directive(file)
@@ -197,8 +233,8 @@ module RuboCop
       yield cop if cop.relevant_file?(file)
     end
 
-    def filtered_run?
-      @options[:except] || @options[:only]
+    def except_redundant_cop_disable_directive?
+      @options[:except] && (@options[:except] & REDUNDANT_COP_DISABLE_DIRECTIVE_RULES).any?
     end
 
     def file_started(file)
@@ -240,7 +276,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.
@@ -304,10 +340,25 @@ module RuboCop
     end
 
     def inspect_file(processed_source, team = mobilize_team(processed_source))
-      report = team.investigate(processed_source)
-      @errors.concat(team.errors)
-      @warnings.concat(team.warnings)
-      [report.offenses, team.updated_source_file?]
+      extracted_ruby_sources = extract_ruby_sources(processed_source)
+      offenses = extracted_ruby_sources.flat_map do |extracted_ruby_source|
+        report = team.investigate(
+          extracted_ruby_source[:processed_source],
+          offset: extracted_ruby_source[:offset],
+          original: processed_source
+        )
+        @errors.concat(team.errors)
+        @warnings.concat(team.warnings)
+        report.offenses
+      end
+      [offenses, team.updated_source_file?]
+    end
+
+    def extract_ruby_sources(processed_source)
+      self.class.ruby_extractors.find do |ruby_extractor|
+        result = ruby_extractor.call(processed_source)
+        break result if result
+      end
     end
 
     def mobilize_team(processed_source)
@@ -382,7 +433,7 @@ module RuboCop
       if @options[:display_only_fail_level_offenses]
         offenses.select { |o| considered_failure?(o) }
       elsif @options[:display_only_safe_correctable]
-        offenses.select { |o| supports_safe_auto_correct?(o) }
+        offenses.select { |o| supports_safe_autocorrect?(o) }
       elsif @options[:display_only_correctable]
         offenses.select(&:correctable?)
       else
@@ -390,7 +441,7 @@ module RuboCop
       end
     end
 
-    def supports_safe_auto_correct?(offense)
+    def supports_safe_autocorrect?(offense)
       cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
       default_cfg = default_config(offense.cop_name)
 
@@ -415,17 +466,21 @@ module RuboCop
     end
 
     def get_processed_source(file)
-      ruby_version = @config_store.for_file(file).target_ruby_version
-
-      if @options[:stdin]
-        ProcessedSource.new(@options[:stdin], ruby_version, file)
-      else
-        begin
-          ProcessedSource.from_file(file, ruby_version)
-        rescue Errno::ENOENT
-          raise RuboCop::Error, "No such file or directory: #{file}"
-        end
-      end
+      config = @config_store.for_file(file)
+      ruby_version = config.target_ruby_version
+
+      processed_source = if @options[:stdin]
+                           ProcessedSource.new(@options[:stdin], ruby_version, file)
+                         else
+                           begin
+                             ProcessedSource.from_file(file, ruby_version)
+                           rescue Errno::ENOENT
+                             raise RuboCop::Error, "No such file or directory: #{file}"
+                           end
+                         end
+      processed_source.config = config
+      processed_source.registry = mobilized_cop_classes(config)
+      processed_source
     end
 
     # A Cop::Team instance is stateful and may change when inspecting.

data/lib/rubocop/server/cache.rb

@@ -0,0 +1,155 @@
+# 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
+
+        # rubocop:disable Metrics/MethodLength
+        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.
+            config_path = ConfigFinder.find_config_path(Dir.pwd)
+            file_contents = File.read(config_path)
+
+            # Returns early if `CacheRootDirectory` is not used before requiring `erb` or `yaml`.
+            next unless file_contents.include?('CacheRootDirectory')
+
+            require 'erb'
+            yaml_code = ERB.new(file_contents).result
+
+            require 'yaml'
+            config_yaml = YAML.safe_load(
+              yaml_code, permitted_classes: [Regexp, Symbol], aliases: true
+            )
+
+            # 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
+        # rubocop:enable Metrics/MethodLength
+
+        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 stderr_path
+          dir.join('stderr')
+        end
+
+        def pid_running?
+          Process.kill(0, pid_path.read.to_i) == 1
+        rescue Errno::ESRCH, Errno::ENOENT
+          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,147 @@
+# frozen_string_literal: true
+
+require_relative '../arguments_env'
+require_relative '../arguments_file'
+
+#
+# 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
+        --no-detach
+      ].freeze
+      EXCLUSIVE_OPTIONS = (SERVER_OPTIONS - %w[--server --no-server]).freeze
+      NO_DETACH_OPTIONS = %w[--server --start-server --restart-server].freeze
+
+      def initialize
+        @exit = false
+      end
+
+      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)
+
+        process_arguments(argv)
+      end
+
+      def exit?
+        @exit
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def process_arguments(argv)
+        server_arguments = delete_server_argument_from(argv)
+
+        detach = !server_arguments.delete('--no-detach')
+
+        if server_arguments.size >= 2
+          return error("#{server_arguments.join(', ')} cannot be specified together.")
+        end
+
+        server_command = server_arguments.first
+
+        unless detach || NO_DETACH_OPTIONS.include?(server_command)
+          return error("#{server_command} cannot be combined with --no-detach.")
+        end
+
+        if EXCLUSIVE_OPTIONS.include?(server_command) && argv.count > allowed_option_count
+          return error("#{server_command} cannot be combined with #{argv[0]}.")
+        end
+
+        if server_command.nil?
+          server_command = ArgumentsEnv.read_as_arguments.delete('--server') ||
+                           ArgumentsFile.read_as_arguments.delete('--server')
+        end
+
+        run_command(server_command, detach: detach)
+
+        STATUS_SUCCESS
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      def run_command(server_command, detach:)
+        case server_command
+        when '--server'
+          Server::ClientCommand::Start.new(detach: detach).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(detach: detach).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)
+        require 'rainbow'
+
+        @exit = true
+        warn Rainbow(message).red
+
+        STATUS_ERROR
+      end
+    end
+  end
+end