rubocop 1.90.0 → 1.91.0

data/lib/rubocop/remote_config.rb

@@ -49,9 +49,9 @@ module RuboCop
       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 +64,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

@@ -123,7 +123,7 @@ module RuboCop
     end
 
     def valid?
-      File.exist?(@path)
+      !@checksum_unavailable && File.exist?(@path)
     end
 
     def load
@@ -132,6 +132,8 @@ module RuboCop
     end
 
     def save(offenses)
+      return if @checksum_unavailable
+
       dir = File.dirname(@path)
 
       begin
@@ -176,14 +178,23 @@ module RuboCop
     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

@@ -53,7 +53,7 @@ module RuboCop
       Lint/RedundantCopDisableDirective RedundantCopDisableDirective Lint
     ].freeze
 
-    attr_reader :errors, :warnings
+    attr_reader :errors, :warnings, :diffs
     attr_writer :aborting
 
     def initialize(options, config_store)
@@ -63,6 +63,7 @@ module RuboCop
       @warnings = []
       @aborting = false
       @inspected_files = []
+      @diffs = []
       @report_queue = {}
     end
 
@@ -73,7 +74,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 +96,16 @@ 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]
+
+      changed = ChangedFiles.new(@options[:changed]).paths
+
+      target_files.select { |file| changed.include?(file) }.freeze
+    end
+
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
       mode = if @options[:only_recognized_file_types]
@@ -205,8 +216,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 +230,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?
 
@@ -379,6 +396,7 @@ module RuboCop
     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)
