rubocop 1.65.1 → 1.75.6

data/lib/rubocop/formatter/junit_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rexml/document'
-
 #
 # This code is based on https://github.com/mikian/rubocop-junit-formatter.
 #
@@ -15,13 +13,18 @@ module RuboCop
   module Formatter
     # This formatter formats the report data in JUnit format.
     class JUnitFormatter < BaseFormatter
+      ESCAPE_MAP = {
+        '"' => '&quot;',
+        "'" => '&apos;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '&' => '&amp;'
+      }.freeze
+
       def initialize(output, options = {})
         super
 
-        @document = REXML::Document.new.tap { |document| document << REXML::XMLDecl.new }
-        testsuites = REXML::Element.new('testsuites', @document)
-        testsuite = REXML::Element.new('testsuite', testsuites)
-        @testsuite = testsuite.tap { |element| element.add_attributes('name' => 'rubocop') }
+        @test_case_elements = []
 
         reset_count
       end
@@ -44,6 +47,33 @@ module RuboCop
         end
       end
 
+      # rubocop:disable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
+      def finished(_inspected_files)
+        output.puts %(<?xml version='1.0'?>)
+        output.puts %(<testsuites>)
+        output.puts %(  <testsuite name='rubocop' tests='#{@inspected_file_count}' failures='#{@offense_count}'>)
+
+        @test_case_elements.each do |test_case_element|
+          if test_case_element.failures.empty?
+            output.puts %(    <testcase classname='#{xml_escape test_case_element.classname}' name='#{test_case_element.name}'/>)
+          else
+            output.puts %(    <testcase classname='#{xml_escape test_case_element.classname}' name='#{test_case_element.name}'>)
+            test_case_element.failures.each do |failure_element|
+              output.puts %(      <failure type='#{failure_element.type}' message='#{xml_escape failure_element.message}'>)
+              output.puts %(        #{xml_escape failure_element.text})
+              output.puts %(      </failure>)
+            end
+            output.puts %(    </testcase>)
+          end
+        end
+
+        output.puts %(  </testsuite>)
+        output.puts %(</testsuites>)
+      end
+      # rubocop:enable Layout/LineLength,Metrics/AbcSize,Metrics/MethodLength
+
+      private
+
       def relevant_for_output?(options, target_offenses)
         !options[:display_only_failed] || target_offenses.any?
       end
@@ -53,11 +83,11 @@ module RuboCop
       end
 
       def add_testcase_element_to_testsuite_element(file, target_offenses, cop)
-        REXML::Element.new('testcase', @testsuite).tap do |testcase|
-          testcase.attributes['classname'] = classname_attribute_value(file)
-          testcase.attributes['name'] = cop.cop_name
-
-          add_failure_to(testcase, target_offenses, cop.cop_name)
+        @test_case_elements << TestCaseElement.new(
+          classname: classname_attribute_value(file),
+          name: cop.cop_name
+        ).tap do |test_case_element|
+          add_failure_to(test_case_element, target_offenses, cop.cop_name)
         end
       end
 
@@ -68,13 +98,6 @@ module RuboCop
         @classname_attribute_value_cache[file]
       end
 
-      def finished(_inspected_files)
-        @testsuite.add_attributes('tests' => @inspected_file_count, 'failures' => @offense_count)
-        @document.write(output, 2)
-      end
-
-      private
-
       def reset_count
         @inspected_file_count = 0
         @offense_count = 0
@@ -84,11 +107,35 @@ module RuboCop
         # One failure per offense. Zero failures is a passing test case,
         # for most surefire/nUnit parsers.
         offenses.each do |offense|
-          REXML::Element.new('failure', testcase).tap do |failure|
-            failure.attributes['type'] = cop_name
-            failure.attributes['message'] = offense.message
-            failure.add_text(offense.location.to_s)
-          end
+          testcase.failures << FailureElement.new(
+            type: cop_name,
+            message: offense.message,
+            text: offense.location.to_s
+          )
+        end
+      end
+
+      def xml_escape(string)
+        string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+      end
+
+      class TestCaseElement # :nodoc:
+        attr_reader :classname, :name, :failures
+
+        def initialize(classname:, name:)
+          @classname = classname
+          @name = name
+          @failures = []
+        end
+      end
+
+      class FailureElement # :nodoc:
+        attr_reader :type, :message, :text
+
+        def initialize(type:, message:, text:)
+          @type = type
+          @message = message
+          @text = text
         end
       end
     end

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -58,7 +58,7 @@ module RuboCop
         return pacdots(@total_files) unless @total_files > cols
         return pacdots(cols) unless (@total_files / cols).eql?(@repetitions)
 
-        pacdots((@total_files - (cols * @repetitions)))
+        pacdots(@total_files - (cols * @repetitions))
       end
 
       def pacdots(number)

data/lib/rubocop/lockfile.rb

@@ -16,7 +16,7 @@ module RuboCop
     # @param [String, Pathname, nil] lockfile_path
     def initialize(lockfile_path = nil)
       lockfile_path ||= begin
-        ::Bundler.default_lockfile if bundler_lock_parser_defined?
+        ::Bundler.default_lockfile if use_bundler_lock_parser?
       rescue ::Bundler::GemfileNotFound
         nil # We might not be a folder with a Gemfile, but that's okay.
       end
@@ -72,7 +72,7 @@ module RuboCop
     def parser
       return @parser if defined?(@parser)
 
-      @parser = if @lockfile_path && File.exist?(@lockfile_path) && bundler_lock_parser_defined?
+      @parser = if @lockfile_path && File.exist?(@lockfile_path) && use_bundler_lock_parser?
                   begin
                     lockfile = ::Bundler.read_file(@lockfile_path)
                     ::Bundler::LockfileParser.new(lockfile) if lockfile
@@ -82,8 +82,10 @@ module RuboCop
                 end
     end
 
-    def bundler_lock_parser_defined?
-      Object.const_defined?(:Bundler) && Bundler.const_defined?(:LockfileParser)
+    def use_bundler_lock_parser?
+      return false unless Object.const_defined?(:Bundler)
+
+      Bundler.const_defined?(:LockfileParser) && Bundler::VERSION >= '2.0'
     end
   end
 end

data/lib/rubocop/lsp/diagnostic.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Diagnostic for Language Server Protocol of RuboCop.
+    # @api private
+    class Diagnostic
+      def initialize(document_encoding, offense, uri, cop_class)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def to_lsp_diagnostic(config)
+        highlighted = @offense.highlighted_area
+
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: message,
+          source: 'RuboCop',
+          code: @offense.cop_name,
+          code_description: code_description(config),
+          severity: severity,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.begin_pos
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.end_pos
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def message
+        message = @offense.message
+        message += "\n\nThis offense is not autocorrectable.\n" unless correctable?
+        message
+      end
+
+      def severity
+        Severity.find_by(@offense.severity.name)
+      end
+
+      def code_description(config)
+        return unless @cop_class
+        return unless (doc_url = @cop_class.documentation_url(config))
+
+        LanguageServer::Protocol::Interface::CodeDescription.new(href: doc_url)
+      end
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def autocorrect_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Autocorrect #{@offense.cop_name}",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: correctable? ? offense_replacements : []
+              )
+            ]
+          ),
+          is_preferred: true
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def offense_replacements
+        @offense.corrector.as_replacements.map do |range, replacement|
+          LanguageServer::Protocol::Interface::TextEdit.new(
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(
+                line: range.line - 1,
+                character: range.column
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: range.last_line - 1,
+                character: range.last_column
+              )
+            ),
+            new_text: replacement
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def disable_line_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Disable #{@offense.cop_name} for this line",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: line_disable_comment
+              )
+            ]
+          )
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      def line_disable_comment
+        new_text = if @offense.source_line.include?(' # rubocop:disable ')
+                     ",#{@offense.cop_name}"
+                   else
+                     " # rubocop:disable #{@offense.cop_name}"
+                   end
+
+        eol = LanguageServer::Protocol::Interface::Position.new(
+          line: @offense.line - 1,
+          character: length_of_line(@offense.source_line)
+        )
+
+        # TODO: fails for multiline strings - may be preferable to use block
+        # comments to disable some offenses
+        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
+          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
+          new_text: new_text
+        )
+
+        [inline_comment]
+      end
+
+      def length_of_line(line)
+        if @document_encoding == Encoding::UTF_16LE
+          line_length = 0
+          line.codepoints.each do |codepoint|
+            line_length += 1
+            line_length += 1 if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+          end
+          line_length
+        else
+          line.length
+        end
+      end
+
+      def correctable?
+        !@offense.corrector.nil?
+      end
+
+      def ensure_uri_scheme(uri)
+        uri = URI.parse(uri)
+        uri.scheme = 'file' if uri.scheme.nil?
+        uri
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/logger.rb

