language_server-protocol 3.16.0.2 → 3.17.0.1

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

@@ -0,0 +1,122 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint information.
+      #
+      class InlayHint
+        def initialize(position:, label:, kind: nil, text_edits: nil, tooltip: nil, padding_left: nil, padding_right: nil, data: nil)
+          @attributes = {}
+
+          @attributes[:position] = position
+          @attributes[:label] = label
+          @attributes[:kind] = kind if kind
+          @attributes[:textEdits] = text_edits if text_edits
+          @attributes[:tooltip] = tooltip if tooltip
+          @attributes[:paddingLeft] = padding_left if padding_left
+          @attributes[:paddingRight] = padding_right if padding_right
+          @attributes[:data] = data if data
+
+          @attributes.freeze
+        end
+
+        #
+        # The position of this hint.
+        #
+        # @return [Position]
+        def position
+          attributes.fetch(:position)
+        end
+
+        #
+        # The label of this hint. A human readable string or an array of
+        # InlayHintLabelPart label parts.
+        #
+        # *Note* that neither the string nor the label part can be empty.
+        #
+        # @return [string | InlayHintLabelPart[]]
+        def label
+          attributes.fetch(:label)
+        end
+
+        #
+        # The kind of this hint. Can be omitted in which case the client
+        # should fall back to a reasonable default.
+        #
+        # @return [InlayHintKind]
+        def kind
+          attributes.fetch(:kind)
+        end
+
+        #
+        # Optional text edits that are performed when accepting this inlay hint.
+        #
+        # *Note* that edits are expected to change the document so that the inlay
+        # hint (or its nearest variant) is now part of the document and the inlay
+        # hint itself is now obsolete.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @return [TextEdit[]]
+        def text_edits
+          attributes.fetch(:textEdits)
+        end
+
+        #
+        # The tooltip text when you hover over this item.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @return [string | MarkupContent]
+        def tooltip
+          attributes.fetch(:tooltip)
+        end
+
+        #
+        # Render padding before the hint.
+        #
+        # Note: Padding should use the editor's background color, not the
+        # background color of the hint itself. That means padding can be used
+        # to visually align/separate an inlay hint.
+        #
+        # @return [boolean]
+        def padding_left
+          attributes.fetch(:paddingLeft)
+        end
+
+        #
+        # Render padding after the hint.
+        #
+        # Note: Padding should use the editor's background color, not the
+        # background color of the hint itself. That means padding can be used
+        # to visually align/separate an inlay hint.
+        #
+        # @return [boolean]
+        def padding_right
+          attributes.fetch(:paddingRight)
+        end
+
+        #
+        # A data entry field that is preserved on a inlay hint between
+        # a `textDocument/inlayHint` and a `inlayHint/resolve` request.
+        #
+        # @return [LSPAny]
+        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/inlay_hint_client_capabilities.rb

@@ -0,0 +1,46 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint client capabilities.
+      #
+      class InlayHintClientCapabilities
+        def initialize(dynamic_registration: nil, resolve_support: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+          @attributes[:resolveSupport] = resolve_support if resolve_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether inlay hints support dynamic registration.
+        #
+        # @return [boolean]
+        def dynamic_registration
+          attributes.fetch(:dynamicRegistration)
+        end
+
+        #
+        # Indicates which properties a client can resolve lazily on a inlay
+        # hint.
+        #
+        # @return [{ properties: string[]; }]
+        def resolve_support
+          attributes.fetch(:resolveSupport)
+        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/inlay_hint_label_part.rb

@@ -0,0 +1,79 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # An inlay hint label part allows for interactive and composite labels
+      # of inlay hints.
+      #
+      class InlayHintLabelPart
+        def initialize(value:, tooltip: nil, location: nil, command: nil)
+          @attributes = {}
+
+          @attributes[:value] = value
+          @attributes[:tooltip] = tooltip if tooltip
+          @attributes[:location] = location if location
+          @attributes[:command] = command if command
+
+          @attributes.freeze
+        end
+
+        #
+        # The value of this label part.
+        #
+        # @return [string]
+        def value
+          attributes.fetch(:value)
+        end
+
+        #
+        # The tooltip text when you hover over this label part. Depending on
+        # the client capability `inlayHint.resolveSupport` clients might resolve
+        # this property late using the resolve request.
+        #
+        # @return [string | MarkupContent]
+        def tooltip
+          attributes.fetch(:tooltip)
+        end
+
+        #
+        # An optional source code location that represents this
+        # label part.
+        #
+        # The editor will use this location for the hover and for code navigation
+        # features: This part will become a clickable link that resolves to the
+        # definition of the symbol at the given location (not necessarily the
+        # location itself), it shows the hover that shows at the given location,
+        # and it shows a context menu with further code navigation commands.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @return [Location]
+        def location
+          attributes.fetch(:location)
+        end
+
+        #
+        # An optional command for this label part.
+        #
+        # Depending on the client capability `inlayHint.resolveSupport` clients
+        # might resolve this property late using the resolve request.
+        #
+        # @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/inlay_hint_options.rb

@@ -0,0 +1,43 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint options used during static registration.
+      #
+      class InlayHintOptions
+        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
+
+        # @return [boolean]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for an inlay hint item.
+        #
+        # @return [boolean]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
+        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/inlay_hint_params.rb

@@ -0,0 +1,54 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # A parameter literal used in inlay hint requests.
+      #
+      class InlayHintParams
+        def initialize(work_done_token: nil, text_document:, range:)
+          @attributes = {}
+
+          @attributes[:workDoneToken] = work_done_token if work_done_token
+          @attributes[:textDocument] = text_document
+          @attributes[:range] = range
+
+          @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
+
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The visible document range for which inlay hints should be computed.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        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/inlay_hint_registration_options.rb

@@ -0,0 +1,63 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inlay hint options used during static or dynamic registration.
+      #
+      class InlayHintRegistrationOptions
+        def initialize(work_done_progress: nil, resolve_provider: nil, document_selector:, id: nil)
+          @attributes = {}
+
+          @attributes[:workDoneProgress] = work_done_progress if work_done_progress
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:documentSelector] = document_selector
+          @attributes[:id] = id if id
+
+          @attributes.freeze
+        end
+
+        # @return [boolean]
+        def work_done_progress
+          attributes.fetch(:workDoneProgress)
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for an inlay hint item.
+        #
+        # @return [boolean]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
+        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/inlay_hint_workspace_client_capabilities.rb

