language_server-protocol 3.14.0.2 → 3.16.0.1

data/lib/language_server/protocol/interface/request_message.rb

@@ -1,7 +1,7 @@
 module LanguageServer
   module Protocol
     module Interface
-      class RequestMessage < Message
+      class RequestMessage
         def initialize(jsonrpc:, id:, method:, params: nil)
           @attributes = {}
 
@@ -13,6 +13,11 @@ module LanguageServer
           @attributes.freeze
         end
 
+        # @return [string]
+        def jsonrpc
+          attributes.fetch(:jsonrpc)
+        end
+
         #
         # The request id.
         #
@@ -32,7 +37,7 @@ module LanguageServer
         #
         # The method's params.
         #
-        # @return [object | any[]]
+        # @return [any]
         def params
           attributes.fetch(:params)
         end

data/lib/language_server/protocol/interface/response_error.rb

@@ -29,10 +29,10 @@ module LanguageServer
         end
 
         #
-        # A Primitive or Structured value that contains additional
+        # A primitive or structured value that contains additional
         # information about the error. Can be omitted.
         #
-        # @return [D]
+        # @return [any]
         def data
           attributes.fetch(:data)
         end

data/lib/language_server/protocol/interface/response_message.rb

@@ -1,7 +1,7 @@
 module LanguageServer
   module Protocol
     module Interface
-      class ResponseMessage < Message
+      class ResponseMessage
         def initialize(jsonrpc:, id:, result: nil, error: nil)
           @attributes = {}
 
@@ -13,6 +13,11 @@ module LanguageServer
           @attributes.freeze
         end
 
+        # @return [string]
+        def jsonrpc
+          attributes.fetch(:jsonrpc)
+        end
+
         #
         # The request id.
         #
@@ -22,10 +27,10 @@ module LanguageServer
         end
 
         #
-        # The result of a request. This can be omitted in
-        # the case of an error.
+        # The result of a request. This member is REQUIRED on success.
+        # This member MUST NOT exist if there was an error invoking the method.
         #
-        # @return [any]
+        # @return [string | number | boolean | object]
         def result
           attributes.fetch(:result)
         end
@@ -33,7 +38,7 @@ module LanguageServer
         #
         # The error object in case a request fails.
         #
-        # @return [ResponseError<any>]
+        # @return [ResponseError]
         def error
           attributes.fetch(:error)
         end

data/lib/language_server/protocol/interface/save_options.rb

@@ -1,9 +1,6 @@
 module LanguageServer
   module Protocol
     module Interface
-      #
-      # Save options.
-      #
       class SaveOptions
         def initialize(include_text: nil)
           @attributes = {}

data/lib/language_server/protocol/interface/selection_range.rb

@@ -0,0 +1,43 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SelectionRange
+        def initialize(range:, parent: nil)
+          @attributes = {}
+
+          @attributes[:range] = range
+          @attributes[:parent] = parent if parent
+
+          @attributes.freeze
+        end
+
+        #
+        # The [range](#Range) of this selection range.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # The parent selection range containing this range. Therefore
+        # `parent.range` must contain `this.range`.
+        #
+        # @return [SelectionRange]
+        def parent
+          attributes.fetch(:parent)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/selection_range_client_capabilities.rb

