language_server-protocol 3.15.0.2 → 3.16.0.0

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

@@ -0,0 +1,42 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class OptionalVersionedTextDocumentIdentifier < TextDocumentIdentifier
+        def initialize(uri:, version:)
+          @attributes = {}
+
+          @attributes[:uri] = uri
+          @attributes[:version] = version
+
+          @attributes.freeze
+        end
+
+        #
+        # The version number of this document. If an optional versioned text document
+        # identifier is sent from the server to the client and the file is not
+        # open in the editor (the server has not received an open notification
+        # before) the server can send `null` to indicate that the version is
+        # known and the content on disk is the master (as specified with document
+        # content ownership).
+        #
+        # The version number of a document will increase after each change,
+        # including undo/redo. The number doesn't need to be consecutive.
+        #
+        # @return [number]
+        def version
+          attributes.fetch(:version)
+        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/parameter_information.rb

@@ -18,12 +18,14 @@ module LanguageServer
         #
         # The label of this parameter information.
         #
-        # Either a string or an inclusive start and exclusive end offsets within its containing
-        # signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
-        # string representation as `Position` and `Range` does.
+        # Either a string or an inclusive start and exclusive end offsets within
+        # its containing signature label. (see SignatureInformation.label). The
+        # offsets are based on a UTF-16 string representation as `Position` and
+        # `Range` does.
         #
-        # *Note*: a label of type string should be a substring of its containing signature label.
-        # Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+        # *Note*: a label of type string should be a substring of its containing
+        # signature label. Its intended use case is to highlight the parameter
+        # label part in the `SignatureInformation.label`.
         #
         # @return [string | [number, number]]
         def label

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

@@ -11,10 +11,10 @@ module LanguageServer
         end
 
         #
-        # An optional token that a server can use to report partial results (e.g. streaming) to
-        # the client.
+        # An optional token that a server can use to report partial results (e.g.
+        # streaming) to the client.
         #
-        # @return [string | number]
+        # @return [ProgressToken]
         def partial_result_token
           attributes.fetch(:partialResultToken)
         end

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

@@ -20,12 +20,12 @@ module LanguageServer
         end
 
         #
-        # Character offset on a line in a document (zero-based). Assuming that the line is
-        # represented as a string, the `character` value represents the gap between the
-        # `character` and `character + 1`.
+        # Character offset on a line in a document (zero-based). Assuming that
+        # the line is represented as a string, the `character` value represents
+        # the gap between the `character` and `character + 1`.
         #
-        # If the character value is greater than the line length it defaults back to the
-        # line length.
+        # If the character value is greater than the line length it defaults back
+        # to the line length.
         #
         # @return [number]
         def character

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

@@ -14,7 +14,7 @@ module LanguageServer
         #
         # The progress token provided by the client or server.
         #
-        # @return [string | number]
+        # @return [ProgressToken]
         def token
           attributes.fetch(:token)
         end

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

@@ -2,12 +2,14 @@ module LanguageServer
   module Protocol
     module Interface
       class PublishDiagnosticsClientCapabilities
-        def initialize(related_information: nil, tag_support: nil, version_support: nil)
+        def initialize(related_information: nil, tag_support: nil, version_support: nil, code_description_support: nil, data_support: nil)
           @attributes = {}
 
           @attributes[:relatedInformation] = related_information if related_information
           @attributes[:tagSupport] = tag_support if tag_support
           @attributes[:versionSupport] = version_support if version_support
+          @attributes[:codeDescriptionSupport] = code_description_support if code_description_support
+          @attributes[:dataSupport] = data_support if data_support
 
           @attributes.freeze
         end
@@ -38,6 +40,24 @@ module LanguageServer
           attributes.fetch(:versionSupport)
         end
 
+        #
+        # Client supports a codeDescription property
+        #
+        # @return [boolean]
+        def code_description_support
+          attributes.fetch(:codeDescriptionSupport)
+        end
+
+        #
+        # Whether code action supports the `data` property which is
+        # preserved between a `textDocument/publishDiagnostics` and
+        # `textDocument/codeAction` request.
+        #
+        # @return [boolean]
+        def data_support
+          attributes.fetch(:dataSupport)
+        end
+
         attr_reader :attributes
 
         def to_hash

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

