ruby-lsp 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f263a066e68d798f4808df8b595c06345061623ab706b9f3ed8ffa0573d8ea47
-  data.tar.gz: 46eeeb5c2938d46e24a2d0a01e5772a49c27db9f3ab4a03ad840a1059e5161c7
+  metadata.gz: 6e66f508823e7d8e663c90e9990ae13bf26c3480d4ce9d7d43db14185518064d
+  data.tar.gz: 70cfc0be15d1ad988d66a641191fa64679109ae1f6be56afdc01ded665b0a439
 SHA512:
-  metadata.gz: e9c78db0a6b5262fc618fd1e7d4832f7a74d76130a29767a339897a06b5ff6fbc2799b328127f596d327d0adbff074e17ebacc5b88a7af97dff640220466ce1b
-  data.tar.gz: 3ddc525a0ad7220537db5ee0a94a208182821d0f5c321f5ab3babafba97d84ee196b392cedc7c925be20df801244c519d425822941e791a73563224f0b00b6b6
+  metadata.gz: a2f71a448863bf25e229032cb06d3ae7e7ebf1ef50b414e6486bd902ec7f100dad1ae4cb7160ef9c5fa8069f3ff0bcbb3da29d9c16a49f2e347f8d3d8797049a
+  data.tar.gz: 4cd747fb8505531a1ab0f1c28c8b3a09a134d544c1834b2f821c220bce2e3b6efce325b73326e23d92891a27ae5ae3cd9a79e9bbfdfa1b45c8f6e490b74d5c9a

data/CHANGELOG.md

