language_server-protocol 3.7.0.0 → 3.15.0.0

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

@@ -0,0 +1,92 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # A code action represents a change that can be performed in code, e.g. to fix a problem or
+      # to refactor code.
+      #
+      # 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, 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
+
+          @attributes.freeze
+        end
+
+        #
+        # A short, human-readable, title for this code action.
+        #
+        # @return [string]
+        def title
+          attributes.fetch(:title)
+        end
+
+        #
+        # The kind of the code action.
+        #
+        # Used to filter code actions.
+        #
+        # @return [string]
+        def kind
+          attributes.fetch(:kind)
+        end
+
+        #
+        # The diagnostics that this code action resolves.
+        #
+        # @return [Diagnostic[]]
+        def diagnostics
+          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.
+        #
+        # @return [WorkspaceEdit]
+        def edit
+          attributes.fetch(:edit)
+        end
+
+        #
+        # A command this code action executes. If a code action
+        # provides an edit and a command, first the edit is
+        # executed and then the command.
+        #
+        # @return [Command]
+        def command
+          attributes.fetch(:command)
+        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_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

@@ -6,22 +6,38 @@ module LanguageServer
       # a code action is run.
       #
       class CodeActionContext
-        def initialize(diagnostics:)
+        def initialize(diagnostics:, only: nil)
           @attributes = {}
 
           @attributes[:diagnostics] = diagnostics
+          @attributes[:only] = only if only
 
           @attributes.freeze
         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
           attributes.fetch(:diagnostics)
         end
 
+        #
+        # Requested kind of actions to return.
+        #
+        # Actions not of this kind are filtered out by the client before being shown. So servers
+        # can omit computing them.
+        #
+        # @return [string[]]
+        def only
+          attributes.fetch(:only)
+        end
+
         attr_reader :attributes
 
         def to_hash

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

@@ -0,0 +1,37 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      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
+        end
+
+        #
+        # CodeActionKinds that this server may return.
+        #
+        # The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+        # may list out every specific kind they provide.
+        #
+        # @return [string[]]
+        def code_action_kinds
+          attributes.fetch(:codeActionKinds)
+        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_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

@@ -0,0 +1,26 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class CodeActionRegistrationOptions < CodeActionOptions
+        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
+
+        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_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