@@ -0,0 +1,36 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SelectionRangeClientCapabilities
+        def initialize(dynamic_registration: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether implementation supports dynamic registration for selection range
+        # providers. If this is set to `true` the client supports the new
+        # `SelectionRangeRegistrationOptions` return value for the corresponding
+        # server capability as well.
+        #
+        # @return [boolean]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/selection_range_options.rb

@@ -0,0 +1,30 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SelectionRangeOptions
+        def initialize(work_done_progress: nil)
+          @attributes = {}
+
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+
+          @attributes.freeze
+        end
+
+        # @return [boolean]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/selection_range_params.rb

@@ -0,0 +1,61 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SelectionRangeParams
+        def initialize(work_done_token: nil, partial_result_token: nil, text_document:, positions:)
+          @attributes = {}
+
+          @attributes[:workDoneToken] = work_done_token if work_done_token
+          @attributes[:partialResultToken] = partial_result_token if partial_result_token
+          @attributes[:textDocument] = text_document
+          @attributes[:positions] = positions
+
+          @attributes.freeze
+        end
+
+        #
+        # An optional token that a server can use to report work done progress.
+        #
+        # @return [ProgressToken]
+        def work_done_token
+          attributes.fetch(:workDoneToken)
+        end
+
+        #
+        # An optional token that a server can use to report partial results (e.g.
+        # streaming) to the client.
+        #
+        # @return [ProgressToken]
+        def partial_result_token
+          attributes.fetch(:partialResultToken)
+        end
+
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The positions inside the text document.
+        #
+        # @return [Position[]]
+        def positions
+          attributes.fetch(:positions)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/selection_range_registration_options.rb

@@ -0,0 +1,50 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SelectionRangeRegistrationOptions
+        def initialize(work_done_progress: nil, document_selector:, id: nil)
+          @attributes = {}
+
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+          @attributes[:documentSelector] = document_selector
+          @attributes[:id] = id if id
+
+          @attributes.freeze
+        end
+
+        # @return [boolean]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
+        #
+        # A document selector to identify the scope of the registration. If set to
+        # null the document selector provided on the client side will be used.
+        #
+        # @return [DocumentSelector]
+        def document_selector
+          attributes.fetch(:documentSelector)
+        end
+
+        #
+        # The id used to register the request. The id can be used to deregister
+        # the request again. See also Registration#id.
+        #
+        # @return [string]
+        def id
+          attributes.fetch(:id)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/semantic_tokens.rb

@@ -0,0 +1,45 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SemanticTokens
+        def initialize(result_id: nil, data:)
+          @attributes = {}
+
+          @attributes[:resultId] = result_id if result_id
+          @attributes[:data] = data
+
+          @attributes.freeze
+        end
+
+        #
+        # An optional result id. If provided and clients support delta updating
+        # the client will include the result id in the next semantic token request.
+        # A server can then instead of computing all semantic tokens again simply
+        # send a delta.
+        #
+        # @return [string]
+        def result_id
+          attributes.fetch(:resultId)
+        end
+
+        #
+        # The actual tokens.
+        #
+        # @return [number[]]
+        def data
+          attributes.fetch(:data)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interface/semantic_tokens_client_capabilities.rb

@@ -0,0 +1,97 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class SemanticTokensClientCapabilities
+        def initialize(dynamic_registration: nil, requests:, token_types:, token_modifiers:, formats:, overlapping_token_support: nil, multiline_token_support: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+          @attributes[:requests] = requests
+          @attributes[:tokenTypes] = token_types
+          @attributes[:tokenModifiers] = token_modifiers
+          @attributes[:formats] = formats
+          @attributes[:overlappingTokenSupport] = overlapping_token_support if overlapping_token_support
+          @attributes[:multilineTokenSupport] = multiline_token_support if multiline_token_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether implementation supports dynamic registration. If this is set to
+        # `true` the client supports the new `(TextDocumentRegistrationOptions &
+        # StaticRegistrationOptions)` return value for the corresponding server
+        # capability as well.
+        #
+        # @return [boolean]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        #
+        # Which requests the client supports and might send to the server
+        # depending on the server's capability. Please note that clients might not
+        # show semantic tokens or degrade some of the user experience if a range
+        # or full request is advertised by the client but not provided by the
+        # server. If for example the client capability `requests.full` and
+        # `request.range` are both set to true but the server only provides a
+        # range provider the client might not render a minimap correctly or might
+        # even decide to not show any semantic tokens at all.
+        #
+        # @return [{ range?: boolean | {}; full?: boolean | { delta?: boolean; }; }]
+        def requests
+          attributes.fetch(:requests)
+        end
+
+        #
+        # The token types that the client supports.
+        #
+        # @return [string[]]
+        def token_types
+          attributes.fetch(:tokenTypes)
+        end
+
+        #
+        # The token modifiers that the client supports.
+        #
+        # @return [string[]]
+        def token_modifiers
+          attributes.fetch(:tokenModifiers)
+        end
+
+        #
+        # The formats the clients supports.
+        #
+        # @return ["relative"[]]
+        def formats
+          attributes.fetch(:formats)
+        end
+
+        #
+        # Whether the client supports tokens that can overlap each other.
+        #
+        # @return [boolean]
+        def overlapping_token_support
+          attributes.fetch(:overlappingTokenSupport)
+        end
+
+        #
+        # Whether the client supports tokens that can span multiple lines.
+        #
+        # @return [boolean]
+        def multiline_token_support
+          attributes.fetch(:multilineTokenSupport)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end