rubocop 1.53.0 → 1.90.0

data/lib/rubocop/lsp/routes.rb

@@ -12,12 +12,21 @@ require_relative 'severity'
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # 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
+
+      # Commands handled by `workspace/executeCommand`. Advertised to the client
+      # via `executeCommandProvider` so it knows which commands it can invoke.
+      EXECUTE_COMMANDS = %w[rubocop.formatAutocorrects rubocop.formatAutocorrectsAll].freeze
+
       def self.handle(name, &block)
-        define_method("handle_#{name}", &block)
+        define_method(:"handle_#{name}", &block)
       end
 
       private_class_method :handle
@@ -36,14 +45,23 @@ module RuboCop
       end
 
       handle 'initialize' do |request|
+        initialization_options = extract_initialization_options_from(request)
+
+        @server.configure(initialization_options)
+
         @server.write(
           id: request[:id],
           result: LanguageServer::Protocol::Interface::InitializeResult.new(
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               document_formatting_provider: true,
-              diagnostic_provider: true,
+              code_action_provider: LanguageServer::Protocol::Interface::CodeActionOptions.new(
+                code_action_kinds: [LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX]
+              ),
+              execute_command_provider: LanguageServer::Protocol::Interface::ExecuteCommandOptions.new(
+                commands: EXECUTE_COMMANDS
+              ),
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
                 open_close: true
               )
             )
@@ -53,8 +71,16 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
-
-        Logger.log("RuboCop #{version} language server initialized, PID #{Process.pid}")
+        # Only one JIT can be enabled at the same time, since YJIT and ZJIT are mutually exclusive.
+        jit = if Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled?
+                '+YJIT'
+              elsif Object.const_defined?('RubyVM::ZJIT') && RubyVM::ZJIT.enabled?
+                '+ZJIT'
+              else
+                ''
+              end
+
+        Logger.log("RuboCop #{version} language server#{jit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|
@@ -65,15 +91,14 @@ module RuboCop
         end
       end
 
-      handle 'textDocument/diagnostic' do |request|
-        doc = request[:params][:textDocument]
-        result = diagnostic(doc[:uri], doc[:text])
-        @server.write(result)
-      end
-
       handle 'textDocument/didChange' do |request|
         params = request[:params]
-        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        file_uri = params[:textDocument][:uri]
+        text = @text_cache[file_uri]
+        params[:contentChanges].each do |content|
+          text = change_text(text, content[:text], content[:range])
+        end
+        result = diagnostic(file_uri, text)
         @server.write(result)
       end
 
@@ -92,38 +117,46 @@ module RuboCop
         @server.write(id: request[:id], result: format_file(uri))
       end
 
+      handle 'textDocument/codeAction' do |request|
+        @server.write(id: request[:id], result: code_actions_for(request[:params]))
+      end
+
       handle 'workspace/didChangeConfiguration' do |_request|
         Logger.log('Ignoring workspace/didChangeConfiguration')
       end
 
       handle 'workspace/didChangeWatchedFiles' do |request|
-        changed = request[:params][:changes].any? do |change|
-          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+        config_changed = request[:params][:changes].any? do |change|
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
         end
 
-        if changed
+        if config_changed
           Logger.log('Configuration file changed; restart required')
           @server.stop
+        else
+          # A watched source file changed on disk, so the project index may be
+          # stale; drop it so the next diagnostics run rebuilds it.
+          @server.reset_project_index
         end
       end
 
       handle 'workspace/executeCommand' do |request|
-        if request[:params][:command] == 'rubocop.formatAutocorrects'
-          uri = request[:params][:arguments][0][:uri]
-          @server.write(
-            id: request[:id],
-            method: 'workspace/applyEdit',
-            params: {
-              label: 'Format with RuboCop autocorrects',
-              edit: {
-                changes: {
-                  uri => format_file(uri)
-                }
-              }
-            }
-          )
+        case (command = request[:params][:command])
+        when 'rubocop.formatAutocorrects'
+          label = 'Format with RuboCop autocorrects'
+        when 'rubocop.formatAutocorrectsAll'
+          label = 'Format all with RuboCop autocorrects'
         else
-          handle_unsupported_method(request, request[:params][:command])
+          handle_unsupported_method(request, command)
+          return
+        end
+
+        # Clients such as Eglot can invoke a command without arguments, so respond with
+        # an error instead of letting the server crash on a missing URI.
+        if (uri = document_uri_from(request))
+          write_formatting_edits(request, uri: uri, command: command, label: label)
+        else
+          write_invalid_arguments_error(request, command)
         end
       end
 
@@ -132,7 +165,9 @@ module RuboCop
       end
 
       handle 'textDocument/didSave' do |_request|
-        # Nothing to do
+        # The buffer's contents are now on disk, so the project index may be
+        # stale; drop it so the next diagnostics run rebuilds it.
+        @server.reset_project_index
       end
 
       handle '$/cancelRequest' do |_request|
@@ -162,61 +197,133 @@ module RuboCop
 
       private
 
-      def format_file(file_uri)
+      def extract_initialization_options_from(request)
+        safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+
+        {
+          safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
+          lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+        }
+      end
+
+      def document_uri_from(request)
+        argument = request.dig(:params, :arguments, 0)
+
+        argument[:uri] if argument.is_a?(Hash)
+      end
+
+      def write_formatting_edits(request, uri:, command:, label:)
+        formatted = nil
+
+        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
+        # so the user's intention for autocorrection is respected.
+        LSP.disable { formatted = format_file(uri, command: command) }
+
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => formatted
+              }
+            }
+          }
+        )
+      end
+
+      def write_invalid_arguments_error(request, command)
+        message = "Missing document URI in arguments for #{command}"
+
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INVALID_PARAMS,
+            message: message
+          )
+        )
+
+        Logger.log(message)
+      end
+
+      def format_file(file_uri, command: nil)
         unless (text = @text_cache[file_uri])
           Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
 
           return []
         end
 
