language_server-protocol 0.1.0

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

@@ -0,0 +1,29 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class VersionedTextDocumentIdentifier
+        def initialize(version:)
+          @attributes = {}
+
+          @attributes[:version] = version
+
+          @attributes.freeze
+        end
+
+        #
+        # The version number of this document.
+        #
+        # @return [number]
+        def version
+          attributes.fetch(:version)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # The parameters send in a will save text document notification.
+      #
+      class WillSaveTextDocumentParams
+        def initialize(text_document:, reason:)
+          @attributes = {}
+
+          @attributes[:textDocument] = text_document
+          @attributes[:reason] = reason
+
+          @attributes.freeze
+        end
+
+        #
+        # The document that will be saved.
+        #
+        # @return [TextDocumentIdentifier]
+        def text_document
+          attributes.fetch(:textDocument)
+        end
+
+        #
+        # The 'TextDocumentSaveReason'.
+        #
+        # @return [number]
+        def reason
+          attributes.fetch(:reason)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # Workspace specific client capabilities.
+      #
+      class WorkspaceClientCapabilites
+        def initialize(apply_edit: nil, workspace_edit: nil, did_change_configuration: nil, did_change_watched_files: nil, symbol: nil, execute_command: nil)
+          @attributes = {}
+
+          @attributes[:applyEdit] = apply_edit if apply_edit
+          @attributes[:workspaceEdit] = workspace_edit if workspace_edit
+          @attributes[:didChangeConfiguration] = did_change_configuration if did_change_configuration
+          @attributes[:didChangeWatchedFiles] = did_change_watched_files if did_change_watched_files
+          @attributes[:symbol] = symbol if symbol
+          @attributes[:executeCommand] = execute_command if execute_command
+
+          @attributes.freeze
+        end
+
+        #
+        # The client supports applying batch edits to the workspace by supporting
+        # the request 'workspace/applyEdit'
+        #
+        # @return [boolean]
+        def apply_edit
+          attributes.fetch(:applyEdit)
+        end
+
+        #
+        # Capabilities specific to `WorkspaceEdit`s
+        #
+        # @return [{ documentChanges?: boolean; }]
+        def workspace_edit
+          attributes.fetch(:workspaceEdit)
+        end
+
+        #
+        # Capabilities specific to the `workspace/didChangeConfiguration` notification.
+        #
+        # @return [{ dynamicRegistration?: boolean; }]
+        def did_change_configuration
+          attributes.fetch(:didChangeConfiguration)
+        end
+
+        #
+        # Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+        #
+        # @return [{ dynamicRegistration?: boolean; }]
+        def did_change_watched_files
+          attributes.fetch(:didChangeWatchedFiles)
+        end
+
+        #
+        # Capabilities specific to the `workspace/symbol` request.
+        #
+        # @return [{ dynamicRegistration?: boolean; }]
+        def symbol
+          attributes.fetch(:symbol)
+        end
+
+        #
+        # Capabilities specific to the `workspace/executeCommand` request.
+        #
+        # @return [{ dynamicRegistration?: boolean; }]
+        def execute_command
+          attributes.fetch(:executeCommand)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      class WorkspaceEdit
+        def initialize(changes: nil, document_changes: nil)
+          @attributes = {}
+
+          @attributes[:changes] = changes if changes
+          @attributes[:documentChanges] = document_changes if document_changes
+
+          @attributes.freeze
+        end
+
+        #
+        # Holds changes to existing resources.
+        #
+        # @return [{ [uri: string]: TextEdit[]; }]
+        def changes
+          attributes.fetch(:changes)
+        end
+
+        #
+        # An array of `TextDocumentEdit`s to express changes to specific a specific
+        # version of a text document. Whether a client supports versioned document
+        # edits is expressed via `WorkspaceClientCapabilites.versionedWorkspaceEdit`.
+        #
+        # @return [TextDocumentEdit[]]
+        def document_changes
+          attributes.fetch(:documentChanges)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module LanguageServer
+  module Protocol
+    module Interfaces
+      #
+      # The parameters of a Workspace Symbol Request.
+      #
+      class WorkspaceSymbolParams
+        def initialize(query:)
+          @attributes = {}
+
+          @attributes[:query] = query
+
+          @attributes.freeze
+        end
+
+        #
+        # A non-empty query string
+        #
+        # @return [string]
+        def query
+          attributes.fetch(:query)
+        end
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/interfaces.rb

