Implement workspace/didChangeConfiguration and workspace/configuration

This adds support for the pull model of dynamic configuration changes,
as described here: https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_configuration

Upon receiving `workspace/didChangeConfiguration` message the Ruby LSP
server sends `workspace/configuration` to the client. The client
replies. This reply is different than other replies handled by Ruby LSP
so far, as it does not include `method` and needs to be associated with
the request via `id`. This required implementing a collection of
server-sent requests, to be able to match.

The `result` of the reply is not a hash, instead it's an array of
hashes, so it needed to be handled separately as well.

Technically, upon receiving `workspace/configuration` the server should
check if it should register or unregister some capabilities. I intended
to do that too, but it started to become messy and also I did not have a
way to properly test it.

Author: katafrakt

lib/ruby_lsp/base_server.rb

@@ -13,6 +13,7 @@ def initialize(**options)
       @install_error = options[:install_error] #: StandardError?
       @incoming_queue = Thread::Queue.new #: Thread::Queue
       @outgoing_queue = Thread::Queue.new #: Thread::Queue
+      @sent_requests = {}
       @cancelled_requests = [] #: Array[Integer]
       @worker = new_worker #: Thread
       @current_request_id = 1 #: Integer
@@ -21,7 +22,15 @@ def initialize(**options)
       @outgoing_dispatcher = Thread.new do
         unless @test_mode
           while (message = @outgoing_queue.pop)
-            @global_state.synchronize { @writer.write(message.to_hash) }
+            @global_state.synchronize do
+              # If the message is a request from server to client, we save it because we might
+              # need it later to understand the response.
+              if message.is_a?(Request)
+                id = message.to_hash[:id]
+                @sent_requests[id] = message
+              end
+              @writer.write(message.to_hash)
+            end
           end
         end
       end #: Thread

lib/ruby_lsp/server.rb

@@ -80,6 +80,9 @@ def process_message(message)
         type_hierarchy_supertypes(message)
       when "typeHierarchy/subtypes"
         type_hierarchy_subtypes(message)
+      when "workspace/didChangeConfiguration"
+        send_log_message("Re-applying Ruby LSP configuration after workspace configuration change")
+        workspace_configuration_did_change(message)
       when "workspace/didChangeWatchedFiles"
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
@@ -157,9 +160,16 @@ def process_message(message)
     # Process responses to requests that were sent to the client
     #: (Hash[Symbol, untyped] message) -> void
     def process_response(message)
-      case message.dig(:result, :method)
+      # Some replies have method in their payload, but some do not and we need to match
+      # the request by id to find what the method is.
+      method = (message[:result].is_a?(Hash) && message.dig(:result, :method)) || @sent_requests[message[:id]]&.to_hash&.fetch(:method)
+
+      case method
       when "window/showMessageRequest"
         window_show_message_request(message)
+      when "workspace/configuration"
+        send_log_message("Received workspace configuration from client: #{message}")
+        workspace_configuration_received(message)
       end
     end
 
@@ -196,6 +206,21 @@ def load_addons(include_project_addons: true)
 
     private
 
+    #: (Hash[Symbol, untyped] message) -> void
+    def workspace_configuration_did_change(message)
+      # This assumes that the workspace configuration is under "rubyLsp" key, which seems
+      # to be the standard naming convention.
+      send_message(Request.workspace_configuration(
+        @current_request_id, section: "rubyLsp"
+      ))
+    end
+
+    def workspace_configuration_received(message)
+      options = { initializationOptions: message[:result]&.first }
+      messages_to_send = @global_state.apply_options(options)
+      messages_to_send.each { |notification| send_message(notification) }
+    end
+
     #: (Hash[Symbol, untyped] message) -> void
     def run_initialize(message)
       options = message[:params]
@@ -273,6 +298,9 @@ def run_initialize(message)
           rename_provider: rename_provider,
           references_provider: !@global_state.has_type_checker,
           document_range_formatting_provider: true,
+          workspace: {
+            configuration: true,
+          },
           experimental: {
             addon_detection: true,
             compose_bundle: true,

lib/ruby_lsp/utils.rb

@@ -175,6 +175,17 @@ def register_watched_files(
           ),
         )
       end
+
+      def workspace_configuration(
+        id,
+        section:
+      )
+        new(id: id, method: "workspace/configuration", params: Interface::ConfigurationParams.new(
+          items: [
+            Interface::ConfigurationItem.new(section: section),
+          ],
+        ))
+      end
     end
 
     #: (id: (Integer | String), method: String, params: Object) -> void

test/server_test.rb

@@ -412,6 +412,31 @@ def test_backtrace_is_printed_to_stderr_on_exceptions
     end
   end
 
+  def test_reply_to_workspace_configuration_modifies_global_state
+    @server.instance_variable_set(:@sent_requests, {
+      1 => RubyLsp::Request.workspace_configuration(
+        1, section: "rubyLsp"
+      ),
+    })
+
+    @server.process_message({
+      id: 1,
+      result: [{ formatter: "standard" }],
+    })
+
+    assert_equal("standard", @server.global_state.formatter)
+  end
+
+  def test_did_change_configuration_sends_workspace_configuration_request
+    @server.process_message({
+      id: 1,
+      method: "workspace/didChangeConfiguration",
+      params: {},
+    })
+
+    find_message(RubyLsp::Request, "workspace/configuration")
+  end
+
   def test_changed_file_only_indexes_ruby
     path = File.join(Dir.pwd, "lib", "foo.rb")
     File.write(path, "class Foo\nend")