ruby-lsp 0.3.8 → 0.4.1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-02-22 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,11 +72,11 @@ 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_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/diagnostics.rb
 - lib/ruby_lsp/requests/document_highlight.rb
@@ -87,9 +87,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 +100,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

data/lib/ruby_lsp/queue.rb

@@ -1,182 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "benchmark"
-
-module RubyLsp
-  class Queue
-    extend T::Sig
-
-    class Result < T::Struct
-      const :response, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
-      const :error, T.nilable(Exception)
-      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])
-      @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
-      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(Exception))
-
-      request_time = Benchmark.realtime do
-        response = T.must(@handlers[request[:method]]).action.call(request)
-      rescue StandardError, LoadError => 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)
-      @mutex.synchronize do
-        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: 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, error))
-        end
-      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
-        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?
-
-          request = job.request
-          @mutex.synchronize { @jobs.delete(request[:id]) }
-
-          result = if job.cancelled
-            # We need to return nil to the client even if the request was cancelled
-            Queue::Result.new(response: nil, error: nil, request_time: nil)
-          else
-            execute(request)
-          end
-
-          finalize_request(result, request)
-        end
-      end
-    end
-
-    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
-    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
-
-        log_params = request[:params]&.reject { |k, _| k == :textDocument }
-        params[:params] = log_params.to_json if log_params&.any?
-
-        backtrace = error.backtrace
-        params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
-      end
-
-      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
-      params
-    end
-  end
-end

data/lib/ruby_lsp/requests/support/syntax_error_diagnostic.rb

@@ -1,32 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    module Support
-      class SyntaxErrorDiagnostic
-        extend T::Sig
-
-        sig { params(edit: Document::EditShape).void }
-        def initialize(edit)
-          @edit = edit
-        end
-
-        sig { returns(FalseClass) }
-        def correctable?
-          false
-        end
-
-        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
-        def to_lsp_diagnostic
-          LanguageServer::Protocol::Interface::Diagnostic.new(
-            message: "Syntax error",
-            source: "SyntaxTree",
-            severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-            range: @edit[:range],
-          )
-        end
-      end
-    end
-  end
-end