ruby-lsp 0.3.8 → 0.4.0

data/lib/ruby_lsp/server.rb

@@ -1,250 +1,157 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/internal"
-
 module RubyLsp
-  Handler.start do
-    on("initialize") do |request|
-      store.clear
-      store.encoding = request.dig(:params, :capabilities, :general, :positionEncodings)
-
-      initialization_options = request.dig(:params, :initializationOptions)
-      enabled_features = initialization_options.fetch(:enabledFeatures, [])
-
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
-          },
-        )
-      end
-
-      document_link_provider = if enabled_features.include?("documentLink")
-        Interface::DocumentLinkOptions.new(resolve_provider: false)
-      end
-
-      hover_provider = if enabled_features.include?("hover")
-        Interface::HoverClientCapabilities.new(dynamic_registration: false)
-      end
-
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
-          ),
-          range: true,
-          full: { delta: false },
-        )
-      end
-
-      diagnostics_provider = if enabled_features.include?("diagnostics")
-        {
-          interFileDependencies: false,
-          workspaceDiagnostics: false,
-        }
-      end
-
-      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
-        Interface::DocumentOnTypeFormattingOptions.new(
-          first_trigger_character: "{",
-          more_trigger_character: ["\n", "|"],
-        )
-      end
-
-      inlay_hint_provider = if enabled_features.include?("inlayHint")
-        Interface::InlayHintOptions.new(resolve_provider: false)
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+  Transport = LanguageServer::Protocol::Transport
+
+  class Server
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @store = T.let(Store.new, Store)
+
+      # 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])
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+
+      Thread.main.priority = 1
+    end
+
+    sig { void }
+    def start
+      warn("Starting Ruby LSP...")
+
+      # Requests that have to be executed sequentially or in the main process are implemented here. All other requests
+      # fall under the else branch which just pushes requests to the queue
+      @reader.read do |request|
+        case request[:method]
+        when "initialize", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+          result = Executor.new(@store).execute(request)
+          finalize_request(result, request)
+        when "$/cancelRequest"
+          # Cancel the job if it's still in the queue
+          @mutex.synchronize { @jobs[request[:params][:id]]&.cancel }
+        when "shutdown"
+          warn("Shutting down Ruby LSP...")
+
+          # 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
+          @jobs.clear
+          # Wait until the thread is finished
+          @worker.join
+          @store.clear
+
+          finalize_request(Result.new(response: nil, notifications: []), request)
+        when "exit"
+          # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
+          # https://microsoft.github.io/language-server-protocol/specification/#exit
+          status = @store.empty? ? 0 : 1
+          exit(status)
+        else
+          # Default case: push the request to the queue to be executed by the worker
+          job = Job.new(request: request, cancelled: false)
+
+          # Remember a handle to the job, so that we can cancel it
+          @mutex.synchronize { @jobs[request[:id]] = job }
+          @job_queue << job
+        end
       end
-
-      Interface::InitializeResult.new(
-        capabilities: Interface::ServerCapabilities.new(
-          text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::INCREMENTAL,
-            open_close: true,
-          ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
-          hover_provider: hover_provider,
-          document_symbol_provider: document_symbol_provider,
-          document_link_provider: document_link_provider,
-          folding_range_provider: folding_ranges_provider,
-          semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features.include?("formatting"),
-          document_highlight_provider: enabled_features.include?("documentHighlights"),
-          code_action_provider: enabled_features.include?("codeActions"),
-          document_on_type_formatting_provider: on_type_formatting_provider,
-          diagnostic_provider: diagnostics_provider,
-          inlay_hint_provider: inlay_hint_provider,
-        ),
-      )
     end
 
-    on("textDocument/didChange") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      store.push_edits(uri, request.dig(:params, :contentChanges))
-
-      Handler::VOID
-    end
-
-    on("textDocument/didOpen") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      text = request.dig(:params, :textDocument, :text)
-      store.set(uri, text)
-
-      Handler::VOID
-    end
-
-    on("textDocument/didClose") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      store.delete(uri)
-      clear_diagnostics(uri)
+    private
 
-      Handler::VOID
-    end
-
-    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", 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
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        # Thread::Queue#pop is thread safe and will wait until an item is available
+        loop do
+          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
+          break if job.nil?
 
