rubocop 1.90.0 → 1.92.0

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -59,15 +59,22 @@ module RuboCop
 
               plugin_config.make_excludes_absolute
 
-              # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin
-              # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` above
-              # carries such keys into each subsequent plugin's config, where `unset_nil: true`
-              # would delete them from the combined configuration.
-              ConfigLoader.merge_with_default(plugin_config, plugin_config_path, unset_nil: false)
+              merge_plugin_config_with_default(plugin_config, plugin_config_path)
             end
           end
         end
 
+        # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin
+        # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` carries
+        # such keys into each subsequent plugin's config, where `unset_nil: true` would
+        # delete them from the combined configuration. Preview is left to be applied when
+        # a project configuration is resolved against the defaults.
+        def merge_plugin_config_with_default(plugin_config, plugin_config_path)
+          ConfigLoader.merge_with_default(
+            plugin_config, plugin_config_path, unset_nil: false, resolve_preview: false
+          )
+        end
+
         def merge_plugin_config_into_all_cops!(rubocop_config, plugin_config)
           rubocop_config['AllCops'].merge!(plugin_config['AllCops'])
         end

data/lib/rubocop/plugin/loader.rb

@@ -8,7 +8,7 @@ module RuboCop
     # A class for loading and resolving plugins.
     # @api private
     class Loader
