ruby-lsp 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fefb041d92fb2000d3da23248ed622abd596a95264b421349f27d104b85f997
-  data.tar.gz: 312918f128e0a49a2f5b2066354df2fe45f9ed37af5e5eace6c76caa101155e5
+  metadata.gz: 6e66f508823e7d8e663c90e9990ae13bf26c3480d4ce9d7d43db14185518064d
+  data.tar.gz: 70cfc0be15d1ad988d66a641191fa64679109ae1f6be56afdc01ded665b0a439
 SHA512:
-  metadata.gz: 7ab96bd356fe94e3a95572bec24053eed9b467c71acec431a80c600e87ea5a3c31f0f2aee20c7b3b407b5aabc9b5736e0bb385dedf2840747c892fe7ad090b69
-  data.tar.gz: 2ec3f3c88c851e86e7ef6485c7719a271dbda81717990446900fe121844daac905b5f554833b59769a4c6f626bb50579d5e51970e7a306d206c898d0a289d36c
+  metadata.gz: a2f71a448863bf25e229032cb06d3ae7e7ebf1ef50b414e6486bd902ec7f100dad1ae4cb7160ef9c5fa8069f3ff0bcbb3da29d9c16a49f2e347f8d3d8797049a
+  data.tar.gz: 4cd747fb8505531a1ab0f1c28c8b3a09a134d544c1834b2f821c220bce2e3b6efce325b73326e23d92891a27ae5ae3cd9a79e9bbfdfa1b45c8f6e490b74d5c9a

data/CHANGELOG.md

@@ -6,28 +6,11 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## [Unreleased]
 
-## [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.2
+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/document_link.rb

@@ -1,30 +1,78 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/source_uri"
+
 module RubyLsp
   module Requests
     # ![Document link demo](../../misc/document_link.gif)
     #
     # The [document link](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentLink)
-    # makes `# source://PATH_TO_FILE:line` comments in a Ruby/RBI file clickable if the file exists.
+    # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
     # When the user clicks the link, it'll open that location.
     #
     # # Example
     #
     # ```ruby
-    # # source://syntax_tree-3.2.1/lib/syntax_tree.rb:51 <- it will be clickable and will take the user to that location
+    # # source://syntax_tree/3.2.1/lib/syntax_tree.rb#51 <- it will be clickable and will take the user to that location
     # def format(source, maxwidth = T.unsafe(nil))
     # end
     # ```
     class DocumentLink < BaseRequest
       extend T::Sig
 
-      RUBY_ROOT = "RUBY_ROOT"
+      GEM_TO_VERSION_MAP = T.let(
+        [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
+          [s.name, s.version.to_s]
+        end.to_h.freeze,
+        T::Hash[String, String]
+      )
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[String, T::Array[String]]) }
+        def gem_paths
+          @gem_paths ||= T.let(begin
+            lookup = {}
+
+            Gem::Specification.stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
+
+              Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
+                lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
+              end
+            end
 
-      sig { params(document: Document).void }
-      def initialize(document)
-        super
+            Gem::Specification.default_stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
+              prefix_matchers = [//]
+              prefix_matchers.concat(spec.require_paths.map { |rp| Regexp.new("^#{rp}/") })
+              prefix_matcher = Regexp.union(prefix_matchers)
+
+              spec.files.each do |file|
+                path = file.sub(prefix_matcher, "")
+                lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
+              end
+            end
+
+            lookup
+          end, T.nilable(T::Hash[String, T::Array[String]]))
+        end
+      end
 
+      sig { params(uri: String, document: Document).void }
+      def initialize(uri, document)
+        super(document)
+
+        # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
+        # in the URI
+        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        @gem_version = T.let(version_match && version_match[0], T.nilable(String))
         @links = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentLink])
       end
 
@@ -36,24 +84,36 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Comment).void }
       def visit_comment(node)