@@ -14,8 +14,8 @@ module RuboCop
     # Log for Language Server Protocol of RuboCop.
     # @api private
     class Logger
-      def self.log(message)
-        warn("[server] #{message}")
+      def self.log(message, prefix: '[server]')
+        warn("#{prefix} #{message}")
       end
     end
   end

data/lib/rubocop/lsp/routes.rb

@@ -16,6 +16,11 @@ module RuboCop
     # Routes for Language Server Protocol of RuboCop.
     # @api private
     class Routes
+      CONFIGURATION_FILE_PATTERNS = [
+        RuboCop::ConfigFinder::DOTFILE,
+        RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+      ].freeze
+
       def self.handle(name, &block)
         define_method(:"handle_#{name}", &block)
       end
@@ -96,7 +101,7 @@ module RuboCop
 
       handle 'workspace/didChangeWatchedFiles' do |request|
         changed = request[:params][:changes].any? do |change|
-          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
         end
 
         if changed
@@ -204,14 +209,12 @@ module RuboCop
 
       def diagnostic(file_uri, text)
         @text_cache[file_uri] = text
-        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
-        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
 
         {
           method: 'textDocument/publishDiagnostics',
           params: {
             uri: file_uri,
-            diagnostics: diagnostics
+            diagnostics: @server.offenses(remove_file_protocol_from(file_uri), text)
           }
         }
       end
