language_server-protocol 3.15.0.1 → 3.16.0.2

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

@@ -2,13 +2,15 @@ module LanguageServer
   module Protocol
     module Interface
       #
-      # A `MarkupContent` literal represents a string value which content is interpreted base on its
-      # kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
+      # A `MarkupContent` literal represents a string value which content is
+      # interpreted base on its kind flag. Currently the protocol supports
+      # `plaintext` and `markdown` as markup kinds.
       #
-      # If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
-      # See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+      # If the kind is `markdown` then the value can contain fenced code blocks like
+      # in GitHub issues.
       #
-      # Here is an example how such a string can be constructed using JavaScript / TypeScript:
+      # Here is an example how such a string can be constructed using
+      # JavaScript / TypeScript:
       # ```typescript
       # let markdown: MarkdownContent = {
       # kind: MarkupKind.Markdown,
@@ -22,8 +24,8 @@ module LanguageServer
       # };
       # ```
       #
-      # *Please Note* that clients might sanitize the return markdown. A client could decide to
-      # remove HTML from the markdown to avoid script execution.
+      # *Please Note* that clients might sanitize the return markdown. A client could
+      # decide to remove HTML from the markdown to avoid script execution.
       #
       class MarkupContent
         def initialize(kind:, value:)

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

@@ -0,0 +1,64 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Moniker definition to match LSIF 0.5 moniker definition.
+      #
+      class Moniker
+        def initialize(scheme:, identifier:, unique:, kind: nil)
+          @attributes = {}
+
+          @attributes[:scheme] = scheme
+          @attributes[:identifier] = identifier
+          @attributes[:unique] = unique
+          @attributes[:kind] = kind if kind
+
+          @attributes.freeze
+        end
+
+        #
+        # The scheme of the moniker. For example tsc or .Net
+        #
+        # @return [string]
+        def scheme
+          attributes.fetch(:scheme)
+        end
+
+        #
+        # The identifier of the moniker. The value is opaque in LSIF however
+        # schema owners are allowed to define the structure if they want.
+        #
+        # @return [string]
+        def identifier
+          attributes.fetch(:identifier)
+        end
+
+        #
+        # The scope in which the moniker is unique
+        #
+        # @return [UniquenessLevel]
+        def unique
+          attributes.fetch(:unique)
+        end
+
+        #
+        # The moniker kind if known.
+        #
+        # @return [MonikerKind]
+        def kind
+          attributes.fetch(:kind)
+        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/moniker_client_capabilities.rb

@@ -0,0 +1,36 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class MonikerClientCapabilities
+        def initialize(dynamic_registration: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+
+          @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
+
+        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/moniker_options.rb

@@ -0,0 +1,30 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class MonikerOptions
+        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/moniker_params.rb

@@ -0,0 +1,61 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class MonikerParams
+        def initialize(text_document:, position:, work_done_token: nil, partial_result_token: nil)
+          @attributes = {}
+
+          @attributes[:textDocument] = text_document
+          @attributes[:position] = position
+          @attributes[:workDoneToken] = work_done_token if work_done_token
+          @attributes[:partialResultToken] = partial_result_token if partial_result_token
+
+          @attributes.freeze
+        end
+
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The position inside the text document.
+        #
+        # @return [Position]
+        def position
+          attributes.fetch(:position)
+        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
+
+        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/moniker_registration_options.rb

@@ -0,0 +1,40 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class MonikerRegistrationOptions
+        def initialize(document_selector:, work_done_progress: nil)
+          @attributes = {}
+
+          @attributes[:documentSelector] = document_selector
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+
+          @attributes.freeze
+        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
+
+        # @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/notification_message.rb

@@ -1,7 +1,7 @@
 module LanguageServer
   module Protocol
     module Interface
-      class NotificationMessage < Message
+      class NotificationMessage
         def initialize(jsonrpc:, method:, params: nil)
           @attributes = {}
 
@@ -12,6 +12,11 @@ module LanguageServer
           @attributes.freeze
         end
 
+        # @return [string]
+        def jsonrpc
+          attributes.fetch(:jsonrpc)
+        end
+
         #
         # The method to be invoked.
         #

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

@@ -0,0 +1,50 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class OptionalVersionedTextDocumentIdentifier
+        def initialize(uri:, version:)
+          @attributes = {}
+
+          @attributes[:uri] = uri
+          @attributes[:version] = version
+
+          @attributes.freeze
+        end
+
+        #
+        # The text document's URI.
+        #
+        # @return [string]
+        def uri
+          attributes.fetch(:uri)
+        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/prepare_rename_params.rb

@@ -1,7 +1,7 @@
 module LanguageServer
   module Protocol
     module Interface
-      class PrepareRenameParams < TextDocumentPositionParams
+      class PrepareRenameParams
         def initialize(text_document:, position:)
           @attributes = {}
 
@@ -11,6 +11,22 @@ module LanguageServer
           @attributes.freeze
         end
 
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The position inside the text document.
+        #
+        # @return [Position]
+        def position
+          attributes.fetch(:position)
+        end
+
         attr_reader :attributes
 
         def to_hash

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