@@ -0,0 +1,42 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Client workspace capabilities specific to inlay hints.
+      #
+      class InlayHintWorkspaceClientCapabilities
+        def initialize(refresh_support: nil)
+          @attributes = {}
+
+          @attributes[:refreshSupport] = refresh_support if refresh_support
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether the client implementation supports a refresh request sent from
+        # the server to the client.
+        #
+        # Note that this event is global and will force the client to refresh all
+        # inlay hints currently shown. It should be used with absolute care and
+        # is useful for situation where a server for example detects a project wide
+        # change that requires such a calculation.
+        #
+        # @return [boolean]
+        def refresh_support
+          attributes.fetch(:refreshSupport)
+        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/inline_value_client_capabilities.rb

@@ -0,0 +1,37 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Client capabilities specific to inline values.
+      #
+      class InlineValueClientCapabilities
+        def initialize(dynamic_registration: nil)
+          @attributes = {}
+
+          @attributes[:dynamicRegistration] = dynamic_registration if dynamic_registration
+
+          @attributes.freeze
+        end
+
+        #
+        # Whether implementation supports dynamic registration for inline
+        # value providers.
+        #
+        # @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/inline_value_context.rb

@@ -0,0 +1,44 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      class InlineValueContext
+        def initialize(frame_id:, stopped_location:)
+          @attributes = {}
+
+          @attributes[:frameId] = frame_id
+          @attributes[:stoppedLocation] = stopped_location
+
+          @attributes.freeze
+        end
+
+        #
+        # The stack frame (as a DAP Id) where the execution has stopped.
+        #
+        # @return [number]
+        def frame_id
+          attributes.fetch(:frameId)
+        end
+
+        #
+        # The document range where execution has stopped.
+        # Typically the end position of the range denotes the line where the
+        # inline values are shown.
+        #
+        # @return [Range]
+        def stopped_location
+          attributes.fetch(:stoppedLocation)
+        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/inline_value_evaluatable_expression.rb

@@ -0,0 +1,52 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Provide an inline value through an expression evaluation.
+      #
+      # If only a range is specified, the expression will be extracted from the
+      # underlying document.
+      #
+      # An optional expression can be used to override the extracted expression.
+      #
+      class InlineValueEvaluatableExpression
+        def initialize(range:, expression: nil)
+          @attributes = {}
+
+          @attributes[:range] = range
+          @attributes[:expression] = expression if expression
+
+          @attributes.freeze
+        end
+
+        #
+        # The document range for which the inline value applies.
+        # The range is used to extract the evaluatable expression from the
+        # underlying document.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # If specified the expression overrides the extracted expression.
+        #
+        # @return [string]
+        def expression
+          attributes.fetch(:expression)
+        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/inline_value_options.rb

@@ -0,0 +1,33 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # Inline value options used during static registration.
+      #
+      class InlineValueOptions
+        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/inline_value_params.rb

@@ -0,0 +1,64 @@
+module LanguageServer
+  module Protocol
+    module Interface
+      #
+      # A parameter literal used in inline value requests.
+      #
+      class InlineValueParams
+        def initialize(work_done_token: nil, text_document:, range:, context:)
+          @attributes = {}
+
+          @attributes[:workDoneToken] = work_done_token if work_done_token
+          @attributes[:textDocument] = text_document
+          @attributes[:range] = range
+          @attributes[:context] = context
+
+          @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
+
+        #
+        # The text document.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The document range for which inline values should be computed.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # Additional information about the context in which inline values were
+        # requested.
+        #
+        # @return [InlineValueContext]
+        def context
+          attributes.fetch(:context)
+        end
+
+        attr_reader :attributes
+
+        def to_hash
+          attributes
+        end
+
+        def to_json(*args)
+          to_hash.to_json(*args)
+        end
+      end
+    end
+  end
+end