ruby-lsp-rails 0.3.31 → 0.4.8

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -8,12 +8,10 @@ module RubyLsp
   module Rails
     class RunnerClient
       class << self
-        extend T::Sig
-
-        sig { params(outgoing_queue: Thread::Queue).returns(RunnerClient) }
-        def create_client(outgoing_queue)
+        #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> RunnerClient
+        def create_client(outgoing_queue, global_state)
           if File.exist?("bin/rails")
-            new(outgoing_queue)
+            new(outgoing_queue, global_state)
           else
             unless outgoing_queue.closed?
               outgoing_queue << RubyLsp::Notification.window_log_message(
@@ -46,15 +44,13 @@ module RubyLsp
       class MessageError < StandardError; end
       class EmptyMessageError < MessageError; end
 
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :rails_root
 
-      sig { params(outgoing_queue: Thread::Queue).void }
-      def initialize(outgoing_queue)
-        @outgoing_queue = T.let(outgoing_queue, Thread::Queue)
-        @mutex = T.let(Mutex.new, Mutex)
+      #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> void
+      def initialize(outgoing_queue, global_state)
+        @outgoing_queue = outgoing_queue #: Thread::Queue
+        @mutex = Mutex.new #: Mutex
         # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
         # parent ends, the spring process ends as well. If this is not set, Spring will throw an error while trying to
         # set its own session ID
@@ -71,24 +67,32 @@ module RubyLsp
         log_message("Ruby LSP Rails booting server")
 
         stdin, stdout, stderr, wait_thread = Bundler.with_original_env do
-          Open3.popen3("bundle", "exec", "rails", "runner", "#{__dir__}/server.rb", "start")
+          Open3.popen3(
+            "bundle",
+            "exec",
+            "rails",
+            "runner",
+            "#{__dir__}/server.rb",
+            "start",
+            server_relevant_capabilities(global_state),
+          )
         end
 
-        @stdin = T.let(stdin, IO)
-        @stdout = T.let(stdout, IO)
-        @stderr = T.let(stderr, IO)
+        @stdin = stdin #: IO
+        @stdout = stdout #: IO
+        @stderr = stderr #: IO
         @stdin.sync = true
         @stdout.sync = true
         @stderr.sync = true
-        @wait_thread = T.let(wait_thread, Process::Waiter)
+        @wait_thread = wait_thread #: Process::Waiter
 
         # We set binmode for Windows compatibility
         @stdin.binmode
         @stdout.binmode
         @stderr.binmode
 
-        initialize_response = T.must(read_response)
-        @rails_root = T.let(initialize_response[:root], String)
+        initialize_response = read_response #: as !nil
+        @rails_root = initialize_response[:root] #: String
         log_message("Finished booting Ruby LSP Rails server")
 
         unless ENV["RAILS_ENV"] == "test"
@@ -100,21 +104,24 @@ module RubyLsp
           end
         end
 
-        @logger_thread = T.let(
-          Thread.new do
-            while (content = @stderr.gets("\n"))
-              log_message(content, type: RubyLsp::Constant::MessageType::LOG)
+        # Responsible for transmitting notifications coming from the server to the outgoing queue, so that we can do
+        # things such as showing progress notifications initiated by the server
+        @notifier_thread = Thread.new do
+          until @stderr.closed?
+            notification = read_notification
+
+            unless @outgoing_queue.closed? || !notification
+              @outgoing_queue << notification
             end
-          rescue IOError
-            # The server was shutdown and stderr is already closed
-          end,
-          Thread,
-        )
+          end
+        rescue IOError
+          # The server was shutdown and stderr is already closed
+        end #: Thread
       rescue StandardError
         raise InitializationError, @stderr.read
       end
 
-      sig { params(server_addon_path: String).void }
+      #: (String server_addon_path) -> void
       def register_server_addon(server_addon_path)
         send_notification("server_addon/register", server_addon_path: server_addon_path)
       rescue MessageError
@@ -125,7 +132,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (String name) -> Hash[Symbol, untyped]?
       def model(name)
         make_request("model", name: name)
       rescue MessageError
@@ -136,15 +143,10 @@ module RubyLsp
         nil
       end
 
-      sig do
-        params(
-          model_name: String,
-          association_name: String,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
-      end
-      def association_target_location(model_name:, association_name:)
+      #: (model_name: String, association_name: String) -> Hash[Symbol, untyped]?
+      def association_target(model_name:, association_name:)
         make_request(
-          "association_target_location",
+          "association_target",
           model_name: model_name,
           association_name: association_name,
         )
@@ -156,7 +158,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (String name) -> Hash[Symbol, untyped]?
       def route_location(name)
         make_request("route_location", name: name)
       rescue MessageError
@@ -167,7 +169,7 @@ module RubyLsp
         nil
       end
 
-      sig { params(controller: String, action: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: (controller: String, action: String) -> Hash[Symbol, untyped]?
       def route(controller:, action:)
         make_request("route_info", controller: controller, action: action)
       rescue MessageError
@@ -179,7 +181,7 @@ module RubyLsp
       end
 
       # Delegates a notification to a server add-on
-      sig { params(server_addon_name: String, request_name: String, params: T.untyped).void }
+      #: (server_addon_name: String, request_name: String, **untyped params) -> void
       def delegate_notification(server_addon_name:, request_name:, **params)
         send_notification(
           "server_addon/delegate",
@@ -189,7 +191,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def pending_migrations_message
         response = make_request("pending_migrations_message")
         response[:pending_migrations_message] if response
@@ -201,7 +203,7 @@ module RubyLsp
         nil
       end
 
-      sig { returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      #: -> Hash[Symbol, untyped]?
       def run_migrations
         make_request("run_migrations")
       rescue MessageError
@@ -213,13 +215,7 @@ module RubyLsp
       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
+      #: (server_addon_name: String, request_name: String, **untyped params) -> Hash[Symbol, untyped]?
       def delegate_request(server_addon_name:, request_name:, **params)
         make_request(
           "server_addon/delegate",
@@ -231,7 +227,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def trigger_reload
         log_message("Reloading Rails application")
         send_notification("reload")
@@ -243,7 +239,7 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def shutdown
         log_message("Ruby LSP Rails shutting down server")
         send_message("shutdown")
@@ -254,29 +250,30 @@ module RubyLsp
         force_kill
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def stopped?
         [@stdin, @stdout, @stderr].all?(&:closed?) && !@wait_thread.alive?
       end
 
-      sig do
-        params(
-          request: String,
-          params: T.untyped,
-        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
+      #: -> bool
+      def connected?
+        true
       end
+
+      private
+
+      #: (String request, **untyped params) -> Hash[Symbol, untyped]?
       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.untyped).void }
+      #: (String request, **untyped params) -> void
       def send_notification(request, **params) = send_message(request, **params)
 
-      private
-
-      sig { overridable.params(request: String, params: T.untyped).void }
+      # @overridable
+      #: (String request, **untyped params) -> void
       def send_message(request, **params)
         message = { method: request }
         message[:params] = params
@@ -289,7 +286,8 @@ module RubyLsp
         # The server connection died
       end
 
-      sig { overridable.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      # @overridable
+      #: -> Hash[Symbol, untyped]?
       def read_response
         raw_response = @mutex.synchronize do
           content_length = read_content_length
@@ -297,9 +295,9 @@ module RubyLsp
           raise EmptyMessageError unless content_length
 
           @stdout.read(content_length)
-        end
+        end #: as !nil
 
-        response = JSON.parse(T.must(raw_response), symbolize_names: true)
+        response = JSON.parse(raw_response, symbolize_names: true)
 
         if response[:error]
           log_message(
@@ -315,20 +313,23 @@ module RubyLsp
         nil
       end
 
-      sig { void }
+      #: -> void
       def force_kill
         # Windows does not support the `TERM` signal, so we're forced to use `KILL` here
-        Process.kill(T.must(Signal.list["KILL"]), @wait_thread.pid)
+        Process.kill(
+          Signal.list["KILL"], #: as !nil
+          @wait_thread.pid,
+        )
       end
 
-      sig { params(message: ::String, type: ::Integer).void }
+      #: (::String message, ?type: ::Integer) -> void
       def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         return if @outgoing_queue.closed?
 
         @outgoing_queue << RubyLsp::Notification.window_log_message(message, type: type)
       end
 
-      sig { returns(T.nilable(Integer)) }
+      #: -> Integer?
       def read_content_length
         headers = @stdout.gets("\r\n\r\n")
         return unless headers
@@ -338,43 +339,73 @@ module RubyLsp
 
         length.to_i
       end
+
+      # Read a server notification from stderr. Only intended to be used by notifier thread
+      #: -> Hash[Symbol, untyped]?
+      def read_notification
+        headers = @stderr.gets("\r\n\r\n")
+        return unless headers
+
+        length = headers[/Content-Length: (\d+)/i, 1]
+        return unless length
+
+        raw_content = @stderr.read(length.to_i)
+        return unless raw_content
+
+        JSON.parse(raw_content, symbolize_names: true)
+      end
+
+      #: (GlobalState global_state) -> String
+      def server_relevant_capabilities(global_state)
+        {
+          supports_progress: global_state.client_capabilities.supports_progress,
+        }.to_json
+      end
     end
 
     class NullClient < RunnerClient
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize # rubocop:disable Lint/MissingSuper
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def shutdown
         # no-op
       end
 
-      sig { override.returns(T::Boolean) }
+      # @override
+      #: -> bool
       def stopped?
         true
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def rails_root
         Dir.pwd
       end
 
+      #: -> bool
+      def connected?
+        false
+      end
+
       private
 
-      sig { params(message: ::String, type: ::Integer).void }
+      #: (::String message, ?type: ::Integer) -> void
       def log_message(message, type: RubyLsp::Constant::MessageType::LOG)
         # no-op
       end
 
-      sig { override.params(request: String, params: T.untyped).void }
+      # @override
+      #: (String request, **untyped params) -> void
       def send_message(request, **params)
         # no-op
       end
 
-      sig { override.returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      # @override
+      #: -> Hash[Symbol, untyped]?
       def read_response
         # no-op
       end