-    on("textDocument/hover") do |request|
-      position = request.dig(:params, :position)
-      document = store.get(request.dig(:params, :textDocument, :uri))
+          request = job.request
+          @mutex.synchronize { @jobs.delete(request[:id]) }
 
-      RubyLsp::Requests::Hover.new(document, position).run
-    end
+          result = if job.cancelled
+            # We need to return nil to the client even if the request was cancelled
+            Result.new(response: nil, notifications: [])
+          else
+            Executor.new(@store).execute(request)
+          end
 
-    on("textDocument/foldingRange", parallel: true) do |request|
-      store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
-        Requests::FoldingRanges.new(document).run
+          finalize_request(result, request)
+        end
       end
     end
 
-    on("textDocument/selectionRange", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      positions = request.dig(:params, :positions)
-
-      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.new(document).run
-      end
-
-      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
-      # every position in the positions array should have an element at the same index in the response
-      # array. For positions without a valid selection range, the corresponding element in the response
-      # array will be nil.
-
-      unless ranges.nil?
-        positions.map do |position|
-          ranges.find do |range|
-            range.cover?(position)
-          end
+    # Finalize a Queue::Result. All IO operations should happen here to avoid any issues with cancelling requests
+    sig { params(result: Result, request: T::Hash[Symbol, T.untyped]).void }
+    def finalize_request(result, request)
+      @mutex.synchronize do
+        error = result.error
+        response = result.response
+
+        # If the response include any notifications, go through them and publish each one
+        result.notifications.each { |n| @writer.write(method: n.message, params: n.params) }
+
+        if error
+          @writer.write(
+            id: request[:id],
+            error: {
+              code: Constant::ErrorCodes::INTERNAL_ERROR,
+              message: error.inspect,
+              data: request.to_json,
+            },
+          )
+        elsif response != VOID
+          @writer.write(id: request[:id], result: response)
         end
-      end
-    end
 
-    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(
-            document,
-            encoder: Requests::Support::SemanticTokenEncoder.new,
-          ).run,
-          LanguageServer::Protocol::Interface::SemanticTokens,
-        )
+        request_time = result.request_time
+        if request_time
+          @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+        end
       end
     end
 
