ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_indexer/test/uri_test.rb

@@ -12,12 +12,12 @@ module RubyIndexer
 
     def test_from_path_on_windows
       uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
-      assert_equal("/C:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/C%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_from_path_on_windows_with_lowercase_drive
       uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
-      assert_equal("/c:/some/windows/path/to/file.rb", uri.path)
+      assert_equal("/c%3A/some/windows/path/to/file.rb", uri.path)
     end
 
     def test_to_standardized_path_on_unix
@@ -68,5 +68,18 @@ module RubyIndexer
       uri.add_require_path_from_load_entry("/some/unix/path")
       assert_equal("to/file", uri.require_path)
     end
+
+    def test_from_path_escapes_colon_characters
+      uri = URI::Generic.from_path(path: "c:/some/windows/path with/spaces/file.rb")
+      assert_equal("c:/some/windows/path with/spaces/file.rb", uri.to_standardized_path)
+      assert_equal("file:///c%3A/some/windows/path%20with/spaces/file.rb", uri.to_s)
+    end
+
+    def test_from_path_with_unicode_characters
+      path = "/path/with/unicode/文件.rb"
+      uri = URI::Generic.from_path(path: path)
+      assert_equal(path, uri.to_standardized_path)
+      assert_equal("file:///path/with/unicode/%E6%96%87%E4%BB%B6.rb", uri.to_s)
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -19,48 +19,36 @@ module RubyLsp
   #   end
   # end
   # ```
+  # @abstract
   class Addon
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
-    @addons = T.let([], T::Array[Addon])
-    @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+    @addons = [] #: Array[Addon]
+    @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
-    @file_watcher_addons = T.let([], T::Array[Addon])
+    @file_watcher_addons = [] #: Array[Addon]
 
     AddonNotFoundError = Class.new(StandardError)
 
     class IncompatibleApiError < StandardError; end
 
     class << self
-      extend T::Sig
-
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :addons
 
-      sig { returns(T::Array[Addon]) }
+      #: Array[Addon]
       attr_accessor :file_watcher_addons
 
-      sig { returns(T::Array[T.class_of(Addon)]) }
+      #: Array[singleton(Addon)]
       attr_reader :addon_classes
 
       # Automatically track and instantiate add-on classes
-      sig { params(child_class: T.class_of(Addon)).void }
+      #: (singleton(Addon) child_class) -> void
       def inherited(child_class)
         addon_classes << child_class
         super
       end
 
       # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
-      sig do
-        params(
-          global_state: GlobalState,
-          outgoing_queue: Thread::Queue,
-          include_project_addons: T::Boolean,
-        ).returns(T::Array[StandardError])
-      end
+      #: (GlobalState global_state, Thread::Queue outgoing_queue, ?include_project_addons: bool) -> Array[StandardError]
       def load_addons(global_state, outgoing_queue, include_project_addons: true)
         # Require all add-ons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb` or in the workspace under
@@ -68,7 +56,28 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
+          bundle_path = Bundler.bundle_path.to_s
+          gems_dir = Bundler.bundle_path.join("gems")
+
+          # Create an array of rejection glob patterns to ignore add-ons already discovered through Gem.find_files if
+          # they are also copied inside the workspace for whatever reason. We received reports of projects having gems
+          # installed in vendor/bundle despite BUNDLE_PATH pointing elsewhere. Without this mechanism, we will
+          # double-require the same add-on, potentially for different versions of the same gem, which leads to incorrect
+          # behavior
+          reject_glob_patterns = addon_files.map do |path|
+            relative_gem_path = Pathname.new(path).relative_path_from(gems_dir)
+            first_part, *parts = relative_gem_path.to_s.split(File::SEPARATOR)
+            first_part&.gsub!(/-([0-9.]+)$/, "*")
+            "**/#{first_part}/#{parts.join("/")}"
+          end
+
+          project_addons.reject! do |path|
+            path.start_with?(bundle_path) ||
+              reject_glob_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::Constants::FNM_PATHNAME) }
+          end
+
+          addon_files.concat(project_addons)
         end
 
         errors = addon_files.filter_map do |addon_path|
@@ -98,7 +107,7 @@ module RubyLsp
       end
 
       # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
-      sig { void }
+      #: -> void
       def unload_addons
         @addons.each(&:deactivate)
         @addons.clear
@@ -112,7 +121,7 @@ module RubyLsp
       # Important: if the add-on is not found, AddonNotFoundError will be raised. If the add-on is found, but its
       # current version does not satisfy the given version constraint, then IncompatibleApiError will be raised. It is
       # the responsibility of the add-ons using this API to handle these errors appropriately.
-      sig { params(addon_name: String, version_constraints: String).returns(Addon) }
+      #: (String addon_name, *String version_constraints) -> Addon
       def get(addon_name, *version_constraints)
         if version_constraints.empty?
           raise IncompatibleApiError, "Must specify version constraints when accessing other add-ons"
@@ -144,7 +153,7 @@ module RubyLsp
       #   end
       # end
       # ```
-      sig { params(version_constraints: String).void }
+      #: (*String version_constraints) -> void
       def depend_on_ruby_lsp!(*version_constraints)
         version_object = Gem::Version.new(RubyLsp::VERSION)
 