@@ -0,0 +1,87 @@
+require "language_server/protocol/interfaces/message"
+require "language_server/protocol/interfaces/request_message"
+require "language_server/protocol/interfaces/response_message"
+require "language_server/protocol/interfaces/response_error"
+require "language_server/protocol/interfaces/notification_message"
+require "language_server/protocol/interfaces/cancel_params"
+require "language_server/protocol/interfaces/position"
+require "language_server/protocol/interfaces/range"
+require "language_server/protocol/interfaces/location"
+require "language_server/protocol/interfaces/diagnostic"
+require "language_server/protocol/interfaces/command"
+require "language_server/protocol/interfaces/text_edit"
+require "language_server/protocol/interfaces/text_document_edit"
+require "language_server/protocol/interfaces/workspace_edit"
+require "language_server/protocol/interfaces/text_document_identifier"
+require "language_server/protocol/interfaces/text_document_item"
+require "language_server/protocol/interfaces/versioned_text_document_identifier"
+require "language_server/protocol/interfaces/text_document_position_params"
+require "language_server/protocol/interfaces/document_filter"
+require "language_server/protocol/interfaces/initialize_params"
+require "language_server/protocol/interfaces/workspace_client_capabilites"
+require "language_server/protocol/interfaces/text_document_client_capabilities"
+require "language_server/protocol/interfaces/client_capabilities"
+require "language_server/protocol/interfaces/initialize_result"
+require "language_server/protocol/interfaces/initialize_error"
+require "language_server/protocol/interfaces/completion_options"
+require "language_server/protocol/interfaces/signature_help_options"
+require "language_server/protocol/interfaces/code_lens_options"
+require "language_server/protocol/interfaces/document_on_type_formatting_options"
+require "language_server/protocol/interfaces/document_link_options"
+require "language_server/protocol/interfaces/execute_command_options"
+require "language_server/protocol/interfaces/save_options"
+require "language_server/protocol/interfaces/text_document_sync_options"
+require "language_server/protocol/interfaces/server_capabilities"
+require "language_server/protocol/interfaces/show_message_params"
+require "language_server/protocol/interfaces/show_message_request_params"
+require "language_server/protocol/interfaces/message_action_item"
+require "language_server/protocol/interfaces/log_message_params"
+require "language_server/protocol/interfaces/registration"
+require "language_server/protocol/interfaces/registration_params"
+require "language_server/protocol/interfaces/text_document_registration_options"
+require "language_server/protocol/interfaces/unregistration"
+require "language_server/protocol/interfaces/unregistration_params"
+require "language_server/protocol/interfaces/did_change_configuration_params"
+require "language_server/protocol/interfaces/did_open_text_document_params"
+require "language_server/protocol/interfaces/did_change_text_document_params"
+require "language_server/protocol/interfaces/text_document_content_change_event"
+require "language_server/protocol/interfaces/text_document_change_registration_options"
+require "language_server/protocol/interfaces/will_save_text_document_params"
+require "language_server/protocol/interfaces/did_save_text_document_params"
+require "language_server/protocol/interfaces/text_document_save_registration_options"
+require "language_server/protocol/interfaces/did_close_text_document_params"
+require "language_server/protocol/interfaces/did_change_watched_files_params"
+require "language_server/protocol/interfaces/file_event"
+require "language_server/protocol/interfaces/publish_diagnostics_params"
+require "language_server/protocol/interfaces/completion_list"
+require "language_server/protocol/interfaces/completion_item"
+require "language_server/protocol/interfaces/completion_registration_options"
+require "language_server/protocol/interfaces/hover"
+require "language_server/protocol/interfaces/signature_help"
+require "language_server/protocol/interfaces/signature_information"
+require "language_server/protocol/interfaces/parameter_information"
+require "language_server/protocol/interfaces/signature_help_registration_options"
+require "language_server/protocol/interfaces/reference_params"
+require "language_server/protocol/interfaces/reference_context"
+require "language_server/protocol/interfaces/document_highlight"
+require "language_server/protocol/interfaces/document_symbol_params"
+require "language_server/protocol/interfaces/symbol_information"
+require "language_server/protocol/interfaces/workspace_symbol_params"
+require "language_server/protocol/interfaces/code_action_params"
+require "language_server/protocol/interfaces/code_action_context"
+require "language_server/protocol/interfaces/code_lens_params"
+require "language_server/protocol/interfaces/code_lens"
+require "language_server/protocol/interfaces/code_lens_registration_options"
+require "language_server/protocol/interfaces/document_link_params"
+require "language_server/protocol/interfaces/document_link"
+require "language_server/protocol/interfaces/document_link_registration_options"
+require "language_server/protocol/interfaces/document_formatting_params"
+require "language_server/protocol/interfaces/formatting_options"
+require "language_server/protocol/interfaces/document_range_formatting_params"
+require "language_server/protocol/interfaces/document_on_type_formatting_params"
+require "language_server/protocol/interfaces/document_on_type_formatting_registration_options"
+require "language_server/protocol/interfaces/rename_params"
+require "language_server/protocol/interfaces/execute_command_params"
+require "language_server/protocol/interfaces/execute_command_registration_options"
+require "language_server/protocol/interfaces/apply_workspace_edit_params"
+require "language_server/protocol/interfaces/apply_workspace_edit_response"

data/lib/language_server/protocol/transport/stdio/reader.rb

@@ -0,0 +1,39 @@
+require "json"
+
+module LanguageServer
+  module Protocol
+    module Transport
+      module Stdio
+        class Reader
+          def read(&block)
+            buffer = ""
+            header_parsed = false
+            content_length = nil
+
+            while char = STDIN.getc
+              buffer << char
+
+              unless header_parsed
+                if buffer[-4..-1] == "\r\n" * 2
+                  content_length = buffer.match(/Content-Length: (\d+)/i)[1].to_i
+
+                  header_parsed = true
+                  buffer.clear
+                end
+              else
+                if buffer.bytesize == content_length
+                  request = JSON.parse(buffer, symbolize_names: true)
+
+                  block.call(request)
+
+                  header_parsed = false
+                  buffer.clear
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/transport/stdio/writer.rb

@@ -0,0 +1,38 @@
+module LanguageServer
+  module Protocol
+    module Transport
+      module Stdio
+        class Writer
+          def respond(id:, result:)
+            write(id: id, result: result)
+          end
+
+          def notify(method:, params: {})
+            write(method: method, params: params)
+          end
+
+          private
+
+          def write(response)
+            response_str = response.merge(
+              jsonrpc: "2.0"
+            ).to_json
+
+            headers = {
+              "Content-Length" => response_str.bytesize
+            }
+
+            headers.each do |k, v|
+              STDOUT.print "#{k}: #{v}\r\n"
+            end
+
+            STDOUT.print "\r\n"
+
+            STDOUT.print response_str
+            STDOUT.flush
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_server/protocol/transport/stdio.rb

@@ -0,0 +1,2 @@
+require "language_server/protocol/transport/stdio/reader"
+require "language_server/protocol/transport/stdio/writer"

data/lib/language_server/protocol/version.rb

@@ -0,0 +1,5 @@
+module LanguageServer
+  module Protocol
+    VERSION = "0.1.0"
+  end
+end

data/lib/language_server/protocol.rb

@@ -0,0 +1,7 @@
+require "language_server/protocol/version"
+
+module LanguageServer
+  module Protocol
+    # Your code goes here...
+  end
+end

data/package.json

@@ -0,0 +1,10 @@
+{
+  "dependencies": {
+    "@types/es6-promise": "^0.0.32",
+    "@types/node": "^7.0.18",
+    "handlebars": "^4.0.8",
+    "isomorphic-fetch": "^2.2.1",
+    "ts-node": "^3.0.4",
+    "typescript": "^2.3.2"
+  }
+}

data/scripts/generateFiles.ts

@@ -0,0 +1,224 @@
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as fetch from 'isomorphic-fetch';
+
+const lspVersion = 'a0d9d12fa6d4c313d3ed70bd842f0a2c8e66e29e';
+const rootDir = path.normalize(path.join(__dirname, ".."));
+const tempDir = path.join(rootDir, "tmp");
+const protocolMdPath = path.join(tempDir, lspVersion, "protocol.md");
+
+const createFile = (filePath, content) => {
+  const dir = path.dirname(path.normalize(filePath));
+
+  dir.split(/(?!^)\//).forEach((_, index, all) => {
+    const dir = all.slice(0, index + 1).join("/");
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir);
+    }
+  });
+
+  fs.writeFileSync(filePath, content);
+}
+
+const extractTypeScriptSource = content => {
+  const regEx = /^```typescript\n([^]*?)^```\n/mg;
+  let match;
+  let result = "";
+
+  while((match = regEx.exec(content)) !== null) {
+    result = result.concat(match[1]);
+  }
+
+  return result;
+}
+
+const extractDefinitions = content => {
+  const fileName = path.join(tempDir, "protocol.ts");
+  createFile(fileName, content);
+  const program = ts.createProgram([fileName], {});
+  const checker = program.getTypeChecker();
+
+  const output = [];
+
+  const serialize = member => {
+    const symbol = checker.getSymbolAtLocation(member.name);
+    const type = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+    const types = member.kind == ts.SyntaxKind.UnionType ? (<ts.UnionTypeNode>(<ts.PropertySignature>member).type).types : [];
+
+    return {
+      name: symbol.getName(),
+      documentation: ts.displayPartsToString(symbol.getDocumentationComment()),
+      type: checker.typeToString(type),
+      optional: !!member.questionToken,
+      nullable: (<ts.NodeArray<ts.TypeNode>>types).some(t => t.kind == ts.SyntaxKind.NullKeyword),
+      value: symbol.valueDeclaration ? symbol.valueDeclaration.getChildAt(symbol.valueDeclaration.getChildCount() - 1).getText() : null
+    };
+  }
+
+  const handleInterface = (node: ts.InterfaceDeclaration) => {
+    const members = node.members.filter(member => member.name).map(member => serialize(member));
+
+    output.push(
+    {
+      interface: serialize(node),
+      members
+    }
+    );
+  }
+
+  const handleModule = (node: ts.ModuleDeclaration) => {
+    const members = []
+
+    ts.forEachChild(node.body, node => {
+      members.push(serialize((<ts.VariableStatement>node).declarationList.declarations[0]));
+    });
+
+    output.push(
+    {
+      module: serialize(node),
+      members
+    }
+    );
+  }
+
+  const visit = node => {
+    switch(node.kind) {
+      case(ts.SyntaxKind.InterfaceDeclaration):
+      handleInterface(node);
+      break;
+
+      case(ts.SyntaxKind.ModuleDeclaration):
+      handleModule(node);
+      break;
+    }
+  };
+
+  ts.forEachChild(program.getSourceFile(fileName), visit);
+
+  return output;
+}
+
+import Handlebars from "handlebars";
+const snake = s => s.replace(/^[A-Z]/, s => s.toLowerCase()).replace(/[A-Z]/g, s => `_${s.toLowerCase()}`);
+
+Handlebars.registerHelper("params", members => {
+  return members.map(member => `${snake(member.name)}:${(member.optional || member.nullable) ? " nil" : ""}`).join(", ");
+});
+Handlebars.registerHelper("snake", snake);
+Handlebars.registerHelper("comment", (s, options) => {
+  const indent = Array(options.hash.indent + 1).join(" ");
+  return s.split("\n").map(s => s.trim()).map(s => `${indent}#${s.length == 0 ? "" : ` ${s}`}`).join("\n");
+});
+Handlebars.registerHelper("local_var", s => {
+  const rubyKeywords = ["end", "retry"]
+  const snaked = snake(s);
+
+  if (rubyKeywords.some(k => k == s)) {
+    return `binding.local_variable_get(:${snaked})`;
+  } else {
+    return snake(s);
+  }
+});
+Handlebars.registerHelper("const", s => {
+  return snake(s).toUpperCase();
+});
+
+(async () => {
+  if (!fs.existsSync(protocolMdPath)) {
+    const res = await fetch(`https://github.com/Microsoft/language-server-protocol/raw/${lspVersion}/protocol.md`);
+    createFile(protocolMdPath, await res.text());
+  }
+
+  const md = fs.readFileSync(protocolMdPath).toString();
+  const typeScriptSource = extractTypeScriptSource(md);
+
+  const definitions = extractDefinitions(typeScriptSource);
+  const interfaces = definitions.filter(d => d.interface);
+  const modules = definitions.filter(d => d.module);
+
+  interfaces.forEach(definition => {
+    createFile(path.join(rootDir, "lib", "language_server", "protocol", "interfaces", `${snake(definition.interface.name)}.rb`), Handlebars.compile(`
+module LanguageServer
+  module Protocol
+    module Interfaces
+      {{#if definition.interface.documentation}}
+      #
+{{comment definition.interface.documentation indent=6}}
+      #
+      {{/if}}
+      class {{definition.interface.name}}
+        def initialize({{params definition.members}})
+          @attributes = {}
+
+          {{#each definition.members}}
+          @attributes[:{{name}}] = {{local_var name}}{{#if optional}} if {{local_var name}}{{/if}}
+          {{/each}}
+
+          @attributes.freeze
+        end
+        {{#each definition.members}}
+
+        {{#if documentation}}
+        #
+{{comment documentation indent=8}}
+        #
+        {{/if}}
+        # @return [{{type}}{{#if nullable}}, nil{{/if}}]
+        def {{snake name}}
+          attributes.fetch(:{{name}})
+        end
+        {{/each}}
+
+        attr_reader :attributes
+
+        def to_json(*args)
+          attributes.to_json(*args)
+        end
+      end
+    end
+  end
+end
+`.slice(1), {noEscape: true})({definition}));
+  });
+
+  modules.forEach(definition => {
+    createFile(path.join(rootDir, "lib", "language_server", "protocol", "constants", `${snake(definition.module.name)}.rb`), Handlebars.compile(`
+module LanguageServer
+  module Protocol
+    module Constants
+      {{#if definition.module.documentation}}
+      #
+{{comment definition.module.documentation indent=6}}
+      #
+      {{/if}}
+      module {{definition.module.name}}
+        {{#each definition.members}}
+        {{#if documentation}}
+        #
+{{comment documentation indent=8}}
+        #
+        {{/if}}
+        {{const name}} = {{value}}
+        {{/each}}
+      end
+    end
+  end
+end
+`.slice(1), {noEscape: true})({definition}));
+  });
+
+  createFile(path.join(rootDir, "lib", "language_server", "protocol", "interfaces.rb"), Handlebars.compile(`
+{{#each interfaces}}
+require "language_server/protocol/interfaces/{{snake interface.name}}"
+{{/each}}
+`.slice(1), {noEscape: true})({interfaces}));
+
+  createFile(path.join(rootDir, "lib", "language_server", "protocol", "constants.rb"), Handlebars.compile(`
+{{#each modules}}
+require "language_server/protocol/constants/{{snake module.name}}"
+{{/each}}
+`.slice(1), {noEscape: true})({modules}));
+
+})();