-      # rubocop:disable Layout/LineLength
+      # rubocop:disable Layout/LineLength -- the comment on each key does not wrap
       DEFAULT_PLUGIN_CONFIG = {
         'enabled' => true,
         'require_path' => nil, # If not set, will be set to the plugin name

data/lib/rubocop/rake_task.rb

@@ -74,7 +74,7 @@ module RuboCop
 
     def setup_subtasks(name, *args, &task_block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       namespace(name) do
-        # rubocop:todo-next Naming/InclusiveLanguage
+        # rubocop:todo-next Naming/InclusiveLanguage -- the deprecated flag spelling is the subject here
         task(:auto_correct, *args) do |_, task_args|
           require 'rainbow'
           warn Rainbow(

data/lib/rubocop/remote_config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'net/http'
 require 'time'
+require 'uri'
 
 module RuboCop
   # Common methods and behaviors for dealing with remote config files.
@@ -45,13 +45,16 @@ module RuboCop
     def request(uri = @uri, limit = 10, &block)
       raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
 
+      # Loaded here rather than at the top, since most runs never fetch a remote config.
+      require 'net/http'
+
       http = Net::HTTP.new(uri.hostname, uri.port)
       http.use_ssl = uri.instance_of?(URI::HTTPS)
 
       generate_request(uri) do |request|
-        handle_response(http.request(request), limit, &block)
+        handle_response(http.request(request), uri, limit, &block)
       rescue SocketError => e
-        handle_response(e, limit, &block)
+        handle_response(e, uri, limit, &block)
       end
     end
 
@@ -64,12 +67,12 @@ module RuboCop
       yield request
     end
 
-    def handle_response(response, limit, &block)
+    def handle_response(response, uri, limit, &block)
       case response
       when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
         yield response
       when Net::HTTPRedirection
-        request(URI.parse(response['location']), limit - 1, &block)
+        request(URI.join(uri, response['location']), limit - 1, &block)
       else
         begin
           response.error!

data/lib/rubocop/result_cache.rb

@@ -59,9 +59,9 @@ module RuboCop
         puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, remove_count)
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EPERM, Errno::EROFS
         # This can happen if parallel RuboCop invocations try to remove the
-        # same files. No problem.
+        # same files, or if the cache can't be written to. No problem.
         puts $ERROR_INFO if verbose
       end
 
@@ -123,7 +123,7 @@ module RuboCop
     end
 
     def valid?
-      File.exist?(@path)
+      !@checksum_unavailable && File.exist?(@path)
     end
 
     def load
@@ -132,30 +132,23 @@ module RuboCop
     end
 
     def save(offenses)
+      return if @checksum_unavailable
+
       dir = File.dirname(@path)
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES, Errno::EROFS => e
+      rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache.\n  #{e.message}"
         return
       end
 
-      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
       # RuboCop must be in control of where its cached data is stored. A
       # symbolic link anywhere in the cache directory tree can be an
       # indication that a symlink attack is being waged.
       return if symlink_protection_triggered?(dir)
 
-      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
-        f.write(@cached_data.to_json(offenses))
-      end
-      # The preliminary path is used so that if there are multiple RuboCop
-      # processes trying to save data for the same inspected file
-      # simultaneously, the only problem we run in to is a competition who gets
-      # to write to the final file. The contents are the same, so no corruption
-      # of data should occur.
-      FileUtils.mv(preliminary_path, @path)
+      write_cache_file(offenses)
     end
 
     private
@@ -175,15 +168,40 @@ module RuboCop
       false
     end
 
+    def write_cache_file(offenses)
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    rescue Errno::EACCES, Errno::EPERM, Errno::EROFS => e
+      FileUtils.rm_f(preliminary_path)
+      warn "Couldn't write cache file. Continuing without cache.\n  #{e.message}"
+    end
+
     def file_checksum(file, config_store)
+      stat = File.stat(file)
+      return unavailable_checksum unless stat.file?
+
       digester = Digest::SHA1.new
-      mode = File.stat(file).mode
-      digester.update("#{file}#{mode}#{config_store.for_file(file).signature}")
+      digester.update("#{file}#{stat.mode}#{config_store.for_file(file).signature}")
       digester.file(file)
       digester.hexdigest
     rescue Errno::ENOENT
-      # Spurious files that come and go should not cause a crash, at least not
-      # here.
+      # Spurious files that come and go should not cause a crash, at least not here.
+      unavailable_checksum
+    end
+
+    # Every file that fails to checksum shares this sentinel value, so the cache entry
+    # must be neither saved nor considered valid, or one file's cached results could be
+    # served as another's.
+    def unavailable_checksum
+      @checksum_unavailable = true
       '_'
     end
 

data/lib/rubocop/runner.rb

@@ -63,9 +63,20 @@ module RuboCop
       @warnings = []
       @aborting = false
       @inspected_files = []
+      @diff_sources = {}
       @report_queue = {}
     end
 
+    # The `--diff` patches, one per file, from the source on disk (or stdin) to
+    # the source once every correction, redundant directive removal included,
+    # has been applied.
+    def diffs
+      @diffs ||= @diff_sources.filter_map do |file, (original_source, corrected_source)|
+        diff = UnifiedDiff.new(PathUtil.smart_path(file), original_source, corrected_source).to_s
+        diff unless diff.empty?
+      end
+    end
+
     def run(paths)
       @inspection_team_by_config = {}.compare_by_identity
 
@@ -73,7 +84,7 @@ module RuboCop
       # inconsistencies between workers.
       ResultCache.source_checksum
 
-      target_files = find_target_files(paths)
+      target_files = only_changed(find_target_files(paths))
       build_project_index(target_files)
 
       if @options[:list_target_files]
@@ -95,6 +106,14 @@ module RuboCop
 
     private
 
+    # The project index is deliberately built from the unfiltered file list:
+    # cross-file offenses must not depend on which files happen to have changed.
+    def only_changed(target_files)
+      return target_files unless @options[:changed]
+
+      ChangedFiles.new(@options[:changed]).filter(target_files).freeze
+    end
+
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
       mode = if @options[:only_recognized_file_types]
@@ -147,11 +166,12 @@ module RuboCop
 
     def inspect_files(files) # rubocop:disable Metrics/AbcSize
       formatter_set.started(files)
+      formatters_started = true
       file_iterator(files) do |file|
-        offenses = process_file(file)
+        offenses, problems = collect_problems { process_file(file) }
         succeeded = offenses.none? { |o| considered_failure?(o) && offense_displayed?(o) }
 
-        [offenses, succeeded]
+        [offenses, succeeded, problems]
       end
     ensure
       # OPTIMIZE: Calling `ResultCache.cleanup` takes time. This optimization
@@ -160,17 +180,18 @@ module RuboCop
       if files.size > 1 && cached_run?
         ResultCache.cleanup(@config_store, @options[:debug], @options[:cache_root])
       end
-      formatter_set.finished(@inspected_files.freeze)
+      formatter_set.finished(@inspected_files.freeze) if formatters_started
       formatter_set.close_output_files
+      warn_about_elided_offenses
     end
 
     def file_iterator(files, &block)
       all_passed = true
 
       on_start = ->(file, _index) { file_started(file) }
-      on_finish = lambda do |file, index, (offenses, passed)|
+      on_finish = lambda do |file, index, (offenses, passed, problems)|
         all_passed &&= passed
-        finished_report(file, index, offenses)
+        finished_report(file, index, offenses, problems)
       end
 
       if run_in_parallel?(files)
@@ -184,8 +205,8 @@ module RuboCop
       all_passed
     end
 
-    def finished_report(file, index, offenses)
-      @report_queue[index] = [file, offenses]
+    def finished_report(file, index, offenses, problems)
+      @report_queue[index] = [file, offenses, problems]
       @next_index_to_report ||= 0
       while @report_queue.key?(@next_index_to_report)
         process_report_queue_entry(@next_index_to_report)
@@ -194,7 +215,10 @@ module RuboCop
     end
 
     def process_report_queue_entry(index)
-      file, offenses = @report_queue.delete(index)
+      file, offenses, (errors, warnings) = @report_queue.delete(index)
+      @errors.concat(errors)
+      @warnings.concat(warnings)
+      file_problems(file, errors, warnings) unless errors.empty? && warnings.empty?
       file_finished(file, offenses)
     end
 
@@ -205,8 +229,7 @@ module RuboCop
     end
 
     def run_in_parallel?(files)
-      return false if @options[:auto_gen_config]
-      return false unless @options[:parallel]
+      return false unless parallel_supported_by_options?
 
       if files.size <= 1
         puts 'Skipping parallel inspection: only a single file needs inspection' if @options[:debug]
@@ -220,6 +243,13 @@ module RuboCop
       true
     end
 
+    # `--auto-gen-config` needs the offenses of every file in one place, and
+    # `--diff` collects the diffs in this process, where a worker's copy of
+    # them would be lost.
+    def parallel_supported_by_options?
+      @options[:parallel] && !@options[:auto_gen_config] && !@options[:diff]
+    end
+
     def project_index_disables_parallel?
       return false if @project_index.nil? || !Gem.win_platform?
 
@@ -252,6 +282,21 @@ module RuboCop
       paths.each { |path| puts PathUtil.relative_path(path) }
     end
 
+    # Keeps the errors and warnings a file causes apart from the rest of the
+    # run's. A parallel worker inspects files in a copy of the runner that is
+    # thrown away, so they have to travel back with the file's offenses.
+    def collect_problems
+      errors = @errors
+      warnings = @warnings
+      @errors = []
+      @warnings = []
+
+      [yield, [@errors, @warnings]]
+    ensure
+      @errors = errors
+      @warnings = warnings
+    end
+
     def process_file(file)
       file_offenses(file)
     rescue InfiniteCorrectionLoop => e
@@ -304,9 +349,11 @@ module RuboCop
         if redundant_updated
           # Do one extra inspection loop if any redundant disables were
           # removed. This is done in order to find rubocop:enable directives that
-          # have now become useless.
-          _source, new_offenses = do_inspection_loop(file)
-          offenses |= new_offenses
+          # have now become useless. It finds the offenses that are left again,
+          # located in the corrected source, so only the corrected ones are kept
+          # from before, as `inspect_and_correct` does.
+          _source, new_offenses = do_inspection_loop(file, team.updated_source)
+          offenses = offenses.select(&:corrected?) | new_offenses
         end
       end
       offenses
@@ -319,6 +366,8 @@ module RuboCop
       team = Cop::Team.mobilize([Cop::Lint::RedundantCopDisableDirective], config, @options)
       return if team.cops.empty?
 
+      team.defer_corrections = @options[:diff]
+
       team.cops.first.offenses_to_check = offenses
       yield team
     end
@@ -352,6 +401,15 @@ module RuboCop
       formatter_set.file_started(file, cli_options: @options, config_store: @config_store)
     end
 
+    # Formatters get the messages without the colors added for the terminal.
+    def file_problems(file, errors, warnings)
+      formatter_set.file_problems(file, plain_messages(errors), plain_messages(warnings))
+    end
+
+    def plain_messages(problems)
+      problems.map { |problem| Rainbow::StringUtils.uncolor(problem.to_s) }
+    end
+
     def file_finished(file, offenses)
       @inspected_files << file
       offenses = offenses_to_report(offenses)
@@ -370,15 +428,16 @@ module RuboCop
       return unless cache
       # Caching results when a cop has crashed would prevent the crash in the
       # next run, since the cop would not be called then. We want crashes to
-      # show up the same in each run.
+      # show up the same in each run. Only this file's errors and warnings are
+      # visible here, see `collect_problems`.
       return if errors.any? || warnings.any?
 
       cache.save(offenses)
     end
 
-    def do_inspection_loop(file)
-      # We can reuse the prism result since the source did not change yet.
-      processed_source = get_processed_source(file, @prism_result)
+    def do_inspection_loop(file, source = nil)
+      processed_source = initial_processed_source(file, source)
+      original_source = processed_source.raw_source
       # This variable is 2d array used to track corrected offenses after each
       # inspection iteration. This is used to output meaningful infinite loop
       # error message.
@@ -391,11 +450,7 @@ module RuboCop
       # once. The corrections are kept in memory while iterating and written
       # back to the file when the loop is done.
       iterate_until_no_changes(processed_source, offenses_by_iteration) do
-        # The offenses that couldn't be corrected will be found again so we
-        # only keep the corrected ones in order to avoid duplicate reporting.
-        !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?)
-        team, new_offenses, updated_source_file = inspect_iteration(processed_source)
-        offenses_by_iteration.push(new_offenses)
+        team, updated_source_file = inspect_and_correct(processed_source, offenses_by_iteration)
 
         # We have to reprocess the source to pickup the changes. Since the
         # change could (theoretically) introduce parsing errors, we break the
@@ -411,30 +466,64 @@ module RuboCop
       # Return summary of corrected offenses after all iterations
       [processed_source, offenses_by_iteration.flatten.uniq]
     ensure
-      # Write the file once, even when the loop was left through an exception
-      # (e.g. an infinite correction loop), like the per-iteration writes
-      # used to be.
-      File.write(file, corrected_source) if corrected_source
+      finalize_corrections(file, original_source, corrected_source)
+    end
+
+    # `source` is the corrected source to continue from when the corrections
+    # are kept in memory rather than written to the file (`--diff`).
+    def initial_processed_source(file, source)
+      return get_processed_source(file, nil, source: source) if source
+
+      # We can reuse the prism result since the source did not change yet.
+      get_processed_source(file, @prism_result)
+    end
+
+    def inspect_and_correct(processed_source, offenses_by_iteration)
+      # The offenses that couldn't be corrected will be found again so we
+      # only keep the corrected ones in order to avoid duplicate reporting.
+      !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?)
+      team, new_offenses, updated_source_file = inspect_iteration(processed_source)
+      offenses_by_iteration.push(new_offenses)
+
+      [team, updated_source_file]
+    end
+
+    # Write the file once, even when the loop was left through an exception
+    # (e.g. an infinite correction loop), like the per-iteration writes used
+    # to be. Under `--diff` nothing is written at all.
+    def finalize_corrections(file, original_source, corrected_source)
+      if @options[:diff]
+        record_diff(file, original_source, corrected_source)
+      elsif corrected_source
+        Util.replace_file_contents(file, corrected_source)
+      end
+    end
+
+    # `--diff` reports what autocorrection would do instead of doing it. With
+    # `--stdin` the corrected source is handed back through the options rather
+    # than deferred, so that is where the new source comes from. A file can go
+    # through more than one inspection loop, so the diff runs from the source
+    # the first loop started with to the one the last loop ended with.
+    def record_diff(file, original_source, corrected_source)
+      return unless original_source
+
+      new_source = @options[:stdin] || corrected_source
+      # The original source is the file as it is on disk, so the corrected one
+      # has to go through the same line ending conversion `File.write` would
+      # apply, or on Windows every single line reads as changed.
+      new_source = new_source ? Util.emulate_write_read_cycle(new_source) : original_source
+
+      sources = (@diff_sources[file] ||= [original_source])
+      sources[1] = new_source
     end
 
     def inspect_iteration(processed_source)
       team = mobilize_team(processed_source)