-        new_text = @server.format(remove_file_protocol_from(file_uri), text)
+        new_text = @server.format(convert_file_uri_to_path(file_uri), text, command: command)
 
         return [] if new_text == text
 
-        [
+        [{
           newText: new_text,
           range: {
             start: { line: 0, character: 0 },
             end: { line: text.count("\n") + 1, character: 0 }
           }
-        ]
+        }]
+      end
+
+      # Returns the quickfix code actions for a `textDocument/codeAction` request.
+      #
+      # RuboCop attaches each offense's autocorrect and disable-line actions to
+      # the diagnostic it publishes, under the diagnostic's `data` (see
+      # `Diagnostic#to_lsp_diagnostic`).  The LSP spec preserves that `data`
+      # between `textDocument/publishDiagnostics` and `textDocument/codeAction`,
+      # so the client hands the diagnostics back in the request's context and we
+      # can surface their actions without re-analyzing the file.  This makes the
+      # actions available to clients that request code actions rather than
+      # reading them off the diagnostic (Eglot, Helix, Flycheck, ...).
+      def code_actions_for(params)
+        diagnostics = params.dig(:context, :diagnostics) || []
+        only = params.dig(:context, :only)
+
+        diagnostics.flat_map { |diagnostic| diagnostic.dig(:data, :code_actions) || [] }
+                   .select { |action| only.nil? || only.include?(action[:kind]) }
       end
 
       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(convert_file_uri_to_path(file_uri), text)
           }
         }
       end
 
-      def remove_file_protocol_from(uri)
-        uri.delete_prefix('file://')
-      end
+      def change_text(orig_text, text, range)
+        return text unless range
 
-      def to_diagnostic(offense)
-        code = offense[:cop_name]
-        message = offense[:message]
-        loc = offense[:location]
-        rubocop_severity = offense[:severity]
-        severity = Severity.find_by(rubocop_severity)
+        start_pos = text_pos(orig_text, range[:start])
+        end_pos = text_pos(orig_text, range[:end])
+        text_bin = orig_text.b
+        text_bin[start_pos...end_pos] = text.b
+        text_bin.force_encoding(orig_text.encoding)
+      end
 
-        {
-          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
-        }
+      def text_pos(text, range)
+        line = range[:line]
+        char = range[:character]
+        pos = 0
+        text.each_line.with_index do |l, i|
+          if i == line
+            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
+            return pos
+          end
+          pos += l.bytesize
+        end
+        pos
       end
 
-      def to_range(location)
-        {
-          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column] - 1, line: location[:last_line] - 1 }
-        }
+      def convert_file_uri_to_path(uri)
+        URI.decode_www_form_component(uri.delete_prefix('file://'))
       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.
 #
@@ -10,69 +13,69 @@
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # Runtime for Language Server Protocol of RuboCop.
     # @api private
     class Runtime
+      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)
+
+        @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)
-        formatting_options = {
-          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: true
-        }
+      def format(path, text, command:, prism_result: nil)
+        safe_autocorrect = if command
+                             command == 'rubocop.formatAutocorrects'
+                           else
+                             @safe_autocorrect
+                           end
 
-        redirect_stdout { run_rubocop(formatting_options, path) }
+        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
+        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        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 reset_project_index
+        @runner.reset_project_index
+      end
 