@@ -219,25 +222,6 @@ module RuboCop
       def remove_file_protocol_from(uri)
         uri.delete_prefix('file://')
       end
-
-      def to_diagnostic(offense)
-        code = offense[:cop_name]
-        message = offense[:message]
-        loc = offense[:location]
-        rubocop_severity = offense[:severity]
-        severity = Severity.find_by(rubocop_severity)
-
-        {
-          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
-        }
-      end
-
-      def to_range(location)
-        {
-          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column], line: location[:last_line] - 1 }
-        }
-      end
     end
   end
 end

data/lib/rubocop/lsp/runtime.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'diagnostic'
+require_relative 'stdin_runner'
+
 #
 # This code is based on https://github.com/standardrb/standard.
 #
@@ -17,59 +20,40 @@ module RuboCop
       attr_writer :safe_autocorrect, :lint_mode, :layout_mode
 
       def initialize(config_store)
-        @config_store = config_store
-        @logged_paths = []
+        RuboCop::LSP.enable
+
+        @runner = RuboCop::Lsp::StdinRunner.new(config_store)
+        @cop_registry = RuboCop::Cop::Registry.global.to_h
+
         @safe_autocorrect = true
         @lint_mode = false
         @layout_mode = false
       end
 
-      # This abuses the `--stdin` option of rubocop and reads the formatted text
-      # from the `options[:stdin]` that rubocop mutates. This depends on
-      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
-      # or reassign that options object. Risky business!
-      #
-      # Reassigning `options[:stdin]` is done here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
-      # Printing `options[:stdin]`
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
-      # Setting `parallel: true` would break this here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
-      def format(path, text, command:)
+      def format(path, text, command:, prism_result: nil)
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
                            else
                              @safe_autocorrect
                            end
 
-        formatting_options = {
-          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: safe_autocorrect
-        }
+        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
         formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        redirect_stdout { run_rubocop(formatting_options, path) }
-
-        formatting_options[:stdin]
+        @runner.run(path, text, formatting_options, prism_result: prism_result)
+        @runner.formatted_source
       end
 
-      def offenses(path, text)
-        diagnostic_options = {
-          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
-        }
+      def offenses(path, text, document_encoding = nil, prism_result: nil)
+        diagnostic_options = {}
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
-        results = JSON.parse(json, symbolize_names: true)
-
-        if results[:files].empty?
-          unless @logged_paths.include?(path)
-            Logger.log "Ignoring file, per configuration: #{path}"
-            @logged_paths << path
-          end
-          return []
+        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        @runner.offenses.map do |offense|
+          Diagnostic.new(
+            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
+          ).to_lsp_diagnostic(@runner.config_for_working_directory)
         end
