lib/ruby_lsp/utils.rb in ruby-lsp-0.14.6 vs lib/ruby_lsp/utils.rb in ruby-lsp-0.15.0

@@ -1,11 +1,16 @@
 # typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
+  # rubocop:disable RubyLsp/UseLanguageServerAliases
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+  Transport = LanguageServer::Protocol::Transport
+  # rubocop:enable RubyLsp/UseLanguageServerAliases
+
   # Used to indicate that a request shouldn't return a response
-  VOID = T.let(Object.new.freeze, Object)
   BUNDLE_PATH = T.let(
     begin
       Bundler.bundle_path.to_s
     rescue Bundler::GemfileNotFound
       nil
@@ -24,78 +29,108 @@
   # A notification to be sent to the client
   class Message
     extend T::Sig
     extend T::Helpers
 
-    abstract!
-
     sig { returns(String) }
-    attr_reader :message
+    attr_reader :method
 
     sig { returns(Object) }
     attr_reader :params
 
-    sig { params(message: String, params: Object).void }
-    def initialize(message:, params:)
-      @message = message
+    abstract!
+
+    sig { params(method: String, params: Object).void }
+    def initialize(method:, params:)
+      @method = method
       @params = params
     end
+
+    sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
+    def to_hash; end
   end
 
   class Notification < Message
     class << self
       extend T::Sig
       sig { params(message: String).returns(Notification) }
       def window_show_error(message)
         new(
-          message: "window/showMessage",
+          method: "window/showMessage",
           params: Interface::ShowMessageParams.new(
             type: Constant::MessageType::ERROR,
             message: message,
           ),
         )
       end
     end
-  end
 
-  class Request < Message; end
-
-  # The final result of running a request before its IO is finalized
-  class Result
     extend T::Sig
 
-    sig { returns(T.untyped) }
-    attr_reader :response
+    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    def to_hash
+      { method: @method, params: T.unsafe(@params).to_hash }
+    end
+  end
 
-    sig { returns(T.nilable(Exception)) }
-    attr_reader :error
+  class Request < Message
+    extend T::Sig
 
-    sig { params(response: T.untyped, error: T.nilable(Exception)).void }
-    def initialize(response:, error: nil)
-      @response = response
-      @error = error
+    sig { params(id: Integer, method: String, params: Object).void }
+    def initialize(id:, method:, params:)
+      @id = id
+      super(method: method, params: params)
     end
+
+    sig { override.returns(T::Hash[Symbol, T.untyped]) }
+    def to_hash
+      { id: @id, method: @method, params: T.unsafe(@params).to_hash }
+    end
   end
 
-  # A request that will sit in the queue until it's executed
-  class Job
+  class Error
     extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { params(id: Integer, code: Integer, message: String, data: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    def initialize(id:, code:, message:, data: nil)
+      @id = id
+      @code = code
+      @message = message
+      @data = data
+    end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
-    attr_reader :request
+    def to_hash
+      {
+        id: @id,
+        error: {
+          code: @code,
+          message: @message,
+          data: @data,
+        },
+      }
+    end
+  end
 
-    sig { returns(T::Boolean) }
-    attr_reader :cancelled
+  # The final result of running a request before its IO is finalized
+  class Result
+    extend T::Sig
 
-    sig { params(request: T::Hash[Symbol, T.untyped], cancelled: T::Boolean).void }
-    def initialize(request:, cancelled:)
-      @request = request
-      @cancelled = cancelled
+    sig { returns(T.untyped) }
+    attr_reader :response
+
+    sig { params(id: Integer, response: T.untyped).void }
+    def initialize(id:, response:)
+      @id = id
+      @response = response
     end
 
-    sig { void }
-    def cancel
-      @cancelled = true
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_hash
+      { id: @id, result: @response }
     end
   end
 
   # A request configuration, to turn on/off features
   class RequestConfig