@@ -6,32 +6,11 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
-## [0.2.3]
-
-- Resolve generic source URIs for jump to gem source (https://github.com/Shopify/ruby-lsp/pull/237)
-
-## [0.2.2]
-
-- Support document links (https://github.com/Shopify/ruby-lsp/pull/195)
-- Avoid returning on request blocks (https://github.com/Shopify/ruby-lsp/pull/232)
-- Better specify gemspec files (https://github.com/Shopify/ruby-lsp/pull/233)
-- Include Kernel instance methods as special methods for semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/231)
-- Fix call processing when message is a :call symbol literal (https://github.com/Shopify/ruby-lsp/pull/236)
-- Alert users about non auto-correctable diagnostics (https://github.com/Shopify/ruby-lsp/pull/230)
-- Let clients pull diagnostics instead of pushing on edits (https://github.com/Shopify/ruby-lsp/pull/242)
-
-## [0.2.1]
-
-- Implement the exit lifecycle request (https://github.com/Shopify/ruby-lsp/pull/198)
-- Remove the Sorbet runtime from the gem's default load path (https://github.com/Shopify/ruby-lsp/pull/214)
-- Return nil if the document is already formatted (https://github.com/Shopify/ruby-lsp/pull/216)
-- Handle nameless keyword rest parameters in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/222)
-- Display a warning on invalid RuboCop configuration (https://github.com/Shopify/ruby-lsp/pull/226)
-- Centralize request handling logic in server.rb (https://github.com/Shopify/ruby-lsp/pull/221)
-- Fix folding ranges for chained invocations involving an FCall (https://github.com/Shopify/ruby-lsp/pull/223)
-- Fix handling of argument fowarding in semantic highlighting (https://github.com/Shopify/ruby-lsp/pull/228)
-- Recover from initial syntax errors when opening documents (https://github.com/Shopify/ruby-lsp/pull/224)
-- Highlight occurrences and definitions in document highlight (https://github.com/Shopify/ruby-lsp/pull/187)
+## [0.3.0]
+- Add on type formatting completions (https://github.com/Shopify/ruby-lsp/pull/253)
+- Upgrade syntax_tree requirement to >= 3.4 (https://github.com/Shopify/ruby-lsp/pull/254)
+- Show error message when there's a InfiniteCorrectionLoop exception (https://github.com/Shopify/ruby-lsp/pull/252)
+- Add request cancellation (https://github.com/Shopify/ruby-lsp/pull/243)
 
 ## [0.2.0]
 

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/lib/ruby_lsp/handler.rb

@@ -3,7 +3,7 @@
 
 require "ruby_lsp/requests"
 require "ruby_lsp/store"
-require "benchmark"
+require "ruby_lsp/queue"
 
 module RubyLsp
   Interface = LanguageServer::Protocol::Interface
@@ -14,11 +14,35 @@ module RubyLsp
     extend T::Sig
     VOID = T.let(Object.new.freeze, Object)
 
-    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
-    def self.start(&blk)
-      handler = new
-      handler.instance_exec(&blk)
-      handler.start
+    class RequestHandler < T::Struct
+      extend T::Sig
+
+      const :action, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+      const :parallel, T::Boolean
+      prop :error_handler,
+        T.nilable(T.proc.params(error: StandardError, request: T::Hash[Symbol, T.untyped]).void)
+
+      # A proc that runs in case a request has errored. Receives the error and the original request as arguments. Useful
+      # for displaying window messages on errors
+      sig do
+        params(
+          block: T.proc.bind(Handler).params(error: StandardError, request: T::Hash[Symbol, T.untyped]).void
+        ).void
+      end
+      def on_error(&block)
+        self.error_handler = block
+      end
+    end
+
+    class << self
+      extend T::Sig
+
+      sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
+      def start(&blk)
+        handler = new
+        handler.instance_exec(&blk)
+        handler.start
+      end
     end
 
     sig { returns(Store) }
@@ -28,61 +52,50 @@ module RubyLsp
     def initialize
       @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
       @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @handlers = T.let({}, T::Hash[String, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)])
+      @handlers = T.let({}, T::Hash[String, RequestHandler])
       @store = T.let(Store.new, Store)
+      @queue = T.let(Queue.new(@writer, @handlers), Queue)
     end
 
     sig { void }
     def start
       $stderr.puts "Starting Ruby LSP..."
-      @reader.read { |request| handle(request) }
+
+      @reader.read do |request|
+        handler = @handlers[request[:method]]
+        next if handler.nil?
+
+        if handler.parallel
+          @queue.push(request)
+        else
+          result = @queue.execute(request)
+          @queue.finalize_request(result, request)
+        end
+      end
     end
 
     private
 
+    sig { params(id: T.any(String, Integer)).void }
+    def cancel_request(id)
+      @queue.cancel(id)
+    end
+
     sig do
       params(
         msg: String,
+        parallel: T::Boolean,
         blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
-      ).void
+      ).returns(RequestHandler)
     end
-    def on(msg, &blk)
-      @handlers[msg] = blk
-    end
-
-    sig { params(request: T::Hash[Symbol, T.untyped]).void }
-    def handle(request)
-      result = T.let(nil, T.untyped)
-      error = T.let(nil, T.nilable(StandardError))
-      handler = @handlers[request[:method]]
-
-      request_time = Benchmark.realtime do
-        if handler
-          begin
-            result = handler.call(request)
-          rescue StandardError => e
-            error = e
-          end
-
-          if error
-            @writer.write(
-              {
-                id: request[:id],
-                error: { code: Constant::ErrorCodes::INTERNAL_ERROR, message: error.inspect, data: request.to_json },
-              }
-            )
-          elsif result != VOID
-            @writer.write(id: request[:id], result: result)
-          end
-        end
-      end
-
-      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+    def on(msg, parallel: false, &blk)
+      @handlers[msg] = RequestHandler.new(action: blk, parallel: parallel)
     end
 
     sig { void }
     def shutdown
       $stderr.puts "Shutting down Ruby LSP..."
+      @queue.shutdown
       store.clear
     end
 
@@ -101,30 +114,5 @@ module RubyLsp
         params: Interface::ShowMessageParams.new(type: type, message: message)
       )
     end
-
-    sig do
-      params(
-        request: T::Hash[Symbol, T.untyped],
-        request_time: Float,
-        error: T.nilable(StandardError)
-      ).returns(T::Hash[Symbol, T.any(String, Float)])
-    end
-    def telemetry_params(request, request_time, error)
-      uri = request.dig(:params, :textDocument, :uri)
-
-      params = {
-        request: request[:method],
-        lspVersion: RubyLsp::VERSION,
-        requestTime: request_time,
-      }
-
-      if error
-        params[:errorClass] = error.class.name
-        params[:errorMessage] = error.message
-      end
-
-      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
-      params
-    end
   end
 end

data/lib/ruby_lsp/queue.rb

@@ -0,0 +1,187 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "benchmark"
+
+module RubyLsp
+  class Queue
+    extend T::Sig
+
+    class Cancelled < Interrupt; end
+
+    class Result < T::Struct
+      const :response, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
+      const :error, T.nilable(StandardError)
+      const :request_time, T.nilable(Float)
+    end
+
+    class Job < T::Struct
+      extend T::Sig
+
+      const :request, T::Hash[Symbol, T.untyped]
+      prop :cancelled, T::Boolean
+
+      sig { void }
+      def cancel
+        self.cancelled = true
+      end
+    end
+
+    sig do
+      params(
+        writer: LanguageServer::Protocol::Transport::Stdio::Writer,
+        handlers: T::Hash[String, Handler::RequestHandler]
+      ).void
+    end
+    def initialize(writer, handlers)
+      @writer = writer
+      @handlers = handlers
+      # The job queue is the actual list of requests we have to process
+      @job_queue = T.let(Thread::Queue.new, Thread::Queue)
+      # The jobs hash is just a way of keeping a handle to jobs based on the request ID, so we can cancel them
+      @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
+      # The current job is a handle to cancel jobs that are currently being processed
+      @current_job = T.let(nil, T.nilable(Job))
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+
+      Thread.main.priority = 1
+    end
+
+    sig { params(request: T::Hash[Symbol, T.untyped]).void }
+    def push(request)
+      job = Job.new(request: request, cancelled: false)
+
+      # Remember a handle to the job, so that we can cancel it
+      @mutex.synchronize do
+        @jobs[request[:id]] = job
+      end
+
+      @job_queue << job
+    end
+
+    sig { params(id: T.any(String, Integer)).void }
+    def cancel(id)
+      @mutex.synchronize do
+        # Cancel the job if it's still in the queue
+        @jobs[id]&.cancel
+
+        # Cancel the job if we're in the middle of processing it
+        if @current_job&.request&.dig(:id) == id
+          @worker.raise(Cancelled)
+        end
+      end
+    end
+
+    sig { void }
+    def shutdown
+      # Close the queue so that we can no longer receive items
+      @job_queue.close
+      # Clear any remaining jobs so that the thread can terminate
+      @job_queue.clear
+      # Wait until the thread is finished
+      @worker.join
+    end
+
+    # Executes a request and returns a Queue::Result. No IO should happen in this method, because it can be cancelled in
+    # the middle with a raise
+    sig { params(request: T::Hash[Symbol, T.untyped]).returns(Queue::Result) }
+    def execute(request)
+      response = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
+
+      request_time = Benchmark.realtime do
+        response = T.must(@handlers[request[:method]]).action.call(request)
+      rescue StandardError => e
+        error = e
+      end
+
+      Queue::Result.new(response: response, error: error, request_time: request_time)
+    end
+
+    # Finalize a Queue::Result. All IO operations should happen here to avoid any issues with cancelling requests
+    sig do
+      params(
+        result: Result,
+        request: T::Hash[Symbol, T.untyped]
+      ).void
+    end
+    def finalize_request(result, request)
+      error = result.error
+      if error
+        T.must(@handlers[request[:method]]).error_handler&.call(error, request)
+
+        @writer.write(
+          id: request[:id],
+          error: {
+            code: LanguageServer::Protocol::Constant::ErrorCodes::INTERNAL_ERROR,
+            message: result.error.inspect,
+            data: request.to_json,
+          },
+        )
+      elsif result.response != Handler::VOID
+        @writer.write(id: request[:id], result: result.response)
+      end
+
+      request_time = result.request_time
+      if request_time
+        @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, result.error))
+      end
+    end
+
+    private
+
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        # Thread::Queue#pop is thread safe and will wait until an item is available
+        while (job = T.let(@job_queue.pop, T.nilable(Job)))
+          # The only time when the job is nil is when the queue is closed and we can then terminate the thread
+
+          request = job.request
+          @mutex.synchronize do
+            @jobs.delete(request[:id])
+            @current_job = job
+          end
+
+          begin
+            next if job.cancelled
+
+            result = execute(request)
+          rescue Cancelled
+            # We need to return nil to the client even if the request was cancelled
+            result = Queue::Result.new(response: nil, error: nil, request_time: nil)
+          ensure
+            @mutex.synchronize { @current_job = nil }
+            finalize_request(result, request) unless result.nil?
+          end
+        end
+      end
+    end
+
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(StandardError)
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
+    end
+    def telemetry_params(request, request_time, error)
+      uri = request.dig(:params, :textDocument, :uri)
+
+      params = {
+        request: request[:method],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
+
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
+      end
+
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      params
+    end
+  end
+end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -105,9 +105,13 @@ module RubyLsp
         sig { returns(Integer) }
         attr_reader :end_line
 
-        sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
-        def self.from(node, kind)
-          new(node.location.start_line - 1, node.location.end_line - 1, kind)
+        class << self
+          extend T::Sig
+
+          sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
+          def from(node, kind)
+            new(node.location.start_line - 1, node.location.end_line - 1, kind)
+          end
         end
 
         sig { params(start_line: Integer, end_line: Integer, kind: String).void }

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -0,0 +1,135 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![On type formatting demo](../../misc/on_type_formatting.gif)
+    #
+    # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
+    # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo # <-- upon adding a line break, on type formatting is triggered
+    #   # <-- cursor ends up here
+    # end # <-- end is automatically added
+    # ```
+    class OnTypeFormatting < BaseRequest
+      extend T::Sig
+
+      END_REGEXES = T.let([
+        /(if|unless|for|while|class|module|until|def|case).*/,
+        /.*\sdo/,
+      ], T::Array[Regexp])
+
+      sig { params(document: Document, position: Document::PositionShape, trigger_character: String).void }
+      def initialize(document, position, trigger_character)
+        super(document)
+
+        scanner = Document::Scanner.new(document.source)
+        line_begin = position[:line] == 0 ? 0 : scanner.find_position({ line: position[:line] - 1, character: 0 })
+        line_end = scanner.find_position(position)
+        line = T.must(@document.source[line_begin..line_end])
+
+        @indentation = T.let(find_indentation(line), Integer)
+        @previous_line = T.let(line.strip.chomp, String)
+        @position = position
+        @edits = T.let([], T::Array[Interface::TextEdit])
+        @trigger_character = trigger_character
+      end
+
+      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      def run
+        return unless @document.syntax_errors?
+
+        case @trigger_character
+        when "{"
+          handle_curly_brace
+        when "|"
+          handle_pipe
+        when "\n"
+          handle_statement_end
+        end
+
+        @edits
+      end
+
+      private
+
+      sig { void }
+      def handle_pipe
+        return unless /".*|/.match?(@previous_line)
+
+        add_edit_with_text("|")
+        move_cursor_to(@position[:line], @position[:character])
+      end
+
+      sig { void }
+      def handle_curly_brace
+        return unless /".*#\{/.match?(@previous_line)
+
+        add_edit_with_text("}")
+        move_cursor_to(@position[:line], @position[:character])
+      end
+
+      sig { void }
+      def handle_statement_end
+        return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
+
+        indents = " " * @indentation
+
+        add_edit_with_text(" \n#{indents}end")
+        move_cursor_to(@position[:line], @indentation + 2)
+      end
+
+      sig { params(text: String).void }
+      def add_edit_with_text(text)
+        position = Interface::Position.new(
+          line: @position[:line],
+          character: @position[:character]
+        )
+
+        @edits << Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: position,
+            end: position
+          ),
+          new_text: text
+        )
+      end
+
+      sig { params(line: Integer, character: Integer).void }
+      def move_cursor_to(line, character)
+        position = Interface::Position.new(
+          line: line,
+          character: character
+        )
+
+        # The $0 is a special snippet anchor that moves the cursor to that given position. See the snippets
+        # documentation for more information:
+        # https://code.visualstudio.com/docs/editor/userdefinedsnippets#_create-your-own-snippets
+        @edits << Interface::TextEdit.new(
+          range: Interface::Range.new(
+            start: position,
+            end: position
+          ),
+          new_text: "$0"
+        )
+      end
+
+      sig { params(line: String).returns(Integer) }
+      def find_indentation(line)
+        count = 0
+
+        line.chars.each do |c|
+          break unless c == " "
+
+          count += 1
+        end
+
+        count
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -10,6 +10,7 @@ module RubyLsp
   # - {RubyLsp::Requests::SelectionRanges}
   # - {RubyLsp::Requests::SemanticHighlighting}
   # - {RubyLsp::Requests::Formatting}
+  # - {RubyLsp::Requests::OnTypeFormatting}
   # - {RubyLsp::Requests::Diagnostics}
   # - {RubyLsp::Requests::CodeActions}
   # - {RubyLsp::Requests::DocumentHighlight}
@@ -21,6 +22,7 @@ module RubyLsp
     autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
     autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
     autoload :Formatting, "ruby_lsp/requests/formatting"
+    autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"

data/lib/ruby_lsp/server.rb

@@ -48,6 +48,13 @@ module RubyLsp
         }
       end
 
+      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
+        Interface::DocumentOnTypeFormattingOptions.new(
+          first_trigger_character: "{",
+          more_trigger_character: ["\n", "|"]
+        )
+      end
+
       # TODO: switch back to using Interface::ServerCapabilities once the gem is updated for spec 3.17
       Interface::InitializeResult.new(
         capabilities: {
@@ -63,6 +70,7 @@ module RubyLsp
           documentFormattingProvider: enabled_features.include?("formatting"),
           documentHighlightProvider: enabled_features.include?("documentHighlights"),
           codeActionProvider: enabled_features.include?("codeActions"),
+          documentOnTypeFormattingProvider: on_type_formatting_provider,
           diagnosticProvider: diagnostics_provider,
         }.reject { |_, v| !v }
       )
@@ -91,26 +99,26 @@ module RubyLsp
       Handler::VOID
     end
 
-    on("textDocument/documentSymbol") do |request|
+    on("textDocument/documentSymbol", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :document_symbol) do |document|
         Requests::DocumentSymbol.new(document).run
       end
     end
 
-    on("textDocument/documentLink") do |request|
+    on("textDocument/documentLink", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       store.cache_fetch(uri, :document_link) do |document|
         RubyLsp::Requests::DocumentLink.new(uri, document).run
       end
     end
 
-    on("textDocument/foldingRange") do |request|
+    on("textDocument/foldingRange", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
         Requests::FoldingRanges.new(document).run
       end
     end
 
-    on("textDocument/selectionRange") do |request|
+    on("textDocument/selectionRange", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       positions = request.dig(:params, :positions)
 
@@ -132,7 +140,7 @@ module RubyLsp
       end
     end
 
-    on("textDocument/semanticTokens/full") do |request|
+    on("textDocument/semanticTokens/full", parallel: true) do |request|
       store.cache_fetch(request.dig(:params, :textDocument, :uri), :semantic_highlighting) do |document|
         T.cast(
           Requests::SemanticHighlighting.new(
@@ -144,13 +152,24 @@ module RubyLsp
       end
     end
 
-    on("textDocument/formatting") do |request|
+    on("textDocument/formatting", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
 
       Requests::Formatting.new(uri, store.get(uri)).run
+    rescue RuboCop::Runner::InfiniteCorrectionLoop => e
+      show_message(Constant::MessageType::ERROR, "Error from RuboCop: #{e.message}")
+      nil
     end
 
-    on("textDocument/documentHighlight") do |request|
+    on("textDocument/onTypeFormatting", parallel: true) do |request|
+      uri = request.dig(:params, :textDocument, :uri)
+      position = request.dig(:params, :position)
+      character = request.dig(:params, :ch)
+
+      Requests::OnTypeFormatting.new(store.get(uri), position, character).run
+    end
+
+    on("textDocument/documentHighlight", parallel: true) do |request|
       document = store.get(request.dig(:params, :textDocument, :uri))
 
       if document.parsed?
@@ -158,7 +177,7 @@ module RubyLsp
       end
     end
 
-    on("textDocument/codeAction") do |request|
+    on("textDocument/codeAction", parallel: true) do |request|
       uri = request.dig(:params, :textDocument, :uri)
       range = request.dig(:params, :range)
       start_line = range.dig(:start, :line)
@@ -169,6 +188,11 @@ module RubyLsp
       end
     end
 
+    on("$/cancelRequest") do |request|
+      cancel_request(request[:params][:id])
+      Handler::VOID
+    end
+
     on("textDocument/diagnostic") do |request|
       uri = request.dig(:params, :textDocument, :uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
@@ -176,9 +200,10 @@ module RubyLsp
       end
 
       { kind: "full", items: response.map(&:to_lsp_diagnostic) } if response
-    rescue RuboCop::ValidationError => e
-      show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{e.message}")
-      nil
+    end.on_error do |error|
+      if error.is_a?(RuboCop::ValidationError)
+        show_message(Constant::MessageType::ERROR, "Error in RuboCop configuration file: #{error.message}")
+      end
     end
 
     on("shutdown") { shutdown }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Shopify
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '3.4'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -69,6 +69,7 @@ files:
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/handler.rb
 - lib/ruby_lsp/internal.rb
+- lib/ruby_lsp/queue.rb
 - lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/base_request.rb
 - lib/ruby_lsp/requests/code_actions.rb
@@ -78,6 +79,7 @@ files:
 - lib/ruby_lsp/requests/document_symbol.rb
 - lib/ruby_lsp/requests/folding_ranges.rb
 - lib/ruby_lsp/requests/formatting.rb
+- lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb