language_server 0.1.0

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

@@ -0,0 +1,47 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class ClientCapabilities
+        def initialize(workspace: nil, text_document: nil, experimental: nil)
+          @attributes = {}
+
+          @attributes[:workspace] = workspace if workspace
+          @attributes[:textDocument] = text_document if text_document
+          @attributes[:experimental] = experimental if experimental
+
+          @attributes.freeze
+        end
+
+        #
+        # Workspace specific client capabilities.
+        #
+        # @return [WorkspaceClientCapabilites]
+        def workspace
+          attributes.fetch(:workspace)
+        end
+
+        #
+        # Text document specific client capabilities.
+        #
+        # @return [TextDocumentClientCapabilities]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # Experimental client capabilities.
+        #
+        # @return [any]
+        def experimental
+          attributes.fetch(:experimental)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/code_action_context.rb

@@ -0,0 +1,33 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Contains additional diagnostic information about the context in which
+      # a code action is run.
+      #
+      class CodeActionContext
+        def initialize(diagnostics:)
+          @attributes = {}
+
+          @attributes[:diagnostics] = diagnostics
+
+          @attributes.freeze
+        end
+
+        #
+        # An array of diagnostics.
+        #
+        # @return [Diagnostic[]]
+        def diagnostics
+          attributes.fetch(:diagnostics)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Params for the CodeActionRequest
+      #
+      class CodeActionParams
+        def initialize(text_document:, range:, context:)
+          @attributes = {}
+
+          @attributes[:textDocument] = text_document
+          @attributes[:range] = range
+          @attributes[:context] = context
+
+          @attributes.freeze
+        end
+
+        #
+        # The document in which the command was invoked.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The range for which the command was invoked.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # Context carrying additional information.
+        #
+        # @return [CodeActionContext]
+        def context
+          attributes.fetch(:context)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/code_lens.rb

@@ -0,0 +1,55 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # A code lens represents a command that should be shown along with
+      # source text, like the number of references, a way to run tests, etc.
+      #
+      # A code lens is _unresolved_ when no command is associated to it. For performance
+      # reasons the creation of a code lens and resolving should be done in two stages.
+      #
+      class CodeLens
+        def initialize(range:, command: nil, data: nil)
+          @attributes = {}
+
+          @attributes[:range] = range
+          @attributes[:command] = command if command
+          @attributes[:data] = data if data
+
+          @attributes.freeze
+        end
+
+        #
+        # The range in which this code lens is valid. Should only span a single line.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # The command this code lens represents.
+        #
+        # @return [Command]
+        def command
+          attributes.fetch(:command)
+        end
+
+        #
+        # A data entry field that is preserved on a code lens item between
+        # a code lens and a code lens resolve request.
+        #
+        # @return [any]
+        def data
+          attributes.fetch(:data)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/code_lens_options.rb

@@ -0,0 +1,32 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Code Lens options.
+      #
+      class CodeLensOptions
+        def initialize(resolve_provider: nil)
+          @attributes = {}
+
+          @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_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class CodeLensParams
+        def initialize(text_document:)
+          @attributes = {}
+
+          @attributes[:textDocument] = text_document
+
+          @attributes.freeze
+        end
+
+        #
+        # The document to request code lens for.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class CodeLensRegistrationOptions
+        def initialize(resolve_provider: nil)
+          @attributes = {}
+
+          @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_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/command.rb

@@ -0,0 +1,48 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class Command
+        def initialize(title:, command:, arguments: nil)
+          @attributes = {}
+
+          @attributes[:title] = title
+          @attributes[:command] = command
+          @attributes[:arguments] = arguments if arguments
+
+          @attributes.freeze
+        end
+
+        #
+        # Title of the command, like `save`.
+        #
+        # @return [string]
+        def title
+          attributes.fetch(:title)
+        end
+
+        #
+        # The identifier of the actual command handler.
+        #
+        # @return [string]
+        def command
+          attributes.fetch(:command)
+        end
+
+        #
+        # Arguments that the command handler should be
+        # invoked with.
+        #
+        # @return [any[]]
+        def arguments
+          attributes.fetch(:arguments)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/completion_item.rb