-
-        results.dig(:files, 0, :offenses)
       end
 
       private
@@ -80,20 +64,6 @@ module RuboCop
         only_options << 'Layout' if @layout_mode
         only_options
       end
-
-      def redirect_stdout(&block)
-        stdout = StringIO.new
-
-        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
-
-        stdout.string
-      end
-
-      def run_rubocop(options, path)
-        runner = RuboCop::Runner.new(options, @config_store)
-
-        runner.run([path])
-      end
     end
   end
 end

data/lib/rubocop/lsp/server.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'language_server-protocol'
-require_relative '../lsp'
 require_relative 'logger'
 require_relative 'routes'
 require_relative 'runtime'
@@ -23,8 +22,6 @@ module RuboCop
       def initialize(config_store)
         $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
 
-        RuboCop::LSP.enable
-
         @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
         @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
         @runtime = RuboCop::LSP::Runtime.new(config_store)

data/lib/rubocop/lsp/stdin_runner.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Originally lifted from:
+    # https://github.com/Shopify/ruby-lsp/blob/8d4c17efce4e8ecc8e7c557ab2981db6b22c0b6d/lib/ruby_lsp/requests/support/rubocop_runner.rb#L20
+    # @api private
+    class StdinRunner < RuboCop::Runner
+      class ConfigurationError < StandardError; end
+
+      attr_reader :offenses, :config_for_working_directory
+
+      DEFAULT_RUBOCOP_OPTIONS = {
+        stderr: true,
+        force_exclusion: true,
+        formatters: ['RuboCop::Formatter::BaseFormatter'],
+        raise_cop_error: true,
+        todo_file: nil,
+        todo_ignore_files: []
+      }.freeze
+
+      def initialize(config_store)
+        @options = {}
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        @config_for_working_directory = config_store.for_pwd
+
+        super(@options, config_store)
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def run(path, contents, options, prism_result: nil)
+        @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
+        @options[:stdin] = contents
+
+        @prism_result = prism_result
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        super([path])
+
+        raise Interrupt if aborting?
+      rescue RuboCop::Runner::InfiniteCorrectionLoop => e
+        if defined?(::RubyLsp::Requests::Formatting::Error)
+          raise ::RubyLsp::Requests::Formatting::Error, e.message
+        end
+
+        raise e
+      rescue RuboCop::ValidationError => e
+        raise ConfigurationError, e.message
+      rescue StandardError => e
+        if defined?(::RubyLsp::Requests::Formatting::Error)
+          raise ::RubyLsp::Requests::Support::InternalRuboCopError, e
+        end
+
+        raise e
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def formatted_source
+        @options[:stdin]
+      end
+
+      private
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+    end
+  end
+end

data/lib/rubocop/magic_comment.rb

@@ -80,13 +80,13 @@ module RuboCop
 
     # Expose the `frozen_string_literal` value coerced to a boolean if possible.
     #
-    # @return [Boolean] if value is `true` or `false`
+    # @return [Boolean] if value is `true` or `false` in any case
     # @return [nil] if frozen_string_literal comment isn't found
     # @return [String] if comment is found but isn't true or false
     def frozen_string_literal
       return unless (setting = extract_frozen_string_literal)
 
-      case setting
+      case setting.downcase
       when 'true'  then true
       when 'false' then false
       else
@@ -193,6 +193,10 @@ module RuboCop
       SEPARATOR = ';'
       OPERATOR  = ':'
 
+      def new_frozen_string_literal(value)
+        "# -*- frozen_string_literal: #{value} -*-"
+      end
+
       private
 
       def extract_frozen_string_literal
@@ -275,6 +279,10 @@ module RuboCop
         end
       end
 
+      def new_frozen_string_literal(value)
+        "# frozen_string_literal: #{value}"
+      end
+
       private
 
       # Extract `frozen_string_literal`.
@@ -283,7 +291,7 @@ module RuboCop
       # is the only text in the comment.
       #
       # Case-insensitive and dashes/underscores are acceptable.
-      # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138
+      # @see https://github.com/ruby/ruby/blob/78b95b49f8/parse.y#L7134-L7138
       def extract_frozen_string_literal
         extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
       end