Add support for server addons

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,20 +28,32 @@ def initialize
         # the real client is initialized, features that depend on it will not be blocked by using the NullClient
         @rails_runner_client = T.let(NullClient.new, RunnerClient)
         @global_state = T.let(nil, T.nilable(GlobalState))
+        @addon_mutex = T.let(Mutex.new, Mutex)
+        @client_mutex = T.let(Mutex.new, Mutex)
+        @client_mutex.lock
+
+        Thread.new do
+          @addon_mutex.synchronize do
+            # We need to ensure the Rails client is fully loaded before we activate the server addons
+            @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client }
+          end
+        end
       end
 
       sig { returns(RunnerClient) }
-      attr_reader :rails_runner_client
+      def rails_runner_client
+        @addon_mutex.synchronize { @rails_runner_client }
+      end
 
       sig { override.params(global_state: GlobalState, message_queue: Thread::Queue).void }
       def activate(global_state, message_queue)
         @global_state = global_state
         $stderr.puts("Activating Ruby LSP Rails addon v#{VERSION}")
-        # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
-        Thread.new { @rails_runner_client = RunnerClient.create_client }
         register_additional_file_watchers(global_state: global_state, message_queue: message_queue)
-
         @global_state.index.register_enhancement(IndexingEnhancement.new)
+
+        # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
+        @client_mutex.unlock
       end
 
       sig { override.void }

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -96,6 +96,14 @@ def initialize
         raise InitializationError, @stderr.read
       end
 
+      sig { params(server_addon_path: String).void }
+      def register_server_addon(server_addon_path)
+        send_notification("server_addon/register", server_addon_path: server_addon_path)
+      rescue IncompleteMessageError
+        $stderr.puts("Ruby LSP Rails failed to register server addon #{server_addon_path}")
+        nil
+      end
+
       sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def model(name)
         make_request("model", name: name)

lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -8,6 +8,41 @@
 
 module RubyLsp
   module Rails
+    class ServerAddon
+      @server_addon_classes = []
+      @server_addons = {}
+
+      class << self
+        # We keep track of runtime server addons the same way we track other addons, by storing classes that inherit
+        # from the base one
+        def inherited(child)
+          @server_addon_classes << child
+          super
+        end
+
+        # Delegate `request` with `params` to the server addon with the given `name`
+        def delegate(name, request, params)
+          @server_addons[name]&.execute(request, params)
+        end
+
+        # Instantiate all server addons and store them in a hash for easy access after we have discovered the classes
+        def finalize_registrations!
+          until @server_addon_classes.empty?
+            addon = @server_addon_classes.shift.new
+            @server_addons[addon.name] = addon
+          end
+        end
+      end
+
+      def name
+        raise NotImplementedError, "Not implemented!"
+      end
+
+      def execute(request, params)
+        raise NotImplementedError, "Not implemented!"
+      end
+    end
+
     class Server
       def initialize(stdout: $stdout, override_default_output_device: true)
         # Grab references to the original pipes so that we can change the default output device further down
@@ -60,6 +95,13 @@ def execute(request, params)
           write_response(route_location(params.fetch(:name)))
         when "route_info"
           write_response(resolve_route_info(params))
+        when "server_addon/register"
+          require params[:server_addon_path]
+          ServerAddon.finalize_registrations!
+        when "server_addon/delegate"
+          server_addon_name = params.delete(:server_addon_name)
+          request_name = params.delete(:request_name)
+          write_response(ServerAddon.delegate(server_addon_name, request_name, params))
         end
       rescue => e
         write_response({ error: e.full_message(highlight: false) })

test/ruby_lsp_rails/server_test.rb

@@ -136,6 +136,27 @@ def <(other)
     assert_equal "/users(.:format)", result[:path]
   end
 
+  test "server addons" do
+    File.write("server_addon.rb", <<~RUBY)
+      class TapiocaServerAddon < RubyLsp::Rails::ServerAddon
+        def name
+          "Tapioca"
+        end
+
+        def execute(request, params)
+          { request:, params: }
+        end
+      end
+    RUBY
+
+    @server.execute("server_addon/register", server_addon_path: File.expand_path("server_addon.rb"))
+
+    @server.execute("server_addon/delegate", server_addon_name: "Tapioca", request_name: "dsl")
+    assert_equal(response, { params: {}, request: "dsl" })
+  ensure
+    FileUtils.rm("server_addon.rb")
+  end
+
   test "prints in the Rails application or server are automatically redirected to stderr" do
     stdout = StringIO.new
     server = RubyLsp::Rails::Server.new(stdout: stdout)