@@ -0,0 +1,145 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class CompletionItem
+        def initialize(label:, kind: nil, detail: nil, documentation: nil, sort_text: nil, filter_text: nil, insert_text: nil, insert_text_format: nil, text_edit: nil, additional_text_edits: nil, command: nil, data: nil)
+          @attributes = {}
+
+          @attributes[:label] = label
+          @attributes[:kind] = kind if kind
+          @attributes[:detail] = detail if detail
+          @attributes[:documentation] = documentation if documentation
+          @attributes[:sortText] = sort_text if sort_text
+          @attributes[:filterText] = filter_text if filter_text
+          @attributes[:insertText] = insert_text if insert_text
+          @attributes[:insertTextFormat] = insert_text_format if insert_text_format
+          @attributes[:textEdit] = text_edit if text_edit
+          @attributes[:additionalTextEdits] = additional_text_edits if additional_text_edits
+          @attributes[:command] = command if command
+          @attributes[:data] = data if data
+
+          @attributes.freeze
+        end
+
+        #
+        # The label of this completion item. By default
+        # also the text that is inserted when selecting
+        # this completion.
+        #
+        # @return [string]
+        def label
+          attributes.fetch(:label)
+        end
+
+        #
+        # The kind of this completion item. Based of the kind
+        # an icon is chosen by the editor.
+        #
+        # @return [number]
+        def kind
+          attributes.fetch(:kind)
+        end
+
+        #
+        # A human-readable string with additional information
+        # about this item, like type or symbol information.
+        #
+        # @return [string]
+        def detail
+          attributes.fetch(:detail)
+        end
+
+        #
+        # A human-readable string that represents a doc-comment.
+        #
+        # @return [string]
+        def documentation
+          attributes.fetch(:documentation)
+        end
+
+        #
+        # A string that shoud be used when comparing this item
+        # with other items. When `falsy` the label is used.
+        #
+        # @return [string]
+        def sort_text
+          attributes.fetch(:sortText)
+        end
+
+        #
+        # A string that should be used when filtering a set of
+        # completion items. When `falsy` the label is used.
+        #
+        # @return [string]
+        def filter_text
+          attributes.fetch(:filterText)
+        end
+
+        #
+        # A string that should be inserted a document when selecting
+        # this completion. When `falsy` the label is used.
+        #
+        # @return [string]
+        def insert_text
+          attributes.fetch(:insertText)
+        end
+
+        #
+        # The format of the insert text. The format applies to both the `insertText` property
+        # and the `newText` property of a provided `textEdit`.
+        #
+        # @return [InsertTextFormat]
+        def insert_text_format
+          attributes.fetch(:insertTextFormat)
+        end
+
+        #
+        # An edit which is applied to a document when selecting this completion. When an edit is provided the value of
+        # `insertText` is ignored.
+        #
+        # *Note:* The range of the edit must be a single line range and it must contain the position at which completion
+        # has been requested.
+        #
+        # @return [TextEdit]
+        def text_edit
+          attributes.fetch(:textEdit)
+        end
+
+        #
+        # An optional array of additional text edits that are applied when
+        # selecting this completion. Edits must not overlap with the main edit
+        # nor with themselves.
+        #
+        # @return [TextEdit[]]
+        def additional_text_edits
+          attributes.fetch(:additionalTextEdits)
+        end
+
+        #
+        # An optional command that is executed *after* inserting this completion. *Note* that
+        # additional modifications to the current document should be described with the
+        # additionalTextEdits-property.
+        #
+        # @return [Command]
+        def command
+          attributes.fetch(:command)
+        end
+
+        #
+        # An data entry field that is preserved on a completion item between
+        # a completion and a completion resolve request.
+        #
+        # @return [any]
+        def data
+          attributes.fetch(:data)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/completion_list.rb

@@ -0,0 +1,43 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Represents a collection of [completion items](#CompletionItem) to be presented
+      # in the editor.
+      #
+      class CompletionList
+        def initialize(is_incomplete:, items:)
+          @attributes = {}
+
+          @attributes[:isIncomplete] = is_incomplete
+          @attributes[:items] = items
+
+          @attributes.freeze
+        end
+
+        #
+        # This list it not complete. Further typing should result in recomputing
+        # this list.
+        #
+        # @return [boolean]
+        def is_incomplete
+          attributes.fetch(:isIncomplete)
+        end
+
+        #
+        # The completion items.
+        #
+        # @return [CompletionItem[]]
+        def items
+          attributes.fetch(:items)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Completion options.
+      #
+      class CompletionOptions
+        def initialize(resolve_provider: nil, trigger_characters: nil)
+          @attributes = {}
+
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+          @attributes[:triggerCharacters] = trigger_characters if trigger_characters
+
+          @attributes.freeze
+        end
+
+        #
+        # The server provides support to resolve additional
+        # information for a completion item.
+        #
+        # @return [boolean]
+        def resolve_provider
+          attributes.fetch(:resolveProvider)
+        end
+
+        #
+        # The characters that trigger completion automatically.
+        #
+        # @return [string[]]
+        def trigger_characters
+          attributes.fetch(:triggerCharacters)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/completion_registration_options.rb

@@ -0,0 +1,39 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class CompletionRegistrationOptions
+        def initialize(trigger_characters: nil, resolve_provider: nil)
+          @attributes = {}
+
+          @attributes[:triggerCharacters] = trigger_characters if trigger_characters
+          @attributes[:resolveProvider] = resolve_provider if resolve_provider
+
+          @attributes.freeze
+        end
+
+        #
+        # The characters that trigger completion automatically.
+        #
+        # @return [string[]]
+        def trigger_characters
+          attributes.fetch(:triggerCharacters)
+        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
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/diagnostic.rb

@@ -0,0 +1,67 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class Diagnostic
+        def initialize(range:, severity: nil, code: nil, source: nil, message:)
+          @attributes = {}
+
+          @attributes[:range] = range
+          @attributes[:severity] = severity if severity
+          @attributes[:code] = code if code
+          @attributes[:source] = source if source
+          @attributes[:message] = message
+
+          @attributes.freeze
+        end
+
+        #
+        # The range at which the message applies.
+        #
+        # @return [Range]
+        def range
+          attributes.fetch(:range)
+        end
+
+        #
+        # The diagnostic's severity. Can be omitted. If omitted it is up to the
+        # client to interpret diagnostics as error, warning, info or hint.
+        #
+        # @return [number]
+        def severity
+          attributes.fetch(:severity)
+        end
+
+        #
+        # The diagnostic's code. Can be omitted.
+        #
+        # @return [string | number]
+        def code
+          attributes.fetch(:code)
+        end
+
+        #
+        # A human-readable string describing the source of this
+        # diagnostic, e.g. 'typescript' or 'super lint'.
+        #
+        # @return [string]
+        def source
+          attributes.fetch(:source)
+        end
+
+        #
+        # The diagnostic's message.
+        #
+        # @return [string]
+        def message
+          attributes.fetch(:message)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces/did_change_configuration_params.rb

@@ -0,0 +1,29 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class DidChangeConfigurationParams
+        def initialize(settings:)
+          @attributes = {}
+
+          @attributes[:settings] = settings
+
+          @attributes.freeze
+        end
+
+        #
+        # The actual changed settings
+        #
+        # @return [any]
+        def settings
+          attributes.fetch(:settings)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end