@@ -155,23 +164,23 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def initialize
-      @errors = T.let([], T::Array[StandardError])
+      @errors = [] #: Array[StandardError]
     end
 
-    sig { params(error: StandardError).returns(T.self_type) }
+    #: (StandardError error) -> self
     def add_error(error)
       @errors << error
       self
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def error?
       @errors.any?
     end
 
-    sig { returns(String) }
+    #: -> String
     def formatted_errors
       <<~ERRORS
         #{name}:
@@ -179,97 +188,90 @@ module RubyLsp
       ERRORS
     end
 
-    sig { returns(String) }
+    #: -> String
     def errors_details
       @errors.map(&:full_message).join("\n\n")
     end
 
     # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
-    def activate(global_state, outgoing_queue); end
+    # @abstract
+    #: (GlobalState, Thread::Queue) -> void
+    def activate(global_state, outgoing_queue)
+      raise AbstractMethodInvokedError
+    end
 
-    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on must implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
-    sig { abstract.void }
-    def deactivate; end
+    # @abstract
+    #: -> void
+    def deactivate
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `name` method to return the add-on name
-    sig { abstract.returns(String) }
-    def name; end
+    # @abstract
+    #: -> String
+    def name
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `version` method to return a semantic version string representing the add-on's
     # version. This is used for compatibility checks
-    sig { abstract.returns(String) }
-    def version; end
+    # @abstract
+    #: -> String
+    def version
+      raise AbstractMethodInvokedError
+    end
 
     # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the
     # original request so that the response is delegated to the correct add-on and must override this method to handle
     # the response
     # https://microsoft.github.io/language-server-protocol/specification#window_showMessageRequest
-    sig { overridable.params(title: String).void }
+    # @overridable
+    #: (String title) -> void
     def handle_window_show_message_response(title); end
 
     # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        uri: URI::Generic,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
     def create_code_lens_listener(response_builder, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::Hover,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_hover_listener(response_builder, node_context, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::DocumentSymbol,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
     def create_document_symbol_listener(response_builder, dispatcher); end
 
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::SemanticHighlighting,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::SemanticHighlighting response_builder, Prism::Dispatcher dispatcher) -> void
     def create_semantic_highlighting_listener(response_builder, dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-          Interface::Location,
-          Interface::LocationLink,
-        )],
-        uri: URI::Generic,
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
     def create_definition_listener(response_builder, uri, node_context, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
-    sig do
-      overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        node_context: NodeContext,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-      ).void
-    end
+    # @overridable
+    #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
     def create_completion_listener(response_builder, node_context, dispatcher, uri); end
+
+    # Creates a new Discover Tests listener. This method is invoked on every DiscoverTests request
+    # @overridable
+    #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+    def create_discover_tests_listener(response_builder, dispatcher, uri); end
+
+    # Resolves the minimal set of commands required to execute the requested tests. Add-ons are responsible for only
+    # handling items related to the framework they add support for and have discovered themselves
+    # @overridable
+    #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+    def resolve_test_commands(items)
+      []
+    end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -2,36 +2,29 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   class BaseServer
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
-    sig { params(options: T.untyped).void }
+    #: (**untyped options) -> void
     def initialize(**options)
-      @test_mode = T.let(options[:test_mode], T.nilable(T::Boolean))
-      @setup_error = T.let(options[:setup_error], T.nilable(StandardError))
-      @install_error = T.let(options[:install_error], T.nilable(StandardError))
-      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
-      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @cancelled_requests = T.let([], T::Array[Integer])
-      @worker = T.let(new_worker, Thread)
-      @current_request_id = T.let(1, Integer)
-      @global_state = T.let(GlobalState.new, GlobalState)
-      @store = T.let(Store.new(@global_state), Store)
-      @outgoing_dispatcher = T.let(
-        Thread.new do
-          unless @test_mode
-            while (message = @outgoing_queue.pop)
-              @global_state.synchronize { @writer.write(message.to_hash) }
-            end
+      @reader = MessageReader.new(options[:reader] || $stdin) #: MessageReader
+      @writer = MessageWriter.new(options[:writer] || $stdout) #: MessageWriter
+      @test_mode = options[:test_mode] #: bool?
+      @setup_error = options[:setup_error] #: StandardError?
+      @install_error = options[:install_error] #: StandardError?
+      @incoming_queue = Thread::Queue.new #: Thread::Queue
+      @outgoing_queue = Thread::Queue.new #: Thread::Queue
+      @cancelled_requests = [] #: Array[Integer]
+      @worker = new_worker #: Thread
+      @current_request_id = 1 #: Integer
+      @global_state = GlobalState.new #: GlobalState
+      @store = Store.new(@global_state) #: Store
+      @outgoing_dispatcher = Thread.new do
+        unless @test_mode
+          while (message = @outgoing_queue.pop)
+            @global_state.synchronize { @writer.write(message.to_hash) }
           end
-        end,
-        Thread,
-      )
+        end
+      end #: Thread
 
       Thread.main.priority = 1
 