-        match = node.value.match(%r{source://(?<path>.*):(?<line>\d+)$})
+        match = node.value.match(%r{source://.*#\d+$})
         return unless match
 
-        file_path = if match[:path].start_with?(RUBY_ROOT)
-          match[:path].sub(RUBY_ROOT, RbConfig::CONFIG["rubylibdir"])
-        else
-          File.join(Bundler.bundle_path, "gems", match[:path])
-        end
-        return unless File.exist?(file_path)
-
-        target = "file://#{file_path}##{match[:line]}"
+        uri = T.cast(URI(match[0]), URI::Source)
+        gem_version = resolve_version(uri)
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
+        return if file_path.nil?
 
         @links << LanguageServer::Protocol::Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
-          target: target,
-          tooltip: "Jump to #{target.delete_prefix("file://")}"
+          target: "file://#{file_path}##{uri.line_number}",
+          tooltip: "Jump to #{file_path}##{uri.line_number}"
         )
       end
+
+      private
+
+      # Try to figure out the gem version for a source:// link. The order of precedence is:
+      # 1. The version in the URI
+      # 2. The version in the RBI file name
+      # 3. The version from the gemspec
+      sig { params(uri: URI::Source).returns(T.nilable(String)) }
+      def resolve_version(uri)
+        version = uri.gem_version
+        return version unless version.nil? || version.empty?
+
+        return @gem_version unless @gem_version.nil? || @gem_version.empty?
+
+        GEM_TO_VERSION_MAP[uri.gem_name]
+      end
     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/support/source_uri.rb

@@ -0,0 +1,82 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "uri/file"
+
+module URI
+  # Must be kept in sync with the one in Tapioca
+  class Source < URI::File
+    extend T::Sig
+
+    COMPONENT = T.let([
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze, T::Array[Symbol])
+
+    T.unsafe(self).alias_method(:gem_name, :host)
+    T.unsafe(self).alias_method(:line_number, :fragment)
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :gem_version
+
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          gem_name: String,
+          gem_version: T.nilable(String),
+          path: String,
+          line_number: T.nilable(String)
+        ).returns(URI::Source)
+      end
+      def build(gem_name:, gem_version:, path:, line_number:)
+        super(
+          {
+            scheme: "source",
+            host: gem_name,
+            path: DEFAULT_PARSER.escape("/#{gem_version}/#{path}"),
+            fragment: line_number,
+          }
+        )
+      end
+    end
+
+    sig { params(v: T.nilable(String)).void }
+    def set_path(v) # rubocop:disable Naming/AccessorMethodName
+      return if v.nil?
+
+      gem_version, path = v.delete_prefix("/").split("/", 2)
+
+      @gem_version = T.let(gem_version, T.nilable(String))
+      @path = T.let(path, T.nilable(String))
+    end
+
+    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    def check_host(v)
+      return true unless v
+
+      if /[A-Za-z][A-Za-z0-9\-_]*/ !~ v
+        raise InvalidComponentError,
+          "bad component(expected gem name): #{v}"
+      end
+
+      true
+    end
+
+    sig { returns(String) }
+    def to_s
+      "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
+    end
+
+    if URI.respond_to?(:register_scheme)
+      URI.register_scheme("SOURCE", self)
+    else
+      @@schemes = T.let(@@schemes, T::Hash[String, Class]) # rubocop:disable Style/ClassVars
+      @@schemes["SOURCE"] = self
+    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,25 +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|
-      store.cache_fetch(request.dig(:params, :textDocument, :uri), :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(document).run
+    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)
 
@@ -131,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(
@@ -143,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/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") do |request|
+    on("textDocument/documentHighlight", parallel: true) do |request|
       document = store.get(request.dig(:params, :textDocument, :uri))
 
       if document.parsed?
@@ -157,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)
@@ -168,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|
@@ -175,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -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
@@ -86,6 +88,7 @@ files:
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
 - lib/ruby_lsp/requests/support/semantic_token_encoder.rb
+- lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_error_diagnostic.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/store.rb