Fallback to NullClient if initializing server fails

Author: vinistock

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -14,7 +14,7 @@ class Addon < ::RubyLsp::Addon
 
       sig { returns(RunnerClient) }
       def client
-        @client ||= T.let(RunnerClient.new, T.nilable(RunnerClient))
+        @client ||= T.let(RunnerClient.create_client, T.nilable(RunnerClient))
       end
 
       sig { override.params(message_queue: Thread::Queue).void }

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -4,13 +4,22 @@
 require "json"
 require "open3"
 
-# NOTE: We should avoid printing to stderr since it causes problems. We never read the standard error pipe
-# from the client, so it will become full and eventually hang or crash.
-# Instead, return a response with an `error` key.
-
 module RubyLsp
   module Rails
     class RunnerClient
+      class << self
+        extend T::Sig
+
+        sig { returns(RunnerClient) }
+        def create_client
+          new
+        rescue Errno::ENOENT, StandardError => e # rubocop:disable Lint/ShadowedException
+          warn("Ruby LSP Rails failed to initialize server: #{e.message}")
+          warn("Server dependent features will not be available")
+          NullClient.new
+        end
+      end
+
       extend T::Sig
 
       sig { void }
@@ -48,13 +57,18 @@ def stopped?
 
       private
 
-      sig { params(request: T.untyped, params: T.untyped).returns(T.untyped) }
+      sig do
+        params(
+          request: String,
+          params: T.nilable(T::Hash[Symbol, T.untyped]),
+        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      end
       def make_request(request, params = nil)
         send_message(request, params)
         read_response
       end
 
-      sig { params(request: T.untyped, params: T.untyped).void }
+      sig { params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
       def send_message(request, params = nil)
         message = { method: request }
         message[:params] = params if params
@@ -80,5 +94,35 @@ def read_response
         response.fetch(:result)
       end
     end
+
+    class NullClient < RunnerClient
+      extend T::Sig
+
+      sig { void }
+      def initialize # rubocop:disable Lint/MissingSuper
+      end
+
+      sig { override.void }
+      def shutdown
+        # no-op
+      end
+
+      sig { override.returns(T::Boolean) }
+      def stopped?
+        true
+      end
+
+      private
+
+      sig { override.params(request: String, params: T.nilable(T::Hash[Symbol, T.untyped])).void }
+      def send_message(request, params = nil)
+        # no-op
+      end
+
+      sig { override.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def read_response
+        # no-op
+      end
+    end
   end
 end

lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -19,6 +19,9 @@
   nil
 end
 
+# NOTE: We should avoid printing to stderr since it causes problems. We never read the standard error pipe from the
+# client, so it will become full and eventually hang or crash. Instead, return a response with an `error` key.
+
 module RubyLsp
   module Rails
     class Server

test/ruby_lsp_rails/runner_client_test.rb

@@ -36,6 +36,20 @@ class RunnerClientTest < ActiveSupport::TestCase
       test "returns nil if the request returns a nil response" do
         assert_nil @client.model("ApplicationRecord") # ApplicationRecord is abstract
       end
+
+      test "failing to spawn server creates a null client" do
+        FileUtils.mv("bin/rails", "bin/rails_backup")
+
+        assert_output("", %r{No such file or directory - bin/rails}) do
+          client = RunnerClient.create_client
+
+          assert_instance_of(NullClient, client)
+          assert_nil(client.model("User"))
+          assert_predicate(client, :stopped?)
+        end
+      ensure
+        FileUtils.mv("bin/rails_backup", "bin/rails")
+      end
     end
   end
 end