language_server-protocol 3.12.0.0 → 3.15.0.1

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

@@ -2,10 +2,11 @@ module LanguageServer
   module Protocol
     module Interface
       class ApplyWorkspaceEditResponse
-        def initialize(applied:)
+        def initialize(applied:, failure_reason: nil)
           @attributes = {}
 
           @attributes[:applied] = applied
+          @attributes[:failureReason] = failure_reason if failure_reason
 
           @attributes.freeze
         end
@@ -18,6 +19,17 @@ module LanguageServer
           attributes.fetch(:applied)
         end
 
+        #
+        # An optional textual description for why the edit was not applied.
+        # This may be used may be used by the server for diagnostic
+        # logging or to provide a suitable error for a request that
+        # triggered the edit.
+        #
+        # @return [string]
+        def failure_reason
+          attributes.fetch(:failureReason)
+        end
+
         attr_reader :attributes
 
         def to_hash

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

@@ -2,11 +2,12 @@ module LanguageServer
   module Protocol
     module Interface
       class ClientCapabilities
-        def initialize(workspace: nil, text_document: nil, experimental: nil)
+        def initialize(workspace: nil, text_document: nil, window: nil, experimental: nil)
           @attributes = {}
 
           @attributes[:workspace] = workspace if workspace
           @attributes[:textDocument] = text_document if text_document
+          @attributes[:window] = window if window
           @attributes[:experimental] = experimental if experimental
 
           @attributes.freeze
@@ -15,7 +16,7 @@ module LanguageServer
         #
         # Workspace specific client capabilities.
         #
-        # @return [WorkspaceClientCapabilities]
+        # @return [{ applyEdit?: boolean; workspaceEdit?: WorkspaceEditClientCapabilities; didChangeConfiguration?: ...]
         def workspace
           attributes.fetch(:workspace)
         end
@@ -28,6 +29,14 @@ module LanguageServer
           attributes.fetch(:textDocument)
         end
 
+        #
+        # Window specific client capabilities.
+        #
+        # @return [{ workDoneProgress?: boolean; }]
+        def window
+          attributes.fetch(:window)
+        end
+
         #
         # Experimental client capabilities.
         #

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

@@ -8,12 +8,13 @@ module LanguageServer
       # A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
       #
       class CodeAction
-        def initialize(title:, kind: nil, diagnostics: nil, edit: nil, command: nil)
+        def initialize(title:, kind: nil, diagnostics: nil, is_preferred: nil, edit: nil, command: nil)
           @attributes = {}
 
           @attributes[:title] = title
           @attributes[:kind] = kind if kind
           @attributes[:diagnostics] = diagnostics if diagnostics
+          @attributes[:isPreferred] = is_preferred if is_preferred
           @attributes[:edit] = edit if edit
           @attributes[:command] = command if command
 
@@ -46,6 +47,18 @@ module LanguageServer
           attributes.fetch(:diagnostics)
         end
 
+        #
+        # Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
+        # by keybindings.
+        #
+        # A quick fix should be marked preferred if it properly addresses the underlying error.
+        # A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
+        #
+        # @return [boolean]
+        def is_preferred
+          attributes.fetch(:isPreferred)
+        end
+
         #
         # The workspace edit this code action performs.
         #

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