+      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 +409,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,15 +425,49 @@ 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
+
+    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
+        File.write(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.
+    def record_diff(file, original_source, corrected_source)
+      new_source = @options[:stdin] || corrected_source
+      return unless original_source && new_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 = emulate_write_read_cycle(new_source)
+
+      diff = UnifiedDiff.new(PathUtil.smart_path(file), original_source, new_source).to_s
+      @diffs << diff unless diff.empty?
     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
@@ -602,13 +650,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

data/lib/rubocop/unified_diff.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Renders a unified diff between two versions of a file's source.
+  #
+  # RuboCop has no diffing dependency and this output is meant to be read by
+  # people (and occasionally piped into `git apply`), so the goal is a diff
+  # that is correct and readable, not one that matches `diff -u` byte for byte.
+  #
+  # @api private
+  class UnifiedDiff
+    CONTEXT_LINES = 3
+    NO_NEWLINE_MARKER = "\\n"
+
+    # Finding a minimal diff costs time and memory proportional to the square
+    # of the number of edits. Past this many edits the file was rewritten
+    # rather than corrected, so the changed region is reported as a single
+    # replacement instead.
+    MAX_EDIT_DISTANCE = 400
+
+    def initialize(path, old_source, new_source)
+      @path = path
+      @old_lines = old_source.lines
+      @new_lines = new_source.lines
+    end
+
+    # @return [String] the diff, or an empty string when the sources are identical
+    def to_s
+      return '' if @old_lines == @new_lines
+
+      hunks = hunks_for(edit_script)
+      return '' if hunks.empty?
+
+      ["--- a/#{@path}\n", "+++ b/#{@path}\n", *hunks].join
+    end
+
+    private
+
+    def edit_script
+      prefix = common_prefix_length
+      suffix = common_suffix_length(prefix)
+      old_last = @old_lines.length - suffix
+      new_last = @new_lines.length - suffix
+
+      [
+        *@old_lines[0...prefix].map { |line| [:equal, line] },
+        *middle_script(@old_lines[prefix...old_last], @new_lines[prefix...new_last]),
+        *@old_lines[old_last..].map { |line| [:equal, line] }
+      ]
+    end
+
+    def common_prefix_length
+      length = 0
+      length += 1 while length < @old_lines.length && @old_lines[length] == @new_lines[length]
+      length
+    end
+
+    def common_suffix_length(prefix)
+      length = 0
+      max = [@old_lines.length, @new_lines.length].min - prefix
+      while length < max &&
+            @old_lines[@old_lines.length - 1 - length] == @new_lines[@new_lines.length - 1 - length]
+        length += 1
+      end
+      length
+    end
+
+    def middle_script(old_lines, new_lines)
+      # The region that actually differs is diffed on its own, so the rest of
+      # the algorithm works on these two slices rather than the whole file.
+      @from_lines = old_lines
+      @to_lines = new_lines
+
+      myers_script ||
+        [*old_lines.map { |line| [:delete, line] }, *new_lines.map { |line| [:insert, line] }]
+    end
+
+    # Myers' diff algorithm. Each round `d` extends the furthest reaching path
+    # for every diagonal `k`; the first path to reach the end of both sources
+    # is a shortest edit script, which is then reconstructed from the saved
+    # rounds. Returns `nil` when the sources are too different to bother.
+    def myers_script
+      trace = []
+      furthest = Hash.new(0)
+      max_distance = [@from_lines.length + @to_lines.length, MAX_EDIT_DISTANCE].min
+
+      0.upto(max_distance) do |distance|
+        trace << furthest.dup
+
+        (-distance).step(distance, 2) do |diagonal|
+          furthest[diagonal] = advance(furthest, diagonal, distance)
+
+          return backtrack(trace) if reached_end?(furthest[diagonal], diagonal)
+        end
+      end
+
+      nil
+    end
+
+    def reached_end?(old_index, diagonal)
+      old_index >= @from_lines.length && old_index - diagonal >= @to_lines.length
+    end
+
+    # Picks the better of the two paths reaching this diagonal, then follows
+    # the diagonal as far as the lines match.
+    def advance(furthest, diagonal, distance)
+      old_index = start_of_path(furthest, diagonal, distance)
+
+      follow_diagonal(old_index, old_index - diagonal)
+    end
+
+    # A path arrives at this diagonal either from the one above it (having
+    # inserted a line) or the one below it (having deleted one); whichever
+    # reached further wins.
+    def previous_diagonal(furthest, diagonal, distance)
+      if diagonal == -distance ||
+         (diagonal != distance && furthest[diagonal - 1] < furthest[diagonal + 1])
+        diagonal + 1
+      else
+        diagonal - 1
+      end
+    end
+
+    def start_of_path(furthest, diagonal, distance)
+      previous = previous_diagonal(furthest, diagonal, distance)
+
+      previous > diagonal ? furthest[previous] : furthest[previous] + 1
+    end
+
+    # Matching lines cost nothing, so the path slides along them for free.
+    def follow_diagonal(old_index, new_index)
+      while old_index < @from_lines.length && new_index < @to_lines.length &&
+            @from_lines[old_index] == @to_lines[new_index]
+        old_index += 1
+        new_index += 1
+      end
+
+      old_index
+    end
+
+    def backtrack(trace)
+      script = []
+      position = [@from_lines.length, @to_lines.length]
+
+      trace.each_with_index.reverse_each do |furthest, distance|
+        previous = previous_position(furthest, distance, *position)
+        position = walk_diagonal(script, position, previous)
+        next if distance.zero?
+
+        position = record_edit(script, position, previous)
+      end
+
+      script
+    end
+
+    # Both sides step back together for as long as their lines match.
+    def walk_diagonal(script, position, previous)
+      old_index, new_index = position
+
+      while old_index > previous[0] && new_index > previous[1]
+        old_index -= 1
+        new_index -= 1
+        script.unshift([:equal, @from_lines[old_index]])
+      end
+
+      [old_index, new_index]
+    end
+
+    def record_edit(script, position, previous)
+      old_index, new_index = position
+
+      if old_index == previous[0]
+        new_index -= 1
+        script.unshift([:insert, @to_lines[new_index]])
+      else
+        old_index -= 1
+        script.unshift([:delete, @from_lines[old_index]])
+      end
+
+      [old_index, new_index]
+    end
+
+    def previous_position(furthest, distance, old_index, new_index)
+      previous = previous_diagonal(furthest, old_index - new_index, distance)
+      previous_old = furthest[previous]
+
+      [previous_old, previous_old - previous]
+    end
+
+    def hunks_for(script)
+      changed = script.each_index.reject { |index| script[index].first == :equal }
+      return [] if changed.empty?
+
+      ranges_for(changed, script.length).map { |range| hunk(script, range) }
+    end
+
+    # Every change is shown with a few lines of context around it, and changes
+    # whose context would overlap are shown as a single hunk.
+    def ranges_for(changed, script_length)
+      ranges = []
+
+      changed.each do |index|
+        first = [index - CONTEXT_LINES, 0].max
+        last = [index + CONTEXT_LINES, script_length - 1].min
+
+        if ranges.last && first <= ranges.last.last + 1
+          ranges[-1] = (ranges.last.first..last)
+        else
+          ranges << (first..last)
+        end
+      end
+
+      ranges
+    end
+
+    def hunk(script, range)
+      old_start, new_start = start_positions(script, range.first)
+      old_count = script[range].count { |kind, _| kind != :insert }
+      new_count = script[range].count { |kind, _| kind != :delete }
+      body = script[range].map { |kind, line| formatted_line(kind, line) }
+
+      [
+        "@@ -#{position(old_start, old_count)} +#{position(new_start, new_count)} @@\n",
+        *body
+      ].join
+    end
+
+    def start_positions(script, index)
+      old_line = 1
+      new_line = 1
+
+      script[0...index].each do |entry|
+        old_line += 1 unless entry.first == :insert
+        new_line += 1 unless entry.first == :delete
+      end
+
+      [old_line, new_line]
+    end
+
+    # An empty side is anchored to the line it follows, which is how `diff`
+    # reports a pure insertion or deletion, and a single line drops the count.
+    def position(start, count)
+      case count
+      when 0 then "#{start - 1},0"
+      when 1 then start.to_s
+      else "#{start},#{count}"
+      end
+    end
+
+    def formatted_line(kind, line)
+      marker = { equal: ' ', delete: '-', insert: '+' }.fetch(kind)
+      return "#{marker}#{line}" if line.end_with?("\n")
+
+      "#{marker}#{line}\n#{NO_NEWLINE_MARKER}"
+    end
+  end
+end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.90.0'
+    STRING = '1.91.0'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/lib/rubocop.rb

@@ -27,6 +27,7 @@ require_relative 'rubocop/ext/regexp_parser'
 require_relative 'rubocop/core_ext/string'
 require_relative 'rubocop/ext/processed_source'
 
+require_relative 'rubocop/changed_files'
 require_relative 'rubocop/error'
 require_relative 'rubocop/file_finder'
 require_relative 'rubocop/file_patterns'
@@ -34,10 +35,11 @@ require_relative 'rubocop/name_similarity'
 require_relative 'rubocop/path_util'
 require_relative 'rubocop/platform'
 require_relative 'rubocop/string_interpreter'
+require_relative 'rubocop/unified_diff'
 require_relative 'rubocop/util'
 require_relative 'rubocop/warning'
 
-# rubocop:disable Style/RequireOrder
+# rubocop:disable Style/RequireOrder -- ordered by load dependency, not alphabetically
 
 require_relative 'rubocop/project_index_loader'
 require_relative 'rubocop/cop/util'
@@ -112,6 +114,7 @@ require_relative 'rubocop/target_finder'
 require_relative 'rubocop/directive_comment'
 require_relative 'rubocop/comment_config/directive_range'
 require_relative 'rubocop/comment_config/disable_next'
+require_relative 'rubocop/comment_config/push_pop'
 require_relative 'rubocop/comment_config'
 require_relative 'rubocop/result_cache'
 require_relative 'rubocop/runner'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.90.0
+  version: 1.91.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -201,6 +201,7 @@ files:
 - lib/rubocop/ast_aliases.rb
 - lib/rubocop/cache_config.rb
 - lib/rubocop/cached_data.rb
+- lib/rubocop/changed_files.rb
 - lib/rubocop/cli.rb
 - lib/rubocop/cli/command.rb
 - lib/rubocop/cli/command/auto_generate_config.rb
@@ -218,6 +219,7 @@ files:
 - lib/rubocop/comment_config.rb
 - lib/rubocop/comment_config/directive_range.rb
 - lib/rubocop/comment_config/disable_next.rb
+- lib/rubocop/comment_config/push_pop.rb
 - lib/rubocop/config.rb
 - lib/rubocop/config_finder.rb
 - lib/rubocop/config_loader.rb
@@ -502,6 +504,7 @@ files:
 - lib/rubocop/cop/lint/literal_assignment_in_condition.rb
 - lib/rubocop/cop/lint/literal_in_interpolation.rb
 - lib/rubocop/cop/lint/loop.rb
+- lib/rubocop/cop/lint/misplaced_magic_comment.rb
 - lib/rubocop/cop/lint/missing_cop_enable_directive.rb
 - lib/rubocop/cop/lint/missing_super.rb
 - lib/rubocop/cop/lint/mixed_case_range.rb
@@ -785,7 +788,6 @@ files:
 - lib/rubocop/cop/style/document_dynamic_eval_definition.rb
 - lib/rubocop/cop/style/documentation.rb
 - lib/rubocop/cop/style/documentation_method.rb
-- lib/rubocop/cop/style/double_cop_disable_directive.rb
 - lib/rubocop/cop/style/double_negation.rb
 - lib/rubocop/cop/style/each_for_simple_loop.rb
 - lib/rubocop/cop/style/each_with_object.rb
@@ -1073,6 +1075,7 @@ files:
 - lib/rubocop/formatter/pacman_formatter.rb
 - lib/rubocop/formatter/progress_formatter.rb
 - lib/rubocop/formatter/quiet_formatter.rb
+- lib/rubocop/formatter/sarif_formatter.rb
 - lib/rubocop/formatter/simple_text_formatter.rb
 - lib/rubocop/formatter/tap_formatter.rb
 - lib/rubocop/formatter/text_util.rb
@@ -1131,6 +1134,7 @@ files:
 - lib/rubocop/target_finder.rb
 - lib/rubocop/target_ruby.rb
 - lib/rubocop/todo_audit.rb
+- lib/rubocop/unified_diff.rb
 - lib/rubocop/util.rb
 - lib/rubocop/version.rb
 - lib/rubocop/warning.rb
@@ -1142,9 +1146,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.90.0
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.91.0
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.90/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.91/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []

data/lib/rubocop/cop/style/double_cop_disable_directive.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/RedundantCopDisableDirective
-# rubocop:disable Style/DoubleCopDisableDirective
-
-module RuboCop
-  module Cop
-    module Style
-      # Detects double disable comments on one line. This is mostly to catch
-      # automatically generated comments that need to be regenerated.
-      #
-      # @example
-      #   # bad
-      #   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
-      #   end
-      #
-      #   # good
-      #   # rubocop:disable Metrics/AbcSize
-      #   def f # rubocop:disable Style/For
-      #   end
-      #   # rubocop:enable Metrics/AbcSize
-      #
-      #   # if both fit on one line
-      #   def f # rubocop:disable Style/For, Metrics/AbcSize
-      #   end
-      #
-      class DoubleCopDisableDirective < Base
-        extend AutoCorrector
-
-        # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
-        MSG = 'More than one disable comment on one line.'
-
-        def on_new_investigation
-          processed_source.comments.each do |comment|
-            next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
-
-            add_offense(comment) do |corrector|
-              corrector.replace(comment, comment.text.gsub(%r{ # rubocop:(disable|todo)}, ','))
-            end
-          end
-        end
-      end
-    end
-  end
-end