@@ -41,9 +34,9 @@ module RubyLsp
       process_message(initialize_request) if initialize_request
     end
 
-    sig { void }
+    #: -> void
     def start
-      @reader.read do |message|
+      @reader.each_message do |message|
         method = message[:method]
 
         # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
@@ -90,8 +83,7 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-          "rubyLsp/diagnoseState"
+        when "initialize", "initialized", "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -101,14 +93,37 @@ module RubyLsp
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
+          exit(@incoming_queue.closed? ? 0 : 1)
         else
           @incoming_queue << message
         end
       end
     end
 
-    sig { void }
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    #: -> untyped
+    def pop_response
+      @outgoing_queue.pop
+    end
+
+    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
+    #: (Hash[Symbol, untyped] message) -> void
+    def push_message(message)
+      @incoming_queue << message
+    end
+
+    # @abstract
+    #: (Hash[Symbol, untyped] message) -> void
+    def process_message(message)
+      raise AbstractMethodInvokedError
+    end
+
+    #: -> bool?
+    def test_mode?
+      @test_mode
+    end
+
+    #: -> void
     def run_shutdown
       @incoming_queue.clear
       @outgoing_queue.clear
@@ -121,34 +136,24 @@ module RubyLsp
       @store.clear
     end
 
-    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
-    sig { returns(T.untyped) }
-    def pop_response
-      @outgoing_queue.pop
-    end
+    private
 
-    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
-    def push_message(message)
-      @incoming_queue << message
+    # @abstract
+    #: -> void
+    def shutdown
+      raise AbstractMethodInvokedError
     end
 
-    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
-    def process_message(message); end
-
-    sig { abstract.void }
-    def shutdown; end
-
-    sig { params(id: Integer, message: String, type: Integer).void }
+    #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
       send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
       send_message(Notification.window_show_message(message, type: type))
     end
 
-    sig { returns(Thread) }
+    #: -> Thread
     def new_worker
       Thread.new do
-        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+        while (message = @incoming_queue.pop)
           id = message[:id]
 
           # Check if the request was cancelled before trying to process it
@@ -165,7 +170,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    #: ((Result | Error | Notification | Request) message) -> void
     def send_message(message)
       # When we're shutting down the server, there's a small race condition between closing the thread queues and
       # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
@@ -176,12 +181,12 @@ module RubyLsp
       @current_request_id += 1 if message.is_a?(Request)
     end
 
-    sig { params(id: Integer).void }
+    #: (Integer id) -> void
     def send_empty_response(id)
       send_message(Result.new(id: id, response: nil))
     end
 
-    sig { params(message: String, type: Integer).void }
+    #: (String message, ?type: Integer) -> void
     def send_log_message(message, type: Constant::MessageType::LOG)
       send_message(Notification.window_log_message(message, type: Constant::MessageType::LOG))
     end

data/lib/ruby_lsp/client_capabilities.rb

@@ -5,40 +5,42 @@ module RubyLsp
   # This class stores all client capabilities that the Ruby LSP and its add-ons depend on to ensure that we're
   # not enabling functionality unsupported by the editor connecting to the server
   class ClientCapabilities
-    extend T::Sig
-
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :supports_watching_files,
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
       :supports_progress,
-      :supports_diagnostic_refresh
+      :supports_diagnostic_refresh,
+      :supports_code_lens_refresh
 
-    sig { void }
+    #: -> void
     def initialize
       # The editor supports watching files. This requires two capabilities: dynamic registration and relative pattern
       # support
-      @supports_watching_files = T.let(false, T::Boolean)
+      @supports_watching_files = false #: bool
 
       # The editor supports request delegation. This is an experimental capability since request delegation has not been
       # standardized into the LSP spec yet
-      @supports_request_delegation = T.let(false, T::Boolean)
+      @supports_request_delegation = false #: bool
 
       # The editor supports extra arbitrary properties for `window/showMessageRequest`. Necessary for add-ons to show
       # dialogs with user interactions
-      @window_show_message_supports_extra_properties = T.let(false, T::Boolean)
+      @window_show_message_supports_extra_properties = false #: bool
 
       # Which resource operations the editor supports, like renaming files
-      @supported_resource_operations = T.let([], T::Array[String])
+      @supported_resource_operations = [] #: Array[String]
 
       # The editor supports displaying progress requests
-      @supports_progress = T.let(false, T::Boolean)
+      @supports_progress = false #: bool
 
       # The editor supports server initiated refresh for diagnostics
-      @supports_diagnostic_refresh = T.let(false, T::Boolean)
+      @supports_diagnostic_refresh = false #: bool
+
+      # The editor supports server initiated refresh for code lenses
+      @supports_code_lens_refresh = false #: bool
     end
 
-    sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] capabilities) -> void
     def apply_client_capabilities(capabilities)
       workspace_capabilities = capabilities[:workspace] || {}
 
@@ -63,9 +65,10 @@ module RubyLsp
       @supports_progress = progress if progress
 
       @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
+      @supports_code_lens_refresh = workspace_capabilities.dig(:codeLens, :refreshSupport) || false
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_rename?
       @supported_resource_operations.include?("rename")
     end