@@ -0,0 +1,52 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class CodeActionClientCapabilities
+        def initialize(dynamic_registration: nil, code_action_literal_support: nil, is_preferred_support: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+          @attributes[:codeActionLiteralSupport] = code_action_literal_support if code_action_literal_support
+          @attributes[:isPreferredSupport] = is_preferred_support if is_preferred_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether code action supports dynamic registration.
+        #
+        # @return [boolean]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        #
+        # The client supports code action literals as a valid
+        # response of the `textDocument/codeAction` request.
+        #
+        # @return [{ codeActionKind: { valueSet: string[]; }; }]
+        def code_action_literal_support
+          attributes.fetch(:codeActionLiteralSupport)
+        end
+
+        #
+        # Whether code action supports the `isPreferred` property.
+        #
+        # @return [boolean]
+        def is_preferred_support
+          attributes.fetch(:isPreferredSupport)
+        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/code_action_context.rb

@@ -16,7 +16,11 @@ module LanguageServer
         end
 
         #
-        # An array of diagnostics.
+        # An array of diagnostics known on the client side overlapping the range provided to the
+        # `textDocument/codeAction` request. They are provided so that the server knows which
+        # errors are currently presented to the user for the given range. There is no guarantee
+        # that these accurately reflect the error state of the resource. The primary parameter
+        # to compute code actions is the provided range.
         #
         # @return [Diagnostic[]]
         def diagnostics

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

@@ -1,13 +1,11 @@
 module LanguageServer
   module Protocol
     module Interface
-      #
-      # Code Action options.
-      #
-      class CodeActionOptions
-        def initialize(code_action_kinds: nil)
+      class CodeActionOptions < WorkDoneProgressOptions
+        def initialize(work_done_progress: nil, code_action_kinds: nil)
           @attributes = {}
 
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
           @attributes[:codeActionKinds] = code_action_kinds if code_action_kinds
 
           @attributes.freeze

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

@@ -4,10 +4,11 @@ module LanguageServer
       #
       # Params for the CodeActionRequest
       #
-      class CodeActionParams
-        def initialize(text_document:, range:, context:)
+      class CodeActionParams < PartialResultParams
+        def initialize(partial_result_token: nil, text_document:, range:, context:)
           @attributes = {}
 
+          @attributes[:partialResultToken] = partial_result_token if partial_result_token
           @attributes[:textDocument] = text_document
           @attributes[:range] = range
           @attributes[:context] = context

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

@@ -2,9 +2,11 @@ module LanguageServer
   module Protocol
     module Interface
       class CodeActionRegistrationOptions < CodeActionOptions
-        def initialize(code_action_kinds: nil)
+        def initialize(work_done_progress: nil, code_action_kinds: nil)
           @attributes = {}
 
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+          @attributes[:codeActionKinds] = code_action_kinds if code_action_kinds
 
           @attributes.freeze
         end

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

@@ -0,0 +1,33 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class CodeLensClientCapabilities
+        def initialize(dynamic_registration: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether code lens supports dynamic registration.
+        #
+        # @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/code_lens_options.rb

@@ -1,13 +1,11 @@
 module LanguageServer
   module Protocol
     module Interface
-      #
-      # Code Lens options.
-      #
-      class CodeLensOptions
-        def initialize(resolve_provider: nil)
+      class CodeLensOptions < WorkDoneProgressOptions
+        def initialize(work_done_progress: nil, resolve_provider: nil)
           @attributes = {}
 
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
           @attributes[:resolveProvider] = resolve_provider if resolve_provider
 
           @attributes.freeze

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

@@ -1,10 +1,11 @@
 module LanguageServer
   module Protocol
     module Interface
-      class CodeLensParams
-        def initialize(text_document:)
+      class CodeLensParams < PartialResultParams
+        def initialize(partial_result_token: nil, text_document:)
           @attributes = {}
 
+          @attributes[:partialResultToken] = partial_result_token if partial_result_token
           @attributes[:textDocument] = text_document
 
           @attributes.freeze

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

@@ -1,23 +1,16 @@
 module LanguageServer
   module Protocol
     module Interface
-      class CodeLensRegistrationOptions < TextDocumentRegistrationOptions
-        def initialize(document_selector:, resolve_provider: nil)
+      class CodeLensRegistrationOptions < CodeLensOptions
+        def initialize(work_done_progress: nil, resolve_provider: nil)
           @attributes = {}
 
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
           @attributes[:resolveProvider] = resolve_provider if resolve_provider
 
           @attributes.freeze
         end
 
-        #
-        # Code lens has a resolve provider as well.
-        #
-        # @return [boolean]
-        def resolve_provider
-          attributes.fetch(:resolveProvider)
-        end
-
         attr_reader :attributes
 
         def to_hash

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

@@ -1,10 +1,11 @@
 module LanguageServer
   module Protocol
     module Interface
-      class ColorPresentationParams
-        def initialize(text_document:, color:, range:)
+      class ColorPresentationParams < PartialResultParams
+        def initialize(partial_result_token: nil, text_document:, color:, range:)
           @attributes = {}
 
+          @attributes[:partialResultToken] = partial_result_token if partial_result_token
           @attributes[:textDocument] = text_document
           @attributes[:color] = color
           @attributes[:range] = range

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

@@ -0,0 +1,59 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class CompletionClientCapabilities
+        def initialize(dynamic_registration: nil, completion_item: nil, completion_item_kind: nil, context_support: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+          @attributes[:completionItem] = completion_item if completion_item
+          @attributes[:completionItemKind] = completion_item_kind if completion_item_kind
+          @attributes[:contextSupport] = context_support if context_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether completion supports dynamic registration.
+        #
+        # @return [boolean]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        #
+        # The client supports the following `CompletionItem` specific
+        # capabilities.
+        #
+        # @return [{ snippetSupport?: boolean; commitCharactersSupport?: boolean; documentationFormat?: MarkupKind[]...]
+        def completion_item
+          attributes.fetch(:completionItem)
+        end
+
+        # @return [{ valueSet?: any[]; }]
+        def completion_item_kind
+          attributes.fetch(:completionItemKind)
+        end
+
+        #
+        # The client supports to send additional context information for a
+        # `textDocument/completion` request.
+        #
+        # @return [boolean]
+        def context_support
+          attributes.fetch(:contextSupport)
+        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/completion_item.rb

@@ -2,11 +2,12 @@ module LanguageServer
   module Protocol
     module Interface
       class CompletionItem
-        def initialize(label:, kind: nil, detail: nil, documentation: nil, deprecated: nil, preselect: nil, sort_text: nil, filter_text: nil, insert_text: nil, insert_text_format: nil, text_edit: nil, additional_text_edits: nil, commit_characters: nil, command: nil, data: nil)
+        def initialize(label:, kind: nil, tags: nil, detail: nil, documentation: nil, deprecated: nil, preselect: nil, sort_text: nil, filter_text: nil, insert_text: nil, insert_text_format: nil, text_edit: nil, additional_text_edits: nil, commit_characters: nil, command: nil, data: nil)
           @attributes = {}
 
           @attributes[:label] = label
           @attributes[:kind] = kind if kind
+          @attributes[:tags] = tags if tags
           @attributes[:detail] = detail if detail
           @attributes[:documentation] = documentation if documentation
           @attributes[:deprecated] = deprecated if deprecated
@@ -36,13 +37,22 @@ module LanguageServer
 
         #
         # The kind of this completion item. Based of the kind
-        # an icon is chosen by the editor.
+        # an icon is chosen by the editor. The standardized set
+        # of available values is defined in `CompletionItemKind`.
         #
         # @return [number]
         def kind
           attributes.fetch(:kind)
         end
 
+        #
+        # Tags for this completion item.
+        #
+        # @return [1[]]
+        def tags
+          attributes.fetch(:tags)
+        end
+
         #
         # A human-readable string with additional information
         # about this item, like type or symbol information.
@@ -116,9 +126,10 @@ module LanguageServer
 
         #
         # The format of the insert text. The format applies to both the `insertText` property
-        # and the `newText` property of a provided `textEdit`.
+        # and the `newText` property of a provided `textEdit`. If omitted defaults to
+        # `InsertTextFormat.PlainText`.
         #
-        # @return [InsertTextFormat]
+        # @return [DiagnosticTag]
         def insert_text_format
           attributes.fetch(:insertTextFormat)
         end
@@ -170,7 +181,7 @@ module LanguageServer
         end
 
         #
-        # An data entry field that is preserved on a completion item between
+        # A data entry field that is preserved on a completion item between
         # a completion and a completion resolve request.
         #
         # @return [any]

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

@@ -4,31 +4,53 @@ module LanguageServer
       #
       # Completion options.
       #
-      class CompletionOptions
-        def initialize(resolve_provider: nil, trigger_characters: nil)
+      class CompletionOptions < WorkDoneProgressOptions
+        def initialize(work_done_progress: nil, trigger_characters: nil, all_commit_characters: nil, resolve_provider: nil)
           @attributes = {}
 
-          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
           @attributes[:triggerCharacters] = trigger_characters if trigger_characters
+          @attributes[:allCommitCharacters] = all_commit_characters if all_commit_characters
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
 
           @attributes.freeze
         end
 
         #
-        # The server provides support to resolve additional
-        # information for a completion item.
+        # Most tools trigger completion request automatically without explicitly requesting
+        # it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
+        # starts to type an identifier. For example if the user types `c` in a JavaScript file
+        # code complete will automatically pop up present `console` besides others as a
+        # completion item. Characters that make up identifiers don't need to be listed here.
         #
-        # @return [boolean]
-        def resolve_provider
-          attributes.fetch(:resolveProvider)
+        # If code complete should automatically be trigger on characters not being valid inside
+        # an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
+        #
+        # @return [string[]]
+        def trigger_characters
+          attributes.fetch(:triggerCharacters)
         end
 
         #
-        # The characters that trigger completion automatically.
+        # The list of all possible characters that commit a completion. This field can be used
+        # if clients don't support individual commit characters per completion item. See
+        # `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`.
+        #
+        # If a server provides both `allCommitCharacters` and commit characters on an individual
+        # completion item the ones on the completion item win.
         #
         # @return [string[]]
-        def trigger_characters
-          attributes.fetch(:triggerCharacters)
+        def all_commit_characters
+          attributes.fetch(:allCommitCharacters)
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for a completion item.
+        #
+        # @return [boolean]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
         end
 
         attr_reader :attributes