-      team.defer_corrections = in_memory_corrections_possible?
+      team.defer_corrections = @options[:diff] || in_memory_corrections_possible?
       offenses, updated_source_file = inspect_file(processed_source, team)
       [team, offenses, updated_source_file]
     end
 
-    # When corrections were written to disk and read back between iterations,
-    # the text-mode write converted LF to CRLF on Windows, and cops like
-    # `Layout/EndOfLine` rely on seeing the source as it would be on disk.
-    # Apply the same conversion to the in-memory source. The final `File.write`
-    # still performs it for the file itself.
-    def emulate_write_read_cycle(source)
-      return source unless Platform.windows?
-
-      source.encode(source.encoding, crlf_newline: true)
-    end
-
     # Custom ruby extractors may derive their fragments from the file on
     # disk rather than from the passed processed source, so corrections can
     # only be kept in memory when the default extractor is used.
@@ -525,6 +614,12 @@ module RuboCop
       end
     end
 
+    # Lets a runner that is reused from run to run pick up a different `--only`
+    # or `--except`.
+    def forget_mobilized_cops
+      @mobilized_cop_classes = nil
+    end
+
     def mobilize_cop_badge?(badge, config)
       return false if badge.department == :Test
       return false if badge.match_name?(@options[:except])
@@ -541,7 +636,7 @@ module RuboCop
       %i[only except].each do |option|
         next unless @options[option]
 