-        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
-        results = JSON.parse(json, symbolize_names: true)
+      def offenses(path, text, document_encoding = nil, prism_result: nil)
+        diagnostic_options = {}
+        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        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)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
+        @runner.offenses.map do |offense|
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
         end
-
-        results.dig(:files, 0, :offenses)
       end
 
       private
 
-      def redirect_stdout(&block)
-        stdout = StringIO.new
-
-        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
-
-        stdout.string
+      def build_diagnostic(offense, path, document_encoding, processed_source, config)
+        Diagnostic.new(
+          document_encoding,
+          offense,
+          path,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
+          processed_source
+        ).to_lsp_diagnostic(config)
       end
 
-      def run_rubocop(options, path)
-        runner = RuboCop::Runner.new(options, @config_store)
-
-        runner.run([path])
+      def config_only_options
+        only_options = []
+        only_options << 'Lint' if @lint_mode
+        only_options << 'Layout' if @layout_mode
+        only_options
       end
     end
   end

data/lib/rubocop/lsp/server.rb

@@ -15,14 +15,16 @@ require_relative 'runtime'
 # https://github.com/standardrb/standard/blob/main/LICENSE.txt
 #
 module RuboCop
-  module Lsp
+  module LSP
     # Language Server Protocol of RuboCop.
     # @api private
     class Server
       def initialize(config_store)
+        $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
+
         @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
         @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
-        @runtime = RuboCop::Lsp::Runtime.new(config_store)
+        @runtime = RuboCop::LSP::Runtime.new(config_store)
         @routes = Routes.new(self)
       end
 
@@ -36,8 +38,8 @@ module RuboCop
             @routes.handle_unsupported_method(request)
           end
         rescue StandardError => e
-          log("Error #{e.class} #{e.message[0..100]}")
-          log(e.backtrace.inspect)
+          Logger.log("Error #{e.class} #{e.message[0..100]}")
+          Logger.log(e.backtrace.inspect)
         end
       end
 
@@ -45,14 +47,24 @@ module RuboCop
         @writer.write(response)
       end
 
-      def format(path, text)
-        @runtime.format(path, text)
+      def format(path, text, command:)
+        @runtime.format(path, text, command: command)
       end
 
       def offenses(path, text)
         @runtime.offenses(path, text)
       end
 
+      def configure(options)
+        @runtime.safe_autocorrect = options[:safe_autocorrect]
+        @runtime.lint_mode = options[:lint_mode]
+        @runtime.layout_mode = options[:layout_mode]
+      end
+
+      def reset_project_index
+        @runtime.reset_project_index
+      end
+
       def stop(&block)
         at_exit(&block) if block
         exit

data/lib/rubocop/lsp/severity.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  module Lsp
+  module LSP
     # Severity for Language Server Protocol of RuboCop.
     # @api private
     class Severity

data/lib/rubocop/lsp/stdin_runner.rb

@@ -0,0 +1,96 @@
+# 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, :processed_source
+
+      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
+
+      def run(path, contents, options, prism_result: nil)
+        @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
+        @options[:stdin] = contents
+
+        @prism_result = prism_result
+        @processed_source = nil
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        super([path])
+
+        raise Interrupt if aborting?
+      end
+
+      def formatted_source
+        @options[:stdin]
+      end
+
+      # Drop the cached project index so the next run rebuilds it. Called when a
+      # file is saved or a watched file changes, i.e. when the on-disk state the
+      # index is derived from may have changed.
+      def reset_project_index
+        @project_index = nil
+        @project_index_built = false
+      end
+
+      private
+
+      # The project index is built from files on disk, not from the in-memory
+      # buffer, so it does not change while the user is typing. Build it once and
+      # reuse it across runs instead of re-walking and re-indexing the whole
+      # project on every request; `reset_project_index` drops the cache when the
+      # on-disk state changes.
+      def build_project_index(target_files)
+        return if @project_index_built
+
+        super
+        @project_index_built = true
+      end
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+
+      def do_inspection_loop(file)
+        source, offenses = super
+        @processed_source = source
+        [source, offenses]
+      end
+    end
+  end
+end

data/lib/rubocop/lsp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The RuboCop's built-in LSP module.
+  module LSP
+    module_function
+
+    # Returns true when LSP is enabled, false when disabled.
+    #
+    # @return [Boolean]
+    def enabled?
+      @enabled ||= false
+    end
+
+    # Enable LSP.
+    #
+    # @return [void]
+    def enable
+      @enabled = true
+    end
+
+    # Disable LSP.
+    #
+    # @return [void]
+    def disable(&block)
+      if block
+        original = @enabled
+        @enabled = false
+        yield
+        @enabled = original
+      else
+        @enabled = false
+      end
+    end
+  end
+end