rubocop 1.71.1 → 1.92.1

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/util.rb

@@ -12,5 +12,74 @@ module RuboCop
     ensure
       $VERBOSE = old_verbose
     end
+
+    # The source as it reads back after `File.write`, which in text mode turns
+    # each LF into CRLF on Windows. Cops like `Layout/EndOfLine` have to see
+    # corrected code that way between correction passes, and so does anything
+    # that compares it with what a write leaves on disk. The final `File.write`
+    # still performs the conversion for the file itself.
+    def self.emulate_write_read_cycle(source)
+      return source unless Platform.windows?
+
+      source.encode(source.encoding, crlf_newline: true)
+    end
+
+    # Replaces the contents of `path` without a window in which the file is truncated
+    # but not yet rewritten, so that an interrupted run or a full disk cannot lose
+    # the original: the new contents are written next to the file and renamed over it,
+    # like `ResultCache#save`. `File.write` is used for the temporary file so text-mode
+    # semantics (the CRLF conversion on Windows) stay identical to a direct write.
+    # Where the temporary file cannot be created or renamed for lack of permission,
+    # a direct write is used as before.
+    def self.replace_file_contents(path, contents)
+      # Write through symlinks so that the rename replaces the real file and
+      # the symlink survives.
+      path = File.realpath(path)
+
+      # Opening a read-only file fails without truncating it, keeping the behavior
+      # a direct write always had.
+      return File.write(path, contents) unless File.writable?(path)
+
+      temp_path = "#{path}.#{Process.pid}.#{rand(1_000_000_000)}.rubocop.tmp"
+      begin
+        replace_via_temporary_file(path, temp_path, contents)
+      ensure
+        FileUtils.rm_f(temp_path)
+      end
+    rescue Errno::ENOENT
+      # The file vanished mid-run or is a dangling symlink: recreate it the way
+      # a direct write always has.
+      File.write(path, contents)
+    end
+
+    def self.replace_via_temporary_file(path, temp_path, contents)
+      # The directory refuses new files even though the file itself is writable,
+      # so a direct write is the only option left.
+      return File.write(path, contents) unless write_temporary_file(temp_path, contents)
+
+      begin
+        # A fresh file would get umask-default permissions on rename;
+        # keep the original's.
+        File.chmod(File.stat(path).mode, temp_path)
+        File.rename(temp_path, path)
+      rescue SystemCallError
+        # The replacement was refused, e.g. the file is open in another process on Windows.
+        # The contents already fit on disk, so a direct write is safe once the temporary copy
+        # no longer takes up that space.
+        FileUtils.rm_f(temp_path)
+        File.write(path, contents)
+      end
+    end
+    private_class_method :replace_via_temporary_file
+
+    # Space errors such as `ENOSPC` must propagate: a direct write would then
+    # truncate the file and fail, which is exactly the loss being avoided.
+    def self.write_temporary_file(temp_path, contents)
+      File.write(temp_path, contents)
+      true
+    rescue Errno::EACCES, Errno::EPERM
+      false
+    end
+    private_class_method :write_temporary_file
   end
 end

data/lib/rubocop/version.rb

@@ -3,12 +3,15 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.71.1'
+    STRING = '1.92.1'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'analyzing as Ruby %<target_ruby_version>s, ' \
-          'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
+          'running on %<ruby_engine>s %<ruby_version>s)' \
+          '%<rubydex_indicator>s%<server_mode>s [%<ruby_platform>s]'
+
+    MINIMUM_PARSABLE_PRISM_VERSION = 3.3
 
     CANONICAL_FEATURE_NAMES = {
       'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
@@ -20,12 +23,16 @@ module RuboCop
 
     # NOTE: Marked as private but used by gems like standard.
     # @api private
+    # rubocop:disable-next Metrics/MethodLength
     def self.version(debug: false, env: nil)
       if debug
-        verbose_version = format(MSG, version: STRING, parser_version: parser_version,
+        target_ruby_version = target_ruby_version(env)
+        verbose_version = format(MSG, version: STRING,
+                                      parser_version: parser_version(target_ruby_version),
                                       rubocop_ast_version: RuboCop::AST::Version::STRING,
-                                      target_ruby_version: target_ruby_version(env),
+                                      target_ruby_version: target_ruby_version,
                                       ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                                      rubydex_indicator: rubydex_indicator(env),
                                       server_mode: server_mode,
                                       ruby_platform: RUBY_PLATFORM)
         return verbose_version unless env
@@ -48,24 +55,37 @@ module RuboCop
     end
 
     # @api private
-    def self.parser_version
-      config_path = ConfigFinder.find_config_path(Dir.pwd)
+    def self.parser_version(target_ruby_version)
+      config_path = ConfigFinder.find_config_path(PathUtil.pwd)
       yaml = Util.silence_warnings do
         ConfigLoader.load_yaml_configuration(config_path)
       end
+      parser_engine = yaml.dig('AllCops', 'ParserEngine')
+      parser_engine_text = ", #{parser_engine}" if parser_engine
 
-      if yaml.dig('AllCops', 'ParserEngine') == 'parser_prism'
-        require 'prism'
-        "Prism #{Prism::VERSION}"
+      if target_ruby_version >= MINIMUM_PARSABLE_PRISM_VERSION
+        "Parser #{Parser::VERSION}, Prism #{Prism::VERSION}#{parser_engine_text}"
       else
         "Parser #{Parser::VERSION}"
       end
     end
 
     # @api private
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.extension_versions(env)
+      plugins = config_for_pwd(env).loaded_plugins
+      plugin_versions = plugins.filter_map do |plugin|
+        next if Plugin::BUILTIN_INTERNAL_PLUGINS.key?(plugin.about.name)
+        next unless (plugin_name = plugin.about.name)
+
+        "  - #{plugin_name} #{plugin.about.version}"
+      end
+
+      # TODO: It needs to be maintained for a while to ensure compatibility with extensions that
+      # don't support plugins. It should be removed in future once the old style becomes obsolete.
       features = config_for_pwd(env).loaded_features.sort
-      features.filter_map do |loaded_feature|
+      features -= plugins.map { |plugin| plugin.about.name }
+      feature_versions = features.filter_map do |loaded_feature|
         next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
 
         # Get the expected name of the folder containing the extension code.
@@ -84,6 +104,8 @@ module RuboCop
 
         "  - #{loaded_feature} #{feature_version}"
       end
+
+      plugin_versions + feature_versions
     end
 
     # @api private
@@ -130,6 +152,22 @@ module RuboCop
       STRING.match('\d+\.\d+').to_s
     end
 
+    # @api private
+    def self.rubydex_indicator(env)
+      env && rubydex_enabled?(env) && ProjectIndexLoader.available? ? ' +Rubydex' : ''
+    end
+
+    # @api private
+    def self.rubydex_enabled?(env)
+      config_for_pwd(env).for_all_cops['UseProjectIndex']
+    rescue StandardError
+      # Keep `rubocop -V` usable when the config cannot be loaded (broken YAML,
+      # missing `inherit_from` target, etc). It is the first command users run to
+      # diagnose a broken setup, so the indicator just hides rather than letting
+      # the version banner crash.
+      false
+    end
+
     # @api private
     def self.server_mode
       RuboCop.const_defined?(:Server) && Server.running? ? ' +server' : ''