-    on("textDocument/semanticTokens/range", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::SemanticHighlighting.new(
-        document,
-        range: start_line..end_line,
-        encoder: Requests::Support::SemanticTokenEncoder.new,
-      ).run
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(Exception),
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
     end
-
-    on("textDocument/formatting", parallel: true) do |request|
+    def telemetry_params(request, request_time, error)
       uri = request.dig(:params, :textDocument, :uri)
+      params = {
+        request: request[:method],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
 
-      Requests::Formatting.new(uri, store.get(uri)).run
-    end.on_error do |error|
-      show_message(Constant::MessageType::ERROR, "Formatting error: #{error.message}")
-    end
-
-    on("textDocument/onTypeFormatting", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      position = request.dig(:params, :position)
-      character = request.dig(:params, :ch)
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
 
-      Requests::OnTypeFormatting.new(store.get(uri), position, character).run
-    end
+        log_params = request[:params]
+        params[:params] = log_params.reject { |k, _| k == :textDocument }.to_json if log_params
 
-    on("textDocument/documentHighlight", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-
-      Requests::DocumentHighlight.new(document, request.dig(:params, :position)).run
-    end
-
-    on("textDocument/codeAction", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      document = store.get(uri)
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::CodeActions.new(uri, document, start_line..end_line).run
-    end
-
-    on("textDocument/inlayHint", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::InlayHints.new(document, start_line..end_line).run
-    end
-
-    on("$/cancelRequest") do |request|
-      cancel_request(request[:params][:id])
-      Handler::VOID
-    end
-
-    on("textDocument/diagnostic", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
+        backtrace = error.backtrace
+        params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
       end
 
-      { kind: "full", items: response.map(&:to_lsp_diagnostic) } if response
-    end.on_error do |error|
-      show_message(Constant::MessageType::ERROR, "Error running diagnostics: #{error.message}")
-    end
-
-    on("shutdown") { shutdown }
-
-    on("exit") do
-      # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
-      # https://microsoft.github.io/language-server-protocol/specification/#exit
-      status = store.empty? ? 0 : 1
-      exit(status)
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      params
     end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -0,0 +1,78 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # Used to indicate that a request shouldn't return a response
+  VOID = T.let(Object.new.freeze, Object)
+
+  # A notification to be sent to the client
+  class Notification
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(Object) }
+    attr_reader :params
+
+    sig { params(message: String, params: Object).void }
+    def initialize(message:, params:)
+      @message = message
+      @params = params
+    end
+  end
+
+  # The final result of running a request before its IO is finalized
+  class Result
+    extend T::Sig
+
+    sig { returns(T.untyped) }
+    attr_reader :response
+
+    sig { returns(T::Array[Notification]) }
+    attr_reader :notifications
+
+    sig { returns(T.nilable(Exception)) }
+    attr_reader :error
+
+    sig { returns(T.nilable(Float)) }
+    attr_reader :request_time
+
+    sig do
+      params(
+        response: T.untyped,
+        notifications: T::Array[Notification],
+        error: T.nilable(Exception),
+        request_time: T.nilable(Float),
+      ).void
+    end
+    def initialize(response:, notifications:, error: nil, request_time: nil)
+      @response = response
+      @notifications = notifications
+      @error = error
+      @request_time = request_time
+    end
+  end
+
+  # A request that will sit in the queue until it's executed
+  class Job
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    attr_reader :request
+
+    sig { returns(T::Boolean) }
+    attr_reader :cancelled
+
+    sig { params(request: T::Hash[Symbol, T.untyped], cancelled: T::Boolean).void }
+    def initialize(request:, cancelled:)
+      @request = request
+      @cancelled = cancelled
+    end
+
+    sig { void }
+    def cancel
+      @cancelled = true
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -44,20 +44,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '6'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: '6'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -72,9 +72,8 @@ files:
 - exe/ruby-lsp
 - lib/ruby-lsp.rb
 - lib/ruby_lsp/document.rb
-- lib/ruby_lsp/handler.rb
+- lib/ruby_lsp/executor.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
@@ -87,9 +86,12 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
+- lib/ruby_lsp/requests/path_completion.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
+- lib/ruby_lsp/requests/support/annotation.rb
 - lib/ruby_lsp/requests/support/highlight_target.rb
+- lib/ruby_lsp/requests/support/prefix_tree.rb
 - lib/ruby_lsp/requests/support/rails_document_client.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
@@ -97,10 +99,11 @@ files:
 - lib/ruby_lsp/requests/support/rubocop_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
 - lib/ruby_lsp/requests/support/semantic_token_encoder.rb
+- lib/ruby_lsp/requests/support/sorbet.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
+- lib/ruby_lsp/utils.rb
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
 - MIT

data/lib/ruby_lsp/handler.rb

@@ -1,118 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "ruby_lsp/requests"
-require "ruby_lsp/store"
-require "ruby_lsp/queue"
-
-module RubyLsp
-  Interface = LanguageServer::Protocol::Interface
-  Constant = LanguageServer::Protocol::Constant
-  Transport = LanguageServer::Protocol::Transport
-
-  class Handler
-    extend T::Sig
-    VOID = T.let(Object.new.freeze, Object)
-
-    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: Exception, 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: Exception, 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) }
-    attr_reader :store
-
-    sig { void }
-    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, RequestHandler])
-      @store = T.let(Store.new, Store)
-      @queue = T.let(Queue.new(@writer, @handlers), Queue)
-    end
-
-    sig { void }
-    def start
-      warn("Starting Ruby LSP...")
-
-      @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),
-      ).returns(RequestHandler)
-    end
-    def on(msg, parallel: false, &blk)
-      @handlers[msg] = RequestHandler.new(action: blk, parallel: parallel)
-    end
-
-    sig { void }
-    def shutdown
-      warn("Shutting down Ruby LSP...")
-      @queue.shutdown
-      store.clear
-    end
-
-    sig { params(uri: String).void }
-    def clear_diagnostics(uri)
-      @writer.write(
-        method: "textDocument/publishDiagnostics",
-        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
-      )
-    end
-
-    sig { params(type: Integer, message: String).void }
-    def show_message(type, message)
-      @writer.write(
-        method: "window/showMessage",
-        params: Interface::ShowMessageParams.new(type: type, message: message),
-      )
-    end
-  end
-end