-        @options[option].map! do |cop_name|
+        @options[option] = @options[option].map do |cop_name|
           Cop::Registry.qualified_cop_name(cop_name, "--#{option} option")
         end
       end
@@ -582,7 +677,28 @@ module RuboCop
     end
 
     def offenses_to_report(offenses)
-      offenses.select { |o| offense_displayed?(o) }
+      offenses = offenses.select { |o| offense_displayed?(o) }
+      offenses = offense_limit.filter(offenses) if offense_limit
+      offenses
+    end
+
+    # Files are reported in order, so which offenses survive the limit does not
+    # depend on how the run was parallelized.
+    def offense_limit
+      return @offense_limit if defined?(@offense_limit)
+
+      max = @options[:max_offenses_per_cop]
+      @offense_limit = (OffenseLimit.new(max.to_i) if max)
+    end
+
+    def warn_about_elided_offenses
+      elided = offense_limit&.elided_per_cop
+      return unless elided&.any?
+
+      warn Rainbow(
+        "#{elided.values.sum} more offenses were not reported because of " \
+        "--max-offenses-per-cop=#{offense_limit.max} (#{elided.keys.join(', ')})."
+      ).yellow
     end
 
     def supports_safe_autocorrect?(offense)
@@ -602,13 +718,8 @@ module RuboCop
     end
 
     def minimum_severity_to_fail
-      @minimum_severity_to_fail ||= begin
-        # Unless given explicitly as `fail_level`, `:info` severity offenses do not fail
-        name = @options[:fail_level] || :refactor
-
-        # autocorrect is a fake level - use the default
-        RuboCop::Cop::Severity.new(name == :autocorrect ? :refactor : name)
-      end
+      @minimum_severity_to_fail ||=
+        RuboCop::Cop::Severity.minimum_to_fail(@options, @config_store.for_pwd)
     end
 
     # rubocop:disable-next Metrics/MethodLength
@@ -619,7 +730,7 @@ module RuboCop
 
       processed_source = if source
                            ProcessedSource.new(
-                             emulate_write_read_cycle(source),
+                             Util.emulate_write_read_cycle(source),
                              ruby_version,
                              file,
                              parser_engine: parser_engine

data/lib/rubocop/server/cache.rb

@@ -112,8 +112,8 @@ module RuboCop
 
         def pid_running?
           Process.kill(0, pid_path(create_dir: false).read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG,
-               Errno::ENOTDIR
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EPERM, Errno::EROFS,
+               Errno::ENAMETOOLONG, Errno::ENOTDIR
           false
         end