Add API for delegate notifications and requests

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -174,6 +174,36 @@ def route(controller:, action:)
         nil
       end
 
+      # Delegates a notification to a server add-on
+      sig { params(server_addon_name: String, request_name: String, params: T.untyped).void }
+      def delegate_notification(server_addon_name:, request_name:, **params)
+        send_notification(
+          "server_addon/delegate",
+          request_name: request_name,
+          server_addon_name: server_addon_name,
+          **params,
+        )
+      end
+
+      # Delegates a request to a server add-on
+      sig do
+        params(
+          server_addon_name: String,
+          request_name: String,
+          params: T.untyped,
+        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      end
+      def delegate_request(server_addon_name:, request_name:, **params)
+        make_request(
+          "server_addon/delegate",
+          server_addon_name: server_addon_name,
+          request_name: request_name,
+          **params,
+        )
+      rescue IncompleteMessageError
+        nil
+      end
+
       sig { void }
       def trigger_reload
         log_message("Reloading Rails application")
@@ -205,24 +235,24 @@ def stopped?
       sig do
         params(
           request: String,
-          params: T.nilable(T::Hash[Symbol, T.untyped]),
+          params: T.untyped,
         ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
       end
-      def make_request(request, params = nil)
-        send_message(request, params)
+      def make_request(request, **params)
+        send_message(request, **params)
         read_response
       end
 
       # Notifications are like messages, but one-way, with no response sent back.
-      sig { params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_notification(request, params = nil) = send_message(request, params)
+      sig { params(request: String, params: T.untyped).void }
+      def send_notification(request, **params) = send_message(request, **params)
 
       private
 
-      sig { overridable.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_message(request, params = nil)
+      sig { overridable.params(request: String, params: T.untyped).void }
+      def send_message(request, **params)
         message = { method: request }
-        message[:params] = params if params
+        message[:params] = params
         json = message.to_json
 
         @mutex.synchronize do
@@ -303,8 +333,8 @@ def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         # no-op
       end
 
-      sig { override.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
-      def send_message(request, params = nil)
+      sig { override.params(request: String, params: T.untyped).void }
+      def send_message(request, **params)
         # no-op
       end
 

test/ruby_lsp_rails/runner_client_test.rb

@@ -99,6 +99,26 @@ class RunnerClientTest < ActiveSupport::TestCase
         FileUtils.mv("test/dummy/config/application.rb.bak", "test/dummy/config/application.rb")
       end
 
+      test "delegate notification" do
+        @client.expects(:send_notification).with(
+          "server_addon/delegate",
+          server_addon_name: "My Add-on",
+          request_name: "do_something",
+          id: 5,
+        )
+        @client.delegate_notification(server_addon_name: "My Add-on", request_name: "do_something", id: 5)
+      end
+
+      test "delegate request" do
+        @client.expects(:make_request).with(
+          "server_addon/delegate",
+          server_addon_name: "My Add-on",
+          request_name: "do_something",
+          id: 5,
+        )
+        @client.delegate_request(server_addon_name: "My Add-on", request_name: "do_something", id: 5)
+      end
+
       private
 
       def pop_log_notification(message_queue, type)
@@ -124,11 +144,11 @@ class NullClientTest < ActiveSupport::TestCase
       end
 
       test "#send_message is a no-op" do
-        assert_nothing_raised { @client.send(:send_message, "request", nil) }
+        assert_nothing_raised { @client.send(:send_message, "request") }
       end
 
       test "#send_notification is a no-op" do
-        assert_nothing_raised { @client.send(:send_notification, "request", nil) }
+        assert_nothing_raised { @client.send(:send_notification, "request") }
       end
 
       test "#read_response is a no-op" do