@@ -21,7 +21,8 @@ module LanguageServer
         end
 
         #
-        # Optional the version number of the document the diagnostics are published for.
+        # Optional the version number of the document the diagnostics are published
+        # for.
         #
         # @return [number]
         def version

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

@@ -0,0 +1,45 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Client capabilities specific to regular expressions.
+      #
+      class RegularExpressionsClientCapabilities
+        def initialize(engine:, version: nil)
+          @attributes = {}
+
+          @attributes[:engine] = engine
+          @attributes[:version] = version if version
+
+          @attributes.freeze
+        end
+
+        #
+        # The engine's name.
+        #
+        # @return [string]
+        def engine
+          attributes.fetch(:engine)
+        end
+
+        #
+        # The engine's version.
+        #
+        # @return [string]
+        def version
+          attributes.fetch(:version)
+        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/rename_client_capabilities.rb

@@ -2,11 +2,13 @@ module LanguageServer
   module Protocol
     module Interface
       class RenameClientCapabilities
-        def initialize(dynamic_registration: nil, prepare_support: nil)
+        def initialize(dynamic_registration: nil, prepare_support: nil, prepare_support_default_behavior: nil, honors_change_annotations: nil)
           @attributes = {}
 
           @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
           @attributes[:prepareSupport] = prepare_support if prepare_support
+          @attributes[:prepareSupportDefaultBehavior] = prepare_support_default_behavior if prepare_support_default_behavior
+          @attributes[:honorsChangeAnnotations] = honors_change_annotations if honors_change_annotations
 
           @attributes.freeze
         end
@@ -28,6 +30,30 @@ module LanguageServer
           attributes.fetch(:prepareSupport)
         end
 
+        #
+        # Client supports the default behavior result
+        # (`{ defaultBehavior: boolean }`).
+        #
+        # The value indicates the default behavior used by the
+        # client.
+        #
+        # @return [any]
+        def prepare_support_default_behavior
+          attributes.fetch(:prepareSupportDefaultBehavior)
+        end
+
+        #
+        # Whether th client honors the change annotations in
+        # text edits and resource operations returned via the
+        # rename request's workspace edit by for example presenting
+        # the workspace edit in the user interface and asking
+        # for confirmation.
+        #
+        # @return [boolean]
+        def honors_change_annotations
+          attributes.fetch(:honorsChangeAnnotations)
+        end
+
         attr_reader :attributes
 
         def to_hash

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

@@ -5,13 +5,14 @@ module LanguageServer
       # Rename file operation
       #
       class RenameFile
-        def initialize(kind:, old_uri:, new_uri:, options: nil)
+        def initialize(kind:, old_uri:, new_uri:, options: nil, annotation_id: nil)
           @attributes = {}
 
           @attributes[:kind] = kind
           @attributes[:oldUri] = old_uri
           @attributes[:newUri] = new_uri
           @attributes[:options] = options if options
+          @attributes[:annotationId] = annotation_id if annotation_id
 
           @attributes.freeze
         end
@@ -48,6 +49,14 @@ module LanguageServer
           attributes.fetch(:options)
         end
 
+        #
+        # An optional annotation identifer describing the operation.
+        #
+        # @return [string]
+        def annotation_id
+          attributes.fetch(:annotationId)
+        end
+
         attr_reader :attributes
 
         def to_hash

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

@@ -0,0 +1,38 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # The parameters sent in notifications/requests for user-initiated renames
+      # of files.
+      #
+      class RenameFilesParams
+        def initialize(files:)
+          @attributes = {}
+
+          @attributes[:files] = files
+
+          @attributes.freeze
+        end
+
+        #
+        # An array of all files/folders renamed in this operation. When a folder
+        # is renamed, only the folder will be included, and not its children.
+        #
+        # @return [FileRename[]]
+        def files
+          attributes.fetch(:files)
+        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.rb

@@ -20,7 +20,8 @@ module LanguageServer
         end
 
         #
-        # The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
+        # The parent selection range containing this range. Therefore
+        # `parent.range` must contain `this.range`.
         #
         # @return [SelectionRange]
         def parent

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

@@ -11,9 +11,10 @@ module LanguageServer
         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.
+        # 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

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