diff options
Diffstat (limited to 'lua/lspconfig')
57 files changed, 3547 insertions, 0 deletions
diff --git a/lua/lspconfig/als.lua b/lua/lspconfig/als.lua new file mode 100755 index 00000000..c5c4a116 --- /dev/null +++ b/lua/lspconfig/als.lua @@ -0,0 +1,104 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local server_name = 'als' +local bin_name = 'ada_language_server' + +if vim.fn.has('win32') == 1 then + bin_name = 'ada_language_server.exe' +end + +local function make_installer() + local install_dir = util.path.join{util.base_install_dir, server_name} + + local url = 'https://dl.bintray.com/reznikmm/ada-language-server/linux-latest.tar.gz' + local download_target = util.path.join{install_dir, "als.tar.gz"} + local extracted_dir = "linux" + local extract_cmd = string.format("tar -xzf '%s' --one-top-level='%s'", download_target, install_dir) + + if vim.fn.has('win32') == 1 then + url = 'https://dl.bintray.com/reznikmm/ada-language-server/win32-latest.zip' + download_target = util.path.join{install_dir, 'win32-latest.zip'} + extracted_dir = 'win32' + extract_cmd = string.format("unzip -o '%s' -d '%s'", download_target, install_dir) + elseif vim.fn.has('mac') == 1 then + url = 'https://dl.bintray.com/reznikmm/ada-language-server/darwin-latest.tar.gz' + download_target = util.path.join{install_dir, 'darwin-latest.tar.gz'} + extracted_dir = 'darwin' + extract_cmd = string.format("tar -xzf '%s' --one-top-level='%s'", download_target, install_dir) + end + + local download_cmd = string.format('curl -fLo "%s" --create-dirs "%s"', download_target, url) + + local bin_path = util.path.join{install_dir, extracted_dir, bin_name} + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(server_name, "is already installed") + return + end + if not (util.has_bins("curl")) then + error('Need "curl" to install this.') + return + end + vim.fn.mkdir(install_dir, 'p') + vim.fn.system(download_cmd) + vim.fn.system(extract_cmd) + end + function X.info() + return { + is_installed = util.path.exists(bin_path); + install_dir = install_dir; + cmd = { bin_path }; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = install_info.cmd + end + end + return X +end + +local installer = make_installer() + +configs[server_name] = { + default_config = { + cmd = {bin_name}; + filetypes = {"ada"}; + -- *.gpr and *.adc would be nice to have here + root_dir = util.root_pattern("Makefile", ".git"); + }; + on_new_config = function(config) + installer.configure(config) + end; + docs = { + package_json = "https://raw.githubusercontent.com/AdaCore/ada_language_server/master/integration/vscode/ada/package.json"; + description = [[ +https://github.com/AdaCore/ada_language_server + +Ada language server. Use `LspInstall als` to install it. + +Can be configured by passing a "settings" object to `als.setup{}`: + +```lua +require('lspconfig').als.setup{ + settings = { + ada = { + projectFile = "project.gpr"; + scenarioVariables = { ... }; + } + } +} +``` +]]; + default_config = { + root_dir = [[util.root_pattern("Makefile", ".git")]]; + }; + }; +}; + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/angularls.lua b/lua/lspconfig/angularls.lua new file mode 100644 index 00000000..f579909f --- /dev/null +++ b/lua/lspconfig/angularls.lua @@ -0,0 +1,72 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = 'angularls' +local bin_name = server_name +local install_loc = util.base_install_dir .. '/' .. server_name +local script_loc = install_loc .. '/node_modules/@angular/language-server/index.js' +local bin_loc = install_loc .. '/node_modules/.bin/angularls' + +local installer = util.npm_installer { + server_name = server_name; + packages = { '@angular/language-server' }; + binaries = { bin_name }; + -- angular-language-service doesn't expose a binary, so we create an execution wrapper. + post_install_script = + 'echo "#! /bin/sh\n' .. 'node ' .. script_loc .. ' \\$*' .. '" > ' .. bin_loc .. '\n' .. + 'chmod +x ' .. bin_loc; +} + +-- Angular requires a node_modules directory to probe for @angular/language-service and typescript +-- in order to use your projects configured versions. +-- This defaults to the vim cwd, but will get overwritten by the resolved root of the file. +local function get_probe_dir(root_dir) + local project_root = util.find_node_modules_ancestor(root_dir) + + return project_root and (project_root .. '/node_modules') or '' +end + +local default_probe_dir = get_probe_dir(vim.fn.getcwd()) + +configs[server_name] = { + default_config = { + cmd = { + bin_loc, + '--stdio', + '--tsProbeLocations', default_probe_dir, + '--ngProbeLocations', default_probe_dir + }; + filetypes = {'typescript', 'html', 'typescriptreact', 'typescript.tsx'}; + -- Check for angular.json or .git first since that is the root of the project. + -- Don't check for tsconfig.json or package.json since there are multiple of these + -- in an angular monorepo setup. + root_dir = util.root_pattern('angular.json', '.git'); + }; + on_new_config = function(new_config, new_root_dir) + local new_probe_dir = get_probe_dir(new_root_dir) + + -- We need to check our probe directories because they may have changed. + new_config.cmd = { + bin_loc, + '--stdio', + '--tsProbeLocations', new_probe_dir, + '--ngProbeLocations', new_probe_dir + } + end; + docs = { + description = [[ +https://github.com/angular/vscode-ng-language-service + +`angular-language-server` can be installed via `:LspInstall angularls` + +If you prefer to install this yourself you can through npm `npm install @angular/language-server`. +Be aware there is no global binary and must be run via `node_modules/@angular/language-server/index.js` + ]]; + default_config = { + root_dir = [[root_pattern("angular.json", ".git")]]; + }; + } +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info diff --git a/lua/lspconfig/bashls.lua b/lua/lspconfig/bashls.lua new file mode 100644 index 00000000..59b21079 --- /dev/null +++ b/lua/lspconfig/bashls.lua @@ -0,0 +1,44 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "bashls" +local bin_name = "bash-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "bash-language-server" }; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {"bash-language-server", "start"}; + filetypes = {"sh"}; + root_dir = util.path.dirname; + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/mads-hartmann/bash-language-server + +Language server for bash, written using tree sitter in typescript. +]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +}; + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/ccls.lua b/lua/lspconfig/ccls.lua new file mode 100644 index 00000000..d167249d --- /dev/null +++ b/lua/lspconfig/ccls.lua @@ -0,0 +1,24 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.ccls = { + default_config = { + cmd = {"ccls"}; + filetypes = {"c", "cpp", "objc", "objcpp"}; + root_dir = util.root_pattern("compile_commands.json", "compile_flags.txt", ".git"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/MaskRay/vscode-ccls/master/package.json"; + description = [[ +https://github.com/MaskRay/ccls/wiki + +ccls relies on a [JSON compilation database](https://clang.llvm.org/docs/JSONCompilationDatabase.html) specified +as compile_commands.json or, for simpler projects, a compile_flags.txt. +For details on how to automatically generate one using CMake look [here](https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html). +]]; + default_config = { + root_dir = [[root_pattern("compile_commands.json", "compile_flags.txt", ".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/clangd.lua b/lua/lspconfig/clangd.lua new file mode 100644 index 00000000..d165edbb --- /dev/null +++ b/lua/lspconfig/clangd.lua @@ -0,0 +1,60 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +-- https://clangd.llvm.org/extensions.html#switch-between-sourceheader +local function switch_source_header(bufnr) + bufnr = util.validate_bufnr(bufnr) + local params = { uri = vim.uri_from_bufnr(bufnr) } + vim.lsp.buf_request(bufnr, 'textDocument/switchSourceHeader', params, function(err, _, result) + if err then error(tostring(err)) end + if not result then print ("Corresponding file can’t be determined") return end + vim.api.nvim_command('edit '..vim.uri_to_fname(result)) + end) +end + +local root_pattern = util.root_pattern("compile_commands.json", "compile_flags.txt", ".git") +configs.clangd = { + default_config = util.utf8_config { + cmd = {"clangd", "--background-index"}; + filetypes = {"c", "cpp", "objc", "objcpp"}; + root_dir = function(fname) + local filename = util.path.is_absolute(fname) and fname + or util.path.join(vim.loop.cwd(), fname) + return root_pattern(filename) or util.path.dirname(filename) + end; + capabilities = { + textDocument = { + completion = { + editsNearCursor = true + } + } + }, + }; + commands = { + ClangdSwitchSourceHeader = { + function() + switch_source_header(0) + end; + description = "Switch between source/header"; + }; + }; + docs = { + description = [[ +https://clang.llvm.org/extra/clangd/Installation.html + +**NOTE:** Clang >= 9 is recommended! See [this issue for more](https://github.com/neovim/nvim-lsp/issues/23). + +clangd relies on a [JSON compilation database](https://clang.llvm.org/docs/JSONCompilationDatabase.html) specified +as compile_commands.json or, for simpler projects, a compile_flags.txt. +For details on how to automatically generate one using CMake look [here](https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html). +]]; + default_config = { + root_dir = [[root_pattern("compile_commands.json", "compile_flags.txt", ".git") or dirname]]; + on_init = [[function to handle changing offsetEncoding]]; + capabilities = [[default capabilities, with offsetEncoding utf-8]]; + }; + }; +} + +configs.clangd.switch_source_header = switch_source_header +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/clojure_lsp.lua b/lua/lspconfig/clojure_lsp.lua new file mode 100644 index 00000000..f1ec6932 --- /dev/null +++ b/lua/lspconfig/clojure_lsp.lua @@ -0,0 +1,22 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.clojure_lsp = { + default_config = { + cmd = {"clojure-lsp"}; + filetypes = {"clojure", "edn"}; + root_dir = util.root_pattern("project.clj", "deps.edn", ".git"); + }; + docs = { + description = [[ +https://github.com/snoe/clojure-lsp + +Clojure Language Server +]]; + default_config = { + root_dir = [[root_pattern("project.clj", "deps.edn", ".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 + diff --git a/lua/lspconfig/cmake.lua b/lua/lspconfig/cmake.lua new file mode 100755 index 00000000..9dbcf717 --- /dev/null +++ b/lua/lspconfig/cmake.lua @@ -0,0 +1,25 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.cmake = { + default_config = { + cmd = {"cmake-language-server"}; + filetypes = {"cmake"}; + root_dir = util.root_pattern(".git", "compile_commands.json", "build"); + init_options = { + buildDirectory = "build", + } + }; + docs = { + description = [[ +https://github.com/regen100/cmake-language-server + +CMake LSP Implementation +]]; + default_config = { + root_dir = [[root_pattern(".git", "compile_commands.json", "build")]]; + }; + }; +}; + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/codeqlls.lua b/lua/lspconfig/codeqlls.lua new file mode 100644 index 00000000..ffe08df4 --- /dev/null +++ b/lua/lspconfig/codeqlls.lua @@ -0,0 +1,52 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "codeqlls" + +local root_pattern = util.root_pattern("qlpack.yml") + +configs[server_name] = { + default_config = { + cmd = {"codeql", "execute", "language-server", "--check-errors", "ON_CHANGE", "-q"}; + filetypes = {'ql'}; + root_dir = function(fname) + return root_pattern("qlpack.yml") or util.path.dirname(fname) + end; + log_level = vim.lsp.protocol.MessageType.Warning; + before_init = function(initialize_params, config) + initialize_params['workspaceFolders'] = {{ + name = 'workspace', + uri = initialize_params['rootUri'] + }} + end; + settings = { + search_path = vim.empty_dict() + }; + }; + docs = { + package_json = "https://raw.githubusercontent.com/github/vscode-codeql/main/extensions/ql-vscode/package.json"; + description = [[ +Reference: +https://help.semmle.com/codeql/codeql-cli.html + +Binaries: +https://github.com/github/codeql-cli-binaries + ]]; + default_config = { + settings = { + search_path = [[list containing all search paths, eg: '~/codeql-home/codeql-repo']]; + }; + }; + }; + on_new_config = function(config) + if type(config.settings.search_path) == 'table' and not vim.tbl_isempty(config.settings.search_path) then + local search_path = "--search-path=" + for _, path in ipairs(config.settings.search_path) do + search_path = search_path..vim.fn.expand(path)..":" + end + config.cmd = {"codeql", "execute", "language-server", "--check-errors", "ON_CHANGE", "-q", search_path} + else + config.cmd = {"codeql", "execute", "language-server", "--check-errors", "ON_CHANGE", "-q"} + end + end; +} diff --git a/lua/lspconfig/configs.lua b/lua/lspconfig/configs.lua new file mode 100644 index 00000000..16ef9949 --- /dev/null +++ b/lua/lspconfig/configs.lua @@ -0,0 +1,214 @@ +local util = require 'lspconfig/util' +local api, validate, lsp = vim.api, vim.validate, vim.lsp +local tbl_extend = vim.tbl_extend + +local configs = {} + +function configs.__newindex(t, config_name, config_def) + validate { + name = {config_name, 's'}; + default_config = {config_def.default_config, 't'}; + on_new_config = {config_def.on_new_config, 'f', true}; + on_attach = {config_def.on_attach, 'f', true}; + commands = {config_def.commands, 't', true}; + } + if config_def.commands then + for k, v in pairs(config_def.commands) do + validate { + ['command.name'] = {k, 's'}; + ['command.fn'] = {v[1], 'f'}; + } + end + else + config_def.commands = {} + end + + local M = {} + + local default_config = tbl_extend("keep", config_def.default_config, util.default_config) + + -- Force this part. + default_config.name = config_name + + -- The config here is the one which will be instantiated for the new server, + -- which is why this is a function, so that it can refer to the settings + -- object on the server. + local function add_callbacks(config) + config.callbacks["window/logMessage"] = function(err, method, params, client_id) + if params and params.type <= config.log_level then + -- TODO(ashkan) remove this after things have settled. + assert(lsp.callbacks, "Update to Nvim HEAD. This is an incompatible interface.") + assert(lsp.callbacks["window/logMessage"], "Callback for window/logMessage notification is not defined") + lsp.callbacks["window/logMessage"](err, method, params, client_id) + end + end + + config.callbacks["window/showMessage"] = function(err, method, params, client_id) + if params and params.type <= config.message_level then + -- TODO(ashkan) remove this after things have settled. + assert(lsp.callbacks and lsp.callbacks[method], "Update to Nvim HEAD. This is an incompatible interface.") + assert(lsp.callbacks["window/showMessage"], "Callback for window/showMessage notification is not defined") + lsp.callbacks["window/showMessage"](err, method, params, client_id) + end + end + + config.callbacks["workspace/configuration"] = function(err, method, params, client_id) + if err then error(tostring(err)) end + if not params.items then + return {} + end + + local result = {} + for _, item in ipairs(params.items) do + if item.section then + local value = util.lookup_section(config.settings, item.section) or vim.NIL + -- For empty sections with no explicit '' key, return settings as is + if value == vim.NIL and item.section == '' then + value = config.settings or vim.NIL + end + table.insert(result, value) + end + end + return result + end + end + + function M.setup(config) + validate { + root_dir = {config.root_dir, 'f', default_config.root_dir ~= nil}; + filetypes = {config.filetype, 't', true}; + on_new_config = {config.on_new_config, 'f', true}; + on_attach = {config.on_attach, 'f', true}; + commands = {config.commands, 't', true}; + } + if config.commands then + for k, v in pairs(config.commands) do + validate { + ['command.name'] = {k, 's'}; + ['command.fn'] = {v[1], 'f'}; + } + end + end + + config = tbl_extend("keep", config, default_config) + + local trigger + if config.filetypes then + trigger = "FileType "..table.concat(config.filetypes, ',') + else + trigger = "BufReadPost *" + end + api.nvim_command(string.format( + "autocmd %s lua require'lspconfig'[%q].manager.try_add()" + , trigger + , config.name + )) + + local get_root_dir = config.root_dir + + -- In the case of a reload, close existing things. + if M.manager then + for _, client in ipairs(M.manager.clients()) do + client.stop(true) + end + M.manager = nil + end + + local make_config = function(_root_dir) + local new_config = util.tbl_deep_extend("keep", vim.empty_dict(), config) + new_config = util.tbl_deep_extend('keep', new_config, default_config) + new_config.capabilities = new_config.capabilities or lsp.protocol.make_client_capabilities() + new_config.capabilities = util.tbl_deep_extend('keep', new_config.capabilities, { + workspace = { + configuration = true; + } + }) + + add_callbacks(new_config) + if config_def.on_new_config then + pcall(config_def.on_new_config, new_config, _root_dir) + end + if config.on_new_config then + pcall(config.on_new_config, new_config, _root_dir) + end + + new_config.on_init = util.add_hook_after(new_config.on_init, function(client, _result) + function client.workspace_did_change_configuration(settings) + if not settings then return end + if vim.tbl_isempty(settings) then + settings = {[vim.type_idx]=vim.types.dictionary} + end + return client.notify('workspace/didChangeConfiguration', { + settings = settings; + }) + end + if not vim.tbl_isempty(new_config.settings) then + client.workspace_did_change_configuration(new_config.settings) + end + end) + + -- Save the old _on_attach so that we can reference it via the BufEnter. + new_config._on_attach = new_config.on_attach + new_config.on_attach = vim.schedule_wrap(function(client, bufnr) + if bufnr == api.nvim_get_current_buf() then + M._setup_buffer(client.id) + else + api.nvim_command(string.format( + "autocmd BufEnter <buffer=%d> ++once lua require'lspconfig'[%q]._setup_buffer(%d)" + , bufnr + , config_name + , client.id + )) + end + end) + + new_config.root_dir = _root_dir + return new_config + end + + local manager = util.server_per_root_dir_manager(function(_root_dir) + return make_config(_root_dir) + end) + + function manager.try_add() + if vim.bo.buftype == 'nofile' then + return + end + local root_dir = get_root_dir(api.nvim_buf_get_name(0), api.nvim_get_current_buf()) + local id = manager.add(root_dir) + if id then + lsp.buf_attach_client(0, id) + end + end + + M.manager = manager + M.make_config = make_config + end + + function M._setup_buffer(client_id) + local client = lsp.get_client_by_id(client_id) + if client.config._on_attach then + client.config._on_attach(client) + end + if client.config.commands and not vim.tbl_isempty(client.config.commands) then + M.commands = util.tbl_deep_extend("force", M.commands, client.config.commands) + end + if not M.commands_created and not vim.tbl_isempty(M.commands) then + -- Create the module commands + util.create_module_commands(config_name, M.commands) + M.commands_created = true + end + end + + M.commands_created = false + M.commands = config_def.commands + M.name = config_name + M.document_config = config_def + + rawset(t, config_name, M) + + return M +end + +return setmetatable({}, configs) +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/cssls.lua b/lua/lspconfig/cssls.lua new file mode 100644 index 00000000..7b50950a --- /dev/null +++ b/lua/lspconfig/cssls.lua @@ -0,0 +1,56 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "cssls" +local bin_name = "css-languageserver" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "vscode-css-languageserver-bin" }; + binaries = {bin_name}; +} + +local root_pattern = util.root_pattern("package.json") + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"css", "scss", "less"}; + root_dir = function(fname) + return root_pattern(fname) or vim.loop.os_homedir() + end; + settings = { + css = { validate = true }, + scss = { validate = true }, + less = { validate = true } + }; + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/vscode-langservers/vscode-css-languageserver-bin + +`css-languageserver` can be installed via `:LspInstall cssls` or by yourself with `npm`: +```sh +npm install -g vscode-css-languageserver-bin +``` +]]; + default_config = { + root_dir = [[root_pattern("package.json")]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/dartls.lua b/lua/lspconfig/dartls.lua new file mode 100644 index 00000000..1baf05d6 --- /dev/null +++ b/lua/lspconfig/dartls.lua @@ -0,0 +1,55 @@ +local util = require 'lspconfig/util' +local configs = require 'lspconfig/configs' + +local server_name = "dartls" +local bin_name = "dart" + +local find_dart_sdk_root_path = function() + if vim.fn["executable"]("flutter") == 1 then + local flutter_path = vim.fn["resolve"](vim.fn["exepath"]("flutter")) + local flutter_bin = vim.fn["fnamemodify"](flutter_path, ":h") + return flutter_bin.."/cache/dart-sdk/bin/dart" + elseif vim.fn["executable"]("dart") == 1 then + return vim.fn["resolve"](vim.fn["exepath"]("dart")) + else + return '' + end +end + +local analysis_server_snapshot_path = function() + local dart_sdk_root_path = vim.fn["fnamemodify"](find_dart_sdk_root_path(), ":h") + local snapshot = dart_sdk_root_path.."/snapshots/analysis_server.dart.snapshot" + + if vim.fn["has"]("win32") == 1 or vim.fn["has"]("win64") == 1 then + snapshot = snapshot:gsub("/", "\\") + end + + return snapshot +end + +configs[server_name] = { + default_config = { + cmd = {bin_name, analysis_server_snapshot_path(), "--lsp"}; + filetypes = {"dart"}; + root_dir = util.root_pattern("pubspec.yaml"); + init_options = { + onlyAnalyzeProjectsWithOpenFiles = "false", + suggestFromUnimportedLibraries = "true", + closingLabels = "true", + outline = "true", + flutterOutline= "false" + }; + }; + docs = { + package_json = "https://raw.githubusercontent.com/Dart-Code/Dart-Code/master/package.json"; + description = [[ +https://github.com/dart-lang/sdk/tree/master/pkg/analysis_server/tool/lsp_spec + +Language server for dart. +]]; + default_config = { + root_dir = [[root_pattern("pubspec.yaml")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/diagnosticls.lua b/lua/lspconfig/diagnosticls.lua new file mode 100644 index 00000000..c4f26220 --- /dev/null +++ b/lua/lspconfig/diagnosticls.lua @@ -0,0 +1,45 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "diagnosticls" +local bin_name = "diagnostic-languageserver" + +local installer = util.npm_installer { + server_name = server_name; + packages = { bin_name }; + binaries = { bin_name }; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}, + filetypes = {}, + root_dir = util.path.dirname, + }, + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name], "--stdio"} + end + end + end; + docs = { + description = [[ +https://github.com/iamcco/diagnostic-languageserver + +Diagnostic language server integrate with linters. +]]; + default_config = { + filetypes = "Empty by default, override to add filetypes", + root_dir = "Vim's starting directory"; + init_options = "Configuration from https://github.com/iamcco/diagnostic-languageserver#config--document"; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info diff --git a/lua/lspconfig/dockerls.lua b/lua/lspconfig/dockerls.lua new file mode 100644 index 00000000..572e4701 --- /dev/null +++ b/lua/lspconfig/dockerls.lua @@ -0,0 +1,47 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "dockerls" +local bin_name = "docker-langserver" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "dockerfile-language-server-nodejs" }; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"Dockerfile", "dockerfile"}; + root_dir = util.root_pattern("Dockerfile"); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/rcjsuen/dockerfile-language-server-nodejs + +`docker-langserver` can be installed via `:LspInstall dockerls` or by yourself with `npm`: +```sh +npm install -g dockerfile-language-server-nodejs +``` + ]]; + default_config = { + root_dir = [[root_pattern("Dockerfile")]]; + }; + }; +}; + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/efm.lua b/lua/lspconfig/efm.lua new file mode 100644 index 00000000..d4fc88ac --- /dev/null +++ b/lua/lspconfig/efm.lua @@ -0,0 +1,25 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "efm" +local bin_name = "efm-langserver" + + +configs[server_name] = { + default_config = { + cmd = {bin_name}; + root_dir = util.root_pattern(".git"); + }; + + docs = { + description = [[ +https://github.com/mattn/efm-langserver + +General purpose Language Server that can use specified error message format generated from specified command. +]]; + default_config = { + root_dir = [[root_pattern(".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/elixirls.lua b/lua/lspconfig/elixirls.lua new file mode 100644 index 00000000..fcd91a04 --- /dev/null +++ b/lua/lspconfig/elixirls.lua @@ -0,0 +1,110 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "elixirls" +local bin_name = "elixir-ls" +local cmd = "language_server" + +if vim.fn.has('mac') == 1 or vim.fn.has('unix') == 1 then + cmd = cmd..".sh" +elseif vim.fn.has('win32') == 1 or vim.fn.has('win64') == 1 then + cmd = cmd..".bat" +else + error("System is not supported, try to install manually.") + return +end + +local function make_installer() + local P = util.path.join + local install_dir = P{util.base_install_dir, server_name} + local cmd_path = P{install_dir, bin_name, "release", cmd} + + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(server_name, "is already installed.") + return + end + + if not (util.has_bins("elixir") and util.has_bins("erl")) then + error("Need elixir and erl to install this") + return + end + + local script = [=[ + set -e + + # clone project + git clone https://github.com/elixir-lsp/elixir-ls + cd elixir-ls + + # fetch dependencies and compile + mix deps.get && mix compile + + # install executable + mix elixir_ls.release -o release + ]=] + vim.fn.mkdir(install_info.install_dir, "p") + util.sh(script, install_info.install_dir) + end + + function X.info() + return { + is_installed = util.path.exists(cmd_path); + install_dir = install_dir; + cmd = { cmd_path }; + } + end + + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = install_info.cmd + end + end + return X +end + +local installer = make_installer() + +configs[server_name] = { + default_config = { + cmd = { cmd }; + filetypes = {"elixir", "eelixir"}; + root_dir = function(fname) + return util.root_pattern("mix.exs", ".git")(fname) or vim.loop.os_homedir() + end; + }; + on_new_config = function(config) + installer.configure(config) + end; + docs = { + package_json = "https://raw.githubusercontent.com/JakeBecker/vscode-elixir-ls/master/package.json"; + description = [[ +https://github.com/elixir-lsp/elixir-ls + +`elixir-ls` can be installed via `:LspInstall elixirls` or by yourself by following the instructions [here](https://github.com/elixir-lsp/elixir-ls#building-and-running). + +This language server does not provide a global binary, but must be installed manually. The command `:LspInstaller elixirls` makes an attempt at installing the binary by +Fetching the elixir-ls repository from GitHub, compiling it and then installing it. + +```lua +require'lspconfig'.elixirls.setup{ + -- Unix + cmd = { "path/to/language_server.sh" }; + -- Windows + cmd = { "path/to/language_server.bat" }; + ... +} +``` +]]; + default_config = { + root_dir = [[root_pattern("mix.exs", ".git") or vim.loop.os_homedir()]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/elmls.lua b/lua/lspconfig/elmls.lua new file mode 100644 index 00000000..c35824c4 --- /dev/null +++ b/lua/lspconfig/elmls.lua @@ -0,0 +1,72 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local lsp = vim.lsp +local api = vim.api + +local server_name = "elmls" +local bin_name = "elm-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "elm", "elm-test", "elm-format", "@elm-tooling/elm-language-server" }; + binaries = {bin_name, "elm", "elm-format", "elm-test"}; +} + +local default_capabilities = lsp.protocol.make_client_capabilities() +default_capabilities.offsetEncoding = {"utf-8", "utf-16"} +local elm_root_pattern = util.root_pattern("elm.json") + +configs[server_name] = { + default_config = { + cmd = {bin_name}; + -- TODO(ashkan) if we comment this out, it will allow elmls to operate on elm.json. It seems like it could do that, but no other editor allows it right now. + filetypes = {"elm"}; + root_dir = function(fname) + local filetype = api.nvim_buf_get_option(0, 'filetype') + if filetype == 'elm' or (filetype == 'json' and fname:match("elm%.json$")) then + return elm_root_pattern(fname) + end + end; + init_options = { + elmPath = "elm", + elmFormatPath = "elm-format", + elmTestPath = "elm-test", + elmAnalyseTrigger = "change", + }; + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + new_config.init_options = util.tbl_deep_extend('force', new_config.init_options, { + elmPath = install_info.binaries["elm"]; + elmFormatPath = install_info.binaries["elm-format"]; + elmTestPath = install_info.binaries["elm-test"]; + }) + end + end; + docs = { + package_json = "https://raw.githubusercontent.com/elm-tooling/elm-language-client-vscode/master/package.json"; + description = [[ +https://github.com/elm-tooling/elm-language-server#installation + +If you don't want to use Nvim to install it, then you can use: +```sh +npm install -g elm elm-test elm-format @elm-tooling/elm-language-server +``` +]]; + default_config = { + root_dir = [[root_pattern("elm.json")]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 + diff --git a/lua/lspconfig/flow.lua b/lua/lspconfig/flow.lua new file mode 100644 index 00000000..5e0abab3 --- /dev/null +++ b/lua/lspconfig/flow.lua @@ -0,0 +1,30 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.flow = { + default_config = { + cmd = {"npx", "--no-install", "flow","lsp"}; + filetypes = {"javascript", "javascriptreact", "javascript.jsx"}; + root_dir = util.root_pattern(".flowconfig"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/flowtype/flow-for-vscode/master/package.json"; + description = [[ +https://flow.org/ +https://github.com/facebook/flow + +See below for how to setup Flow itself. +https://flow.org/en/docs/install/ + +See below for lsp command options. + +```sh +npx flow lsp --help +``` + ]]; + default_config = { + root_dir = [[root_pattern(".flowconfig")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/fortls.lua b/lua/lspconfig/fortls.lua new file mode 100644 index 00000000..7a66c703 --- /dev/null +++ b/lua/lspconfig/fortls.lua @@ -0,0 +1,25 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.fortls = { + default_config = { + cmd = {"fortls"}; + filetypes = {"fortran"}; + root_dir = util.root_pattern(".fortls"); + settings = { + nthreads = 1, + }; + }; + docs = { + package_json = "https://raw.githubusercontent.com/hansec/vscode-fortran-ls/master/package.json"; + description = [[ +https://github.com/hansec/fortran-language-server + +Fortran Language Server for the Language Server Protocol + ]]; + default_config = { + root_dir = [[root_pattern(".fortls")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/gdscript.lua b/lua/lspconfig/gdscript.lua new file mode 100644 index 00000000..ecd3288f --- /dev/null +++ b/lua/lspconfig/gdscript.lua @@ -0,0 +1,22 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.gdscript = { + default_config = { + cmd = {"nc", "localhost", "6008"}; + filetypes = {"gd", "gdscript", "gdscript3"}; + root_dir = util.root_pattern("project.godot", ".git"); + }; + docs = { + description = [[ +https://github.com/godotengine/godot + +Language server for GDScript, used by Godot Engine. +]]; + default_config = { + root_dir = util.root_pattern("project.godot", ".git"); + }; + }; +}; + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/ghcide.lua b/lua/lspconfig/ghcide.lua new file mode 100644 index 00000000..c427d599 --- /dev/null +++ b/lua/lspconfig/ghcide.lua @@ -0,0 +1,24 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.ghcide = { + default_config = { + cmd = { "ghcide", "--lsp" }; + filetypes = { "haskell", "lhaskell" }; + root_dir = util.root_pattern("stack.yaml", "hie-bios", "BUILD.bazel", "cabal.config", "package.yaml"); + }; + + docs = { + package_json = "https://raw.githubusercontent.com/digital-asset/ghcide/master/extension/package.json"; + description = [[ +https://github.com/digital-asset/ghcide + +A library for building Haskell IDE tooling. +]]; + default_config = { + root_dir = [[root_pattern("stack.yaml", "hie-bios", "BUILD.bazel", "cabal.config", "package.yaml")]]; + }; + }; +}; + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/gopls.lua b/lua/lspconfig/gopls.lua new file mode 100644 index 00000000..08eacc15 --- /dev/null +++ b/lua/lspconfig/gopls.lua @@ -0,0 +1,23 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.gopls = { + default_config = { + cmd = {"gopls"}; + filetypes = {"go", "gomod"}; + root_dir = util.root_pattern("go.mod", ".git"); + }; + -- on_new_config = function(new_config) end; + -- on_attach = function(client, bufnr) end; + docs = { + description = [[ +https://github.com/golang/tools/tree/master/gopls + +Google's lsp server for golang. +]]; + default_config = { + root_dir = [[root_pattern("go.mod", ".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/health.lua b/lua/lspconfig/health.lua new file mode 100644 index 00000000..3abab080 --- /dev/null +++ b/lua/lspconfig/health.lua @@ -0,0 +1,26 @@ +local M = {} +function M.check_health() + local configs = require 'lspconfig/configs' + + for _, top_level_config in pairs(configs) do + -- If users execute `:LspInstall` or `:LspInstallInfo`, + -- a config is required but is not added make_config function. + if not (top_level_config.make_config == nil) then + -- the folder needs to exist + local config = top_level_config.make_config(".") + + local status, cmd = pcall(vim.lsp._cmd_parts, config.cmd) + if not status then + vim.fn['health#report_error'](string.format("%s: config.cmd error, %s", config.name, cmd)) + else + if not (vim.fn.executable(cmd) == 1) then + vim.fn['health#report_error'](string.format("%s: The given command %q is not executable.", config.name, cmd)) + else + vim.fn['health#report_info'](string.format("%s: configuration checked.", config.name)) + end + end + end + end +end + +return M diff --git a/lua/lspconfig/hie.lua b/lua/lspconfig/hie.lua new file mode 100644 index 00000000..f57326dc --- /dev/null +++ b/lua/lspconfig/hie.lua @@ -0,0 +1,38 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.hie = { + default_config = { + cmd = {"hie-wrapper", "--lsp"}; + filetypes = {"haskell"}; + root_dir = util.root_pattern("stack.yaml", "package.yaml", ".git"); + }; + + docs = { + package_json = "https://raw.githubusercontent.com/alanz/vscode-hie-server/master/package.json"; + description = [[ +https://github.com/haskell/haskell-ide-engine + +the following init_options are supported (see https://github.com/haskell/haskell-ide-engine#configuration): +```lua +init_options = { + languageServerHaskell = { + hlintOn = bool; + maxNumberOfProblems = number; + diagnosticsDebounceDuration = number; + liquidOn = bool (default false); + completionSnippetsOn = bool (default true); + formatOnImportOn = bool (default true); + formattingProvider = string (default "brittany", alternate "floskell"); + } +} +``` + ]]; + + default_config = { + root_dir = [[root_pattern("stack.yaml", "package.yaml", ".git")]]; + }; + }; +}; + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/hls.lua b/lua/lspconfig/hls.lua new file mode 100644 index 00000000..9c29b82c --- /dev/null +++ b/lua/lspconfig/hls.lua @@ -0,0 +1,24 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.hls = { + default_config = { + cmd = {"haskell-language-server-wrapper", "--lsp"}; + filetypes = {"haskell", "lhaskell"}; + root_dir = util.root_pattern("*.cabal", "stack.yaml", "cabal.project", "package.yaml", "hie.yaml"); + }; + + docs = { + description = [[ +https://github.com/haskell/haskell-language-server + +Haskell Language Server + ]]; + + default_config = { + root_dir = [[root_pattern("*.cabal", "stack.yaml", "cabal.project", "package.yaml", "hie.yaml")]]; + }; + }; +}; + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/html.lua b/lua/lspconfig/html.lua new file mode 100644 index 00000000..a9636222 --- /dev/null +++ b/lua/lspconfig/html.lua @@ -0,0 +1,54 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "html" +local bin_name = "html-languageserver" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "vscode-html-languageserver-bin" }; + binaries = {bin_name}; +} + +local root_pattern = util.root_pattern("package.json") + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"html"}; + root_dir = function(fname) + return root_pattern(fname) or vim.loop.os_homedir() + end; + settings = {}; + init_options = { + embeddedLanguages = { css= true, javascript= true }, + configurationSection = { 'html', 'css', 'javascript' }, + } + + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/vscode-langservers/vscode-html-languageserver-bin + +`html-languageserver` can be installed via `:LspInstall html` or by yourself with `npm`: +```sh +npm install -g vscode-html-languageserver-bin +``` +]]; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/intelephense.lua b/lua/lspconfig/intelephense.lua new file mode 100644 index 00000000..7e381349 --- /dev/null +++ b/lua/lspconfig/intelephense.lua @@ -0,0 +1,68 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "intelephense" +local bin_name = "intelephense" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "intelephense" }; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"php"}; + root_dir = function (pattern) + local cwd = vim.loop.cwd(); + local root = util.root_pattern("composer.json", ".git")(pattern); + + -- prefer cwd if root is a descendant + return util.path.is_descendant(cwd, root) and cwd or root; + end; + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://intelephense.com/ + +`intelephense` can be installed via `:LspInstall intelephense` or by yourself with `npm`: +```sh +npm install -g intelephense +``` +]]; + default_config = { + root_dir = [[root_pattern("composer.json", ".git")]]; + init_options = [[{ + storagePath = Optional absolute path to storage dir. Defaults to os.tmpdir(). + globalStoragePath = Optional absolute path to a global storage dir. Defaults to os.homedir(). + licenceKey = Optional licence key or absolute path to a text file containing the licence key. + clearCache = Optional flag to clear server state. State can also be cleared by deleting {storagePath}/intelephense + -- See https://github.com/bmewburn/intelephense-docs#initialisation-options + }]]; + settings = [[{ + intelephense = { + files = { + maxSize = 1000000; + }; + }; + -- See https://github.com/bmewburn/intelephense-docs#configuration-options + }]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/jdtls.lua b/lua/lspconfig/jdtls.lua new file mode 100644 index 00000000..be9ba6e8 --- /dev/null +++ b/lua/lspconfig/jdtls.lua @@ -0,0 +1,138 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local callbacks = require 'vim.lsp.callbacks' +local path = util.path + +local server_name = "jdtls" + +local function make_installer() + local install_dir = path.join { util.base_install_dir, server_name } + local tar_name = "jdt-language-server-latest.tar.gz" + local script = string.format([[ + curl -LO http://download.eclipse.org/jdtls/snapshots/%s > %s + tar xf %s + ]], tar_name, tar_name, tar_name) + local launcher_ls = "ls " .. path.join { install_dir, "plugins", "org.eclipse.equinox.launcher_*.jar" } + + local X = {} + + function X.install() + if not util.has_bins("curl", "tar") then + error('Need the binaries "curl", "tar" to install this.') + return + end + + vim.fn.mkdir(install_dir, "p") + util.sh(script, install_dir) + end + + function X.info() + return { + is_installed = util.path.exists(install_dir, 'features') ~= false; + install_dir = install_dir; + } + end + + function X.get_os_config() + if vim.fn.has("osx") == 1 then + return "config_mac" + elseif vim.fn.has("unix") == 1 then + return "config_linux" + else + return "config_win" + end + end + + function X.get_launcher() + local file = io.popen(launcher_ls) + local results = {} + + for line in file:lines() do + table.insert(results, line) + end + + if #results == 1 then + return results[1] + end + + error("Could not find launcher for jdtls.") + end + + function X.configure(config) + local install_info = X.info() + local launcher_path = X.get_launcher() + + if install_info.is_installed then + config.cmd = vim.list_extend( + vim.list_extend( + { + "java", + "-Declipse.application=org.eclipse.jdt.ls.core.id1", + "-Dosgi.bundles.defaultStartLevel=4", + "-Declipse.product=org.eclipse.jdt.ls.core.product", + "-Dlog.level=ALL", + "-noverify", + "-Xmx1G", + }, + config.init_options.jvm_args), + { + "-jar", launcher_path, + "-configuration", path.join { install_dir, config.init_options.os_config or X.get_os_config() }, + "-data", config.init_options.workspace, + -- TODO: Handle Java versions 8 and under. This may just work... + "--add-modules=ALL-SYSTEM", + "--add-opens", "java.base/java.util=ALL-UNNAMED", + "--add-opens", "java.base/java.lang=ALL-UNNAMED" + }) + end + end + + return X +end + +local installer = make_installer() + +configs[server_name] = { + default_config = { + filetypes = { "java" }; + root_dir = util.root_pattern('.git'); + init_options = { + workspace = path.join { vim.loop.os_homedir(), "workspace" }; + jvm_args = {}; + os_config = nil; + }; + callbacks = { + -- Due to an invalid protocol implementation in the jdtls we have to + -- conform these to be spec compliant. + -- https://github.com/eclipse/eclipse.jdt.ls/issues/376 + ['textDocument/codeAction'] = function(a, b, actions) + for _,action in ipairs(actions) do + -- TODO: (steelsojka) Handle more than one edit? + if action.command == 'java.apply.workspaceEdit' then + action.edit = action.arguments[1] + end + end + + callbacks['textDocument/codeAction'](a, b, actions) + end + }; + }; + on_new_config = function(config) + installer.configure(config) + end; + docs = { + description = [[ +https://projects.eclipse.org/projects/eclipse.jdt.ls + +Language server can be installed with `:LspInstall jdtls` + +Language server for Java. + ]]; + default_config = { + root_dir = [[root_pattern(".git")]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info diff --git a/lua/lspconfig/jedi_language_server.lua b/lua/lspconfig/jedi_language_server.lua new file mode 100644 index 00000000..5fd6cbfc --- /dev/null +++ b/lua/lspconfig/jedi_language_server.lua @@ -0,0 +1,22 @@ +local configs = require 'lspconfig/configs' + +configs.jedi_language_server = { + default_config = { + cmd = {"jedi-language-server"}; + filetypes = {"python"}; + root_dir = function(fname) + return vim.fn.getcwd() + end; + }; + docs = { + description = [[ +https://github.com/pappasam/jedi-language-server + +`jedi-language-server`, a language server for Python, built on top of jedi + ]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/jsonls.lua b/lua/lspconfig/jsonls.lua new file mode 100644 index 00000000..616a0bbe --- /dev/null +++ b/lua/lspconfig/jsonls.lua @@ -0,0 +1,51 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "jsonls" +local bin_name = "vscode-json-languageserver" + +local installer = util.npm_installer { + server_name = server_name; + packages = {bin_name}; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"json"}; + root_dir = util.root_pattern(".git", vim.fn.getcwd()); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + -- this language server config is in VSCode built-in package.json + package_json = "https://raw.githubusercontent.com/microsoft/vscode/master/extensions/json-language-features/package.json"; + description = [[ +https://github.com/vscode-langservers/vscode-json-languageserver + +vscode-json-languageserver, a language server for JSON and JSON schema + +`vscode-json-languageserver` can be installed via `:LspInstall jsonls` or by yourself with `npm`: +```sh +npm install -g vscode-json-languageserver +``` +]]; + default_config = { + root_dir = [[root_pattern(".git", vim.fn.getcwd())]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/julials.lua b/lua/lspconfig/julials.lua new file mode 100644 index 00000000..f74ce7b7 --- /dev/null +++ b/lua/lspconfig/julials.lua @@ -0,0 +1,66 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local environment_directory = util.path.join(util.base_install_dir, "julials") + +configs.julials = { + default_config = { + cmd = { + "julia", "--project=" .. environment_directory, "--startup-file=no", "--history-file=no", "-e", [[ + using Pkg; + Pkg.instantiate() + using LanguageServer; using SymbolServer; + depot_path = get(ENV, "JULIA_DEPOT_PATH", "") + project_path = dirname(something(Base.current_project(pwd()), Base.load_path_expand(LOAD_PATH[2]))) + # Make sure that we only load packages from this environment specifically. + empty!(LOAD_PATH) + push!(LOAD_PATH, "@") + @info "Running language server" env=Base.load_path()[1] pwd() project_path depot_path + server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path); + server.runlinter = true; + run(server); + ]] + }; + filetypes = {'julia'}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + }; + docs = { + package_json = "https://raw.githubusercontent.com/julia-vscode/julia-vscode/master/package.json"; + description = [[ +https://github.com/julia-vscode/julia-vscode +`LanguageServer.jl` can be installed via `:LspInstall julials` or by yourself the `julia` and `Pkg`: +```sh +julia --project=]] .. environment_directory .. [[ -e 'using Pkg; Pkg.add("LanguageServer"); Pkg.add("SymbolServer")' +``` +If you want to install the LanguageServer manually, you will have to ensure that the Julia environment is stored in this location: +```vim +:lua print(require'lspconfig'.util.path.join(require'lspconfig'.util.base_install_dir, "julials")) +``` + ]]; + }; +} + +configs.julials.install = function() + + local script = [[ + julia --project=]] .. environment_directory .. [[ -e 'using Pkg; Pkg.add("LanguageServer"); Pkg.add("SymbolServer")' + ]] + + util.sh(script, vim.loop.os_homedir()) +end + +configs.julials.install_info = function() + local script = [[ + julia --project=]] .. environment_directory .. [[ -e 'using LanguageServer; using SymbolServer' + ]] + + local status = pcall(vim.fn.system, script) + + return { + is_installed = status and vim.v.shell_error == 0; + } +end + +--- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/kotlin_language_server.lua b/lua/lspconfig/kotlin_language_server.lua new file mode 100644 index 00000000..373c782c --- /dev/null +++ b/lua/lspconfig/kotlin_language_server.lua @@ -0,0 +1,52 @@ +--- default config for gradle-projects of the +--- kotlin-language-server: https://github.com/fwcd/kotlin-language-server +--- +--- This server requires vim to be aware of the kotlin-filetype. +--- You could refer for this capability to: +--- https://github.com/udalov/kotlin-vim (recommended) +--- Note that there is no LICENSE specified yet. + +local util = require 'lspconfig/util' +local configs = require 'lspconfig/configs' + +configs.kotlin_language_server = { + default_config = { + filetypes = { "kotlin" }; + root_dir = util.root_pattern("settings.gradle"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/fwcd/vscode-kotlin/master/package.json"; + description = [[ + A kotlin language server which was developed for internal usage and + released afterwards. Maintaining is not done by the original author, + but by fwcd. + + It is builded via gradle and developed on github. + Source and additional description: + https://github.com/fwcd/kotlin-language-server + ]]; + default_config = { + root_dir = [[root_pattern("settings.gradle")]]; + capabilities = [[ + smart code completion, + diagnostics, + hover, + document symbols, + definition lookup, + method signature help, + dependency resolution, + additional plugins from: https://github.com/fwcd + + Snipped of License (refer to source for full License): + + The MIT License (MIT) + + Copyright (c) 2016 George Fraser + Copyright (c) 2018 fwcd + + ]]; + }; + }; +} + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/leanls.lua b/lua/lspconfig/leanls.lua new file mode 100644 index 00000000..cd6f4644 --- /dev/null +++ b/lua/lspconfig/leanls.lua @@ -0,0 +1,22 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.leanls = { + default_config = { + cmd = {"lean-language-server", "--stdio"}; + filetypes = {"lean"}; + root_dir = util.root_pattern(".git"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/leanprover/vscode-lean/master/package.json"; + description = [[ +https://github.com/leanprover/lean-client-js/tree/master/lean-language-server + +Lean language server. + ]]; + default_config = { + root_dir = [[util.root_pattern(".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/metals.lua b/lua/lspconfig/metals.lua new file mode 100644 index 00000000..12e244bb --- /dev/null +++ b/lua/lspconfig/metals.lua @@ -0,0 +1,106 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local server_name = "metals" +local bin_name = "metals" + +local function make_installer() + local install_dir = util.path.join{util.base_install_dir, server_name} + local metals_bin = util.path.join{install_dir, bin_name} + local server_version + if (vim.g.metals_server_version) then + server_version = vim.g.metals_server_version + else + server_version = 'latest.release' + end + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(server_name, "is already installed") + return + end + if not (util.has_bins("curl")) then + error('Need "curl" to install this.') + return + end + if not (util.has_bins("java")) then + error('Need "JDK" to install this.') + return + end + + local coursier_exe = nil + if util.has_bins("cs") then + coursier_exe = "cs" + elseif util.has_bins("coursier") then + coursier_exe = "coursier" + end + if not coursier_exe then + coursier_exe = install_dir .. "/coursier" + local download_cmd = string.format("curl -fLo %s --create-dirs https://git.io/coursier-cli", coursier_exe) + local chmod_cmd = string.format("chmod +x %s", coursier_exe) + vim.fn.system(download_cmd) + vim.fn.system(chmod_cmd) + else + os.execute("mkdir -p " .. install_dir) + end + + local install_cmd = string.format("%s bootstrap --java-opt -Xss4m --java-opt -Xms100m org.scalameta:metals_2.12:%s -r bintray:scalacenter/releases -r sonatype:snapshots -o %s -f", coursier_exe, server_version, metals_bin) + vim.fn.system(install_cmd) + end + function X.info() + return { + is_installed = util.path.exists(metals_bin); + install_dir = install_dir; + cmd = { metals_bin }; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = install_info.cmd + end + end + return X +end + +local installer = make_installer() + +configs[server_name] = { + default_config = { + cmd = {bin_name}; + filetypes = {"scala"}; + root_dir = util.root_pattern("build.sbt", "build.sc", "build.gradle", "pom.xml"); + message_level = vim.lsp.protocol.MessageType.Log; + init_options = { + statusBarProvider = "show-message", + isHttpEnabled = true, + compilerOptions = { + snippetAutoIndent = false + } + }; + }; + on_new_config = function(config) + installer.configure(config) + end; + docs = { + package_json = "https://raw.githubusercontent.com/scalameta/metals-vscode/master/package.json"; + description = [[ +https://scalameta.org/metals/ + +To target a specific version on Metals, set the following. +If nothing is set, the latest stable will be used. +```vim +let g:metals_server_version = '0.8.4+106-5f2b9350-SNAPSHOT' +``` + +Scala language server with rich IDE features. +`metals` can be installed via `:LspInstall metals`. +]]; + default_config = { + root_dir = [[util.root_pattern("build.sbt", "build.sc", "build.gradle", "pom.xml")]]; + }; + }; +}; + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info diff --git a/lua/lspconfig/nimls.lua b/lua/lspconfig/nimls.lua new file mode 100644 index 00000000..f71c60f9 --- /dev/null +++ b/lua/lspconfig/nimls.lua @@ -0,0 +1,45 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.nimls = { + default_config = { + cmd = {"nimlsp",}; + filetypes = {'nim'}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + }; + docs = { + package_json = "https://raw.githubusercontent.com/pragmagic/vscode-nim/master/package.json"; + description = [[ +https://github.com/PMunch/nimlsp +`nimlsp` can be installed via `:LspInstall nimls` or by yourself the `nimble` package manager: +```sh +nimble install nimlsp +``` + ]]; + default_config = { + root_dir = [[root_pattern(".git") or os_homedir]]; + }; + }; +} + +configs.nimls.install = function() + local script = [[ + nimble install nimlsp + ]] + + util.sh(script, vim.loop.os_homedir()) +end + +configs.nimls.install_info = function() + local script = [[ + nimlsp --version + ]] + + local status = pcall(vim.fn.system, script) + + return { + is_installed = status and vim.v.shell_error == 0; + } +end diff --git a/lua/lspconfig/ocamlls.lua b/lua/lspconfig/ocamlls.lua new file mode 100644 index 00000000..05e71992 --- /dev/null +++ b/lua/lspconfig/ocamlls.lua @@ -0,0 +1,45 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "ocamlls" +local bin_name = "ocaml-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "ocaml-language-server" }; + binaries = { bin_name }; +} + +configs[server_name] = { + default_config = { + cmd = { bin_name, "--stdio" }; + filetypes = { "ocaml", "reason" }; + root_dir = util.root_pattern(".merlin", "package.json"); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/ocaml-lsp/ocaml-language-server + +`ocaml-language-server` can be installed via `:LspInstall ocamlls` or by yourself with `npm` +```sh +npm install -g ocaml-langauge-server +``` + ]]; + default_config = { + root_dir = [[root_pattern(".merlin", "package.json")]]; + }; + }; +}; +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/ocamllsp.lua b/lua/lspconfig/ocamllsp.lua new file mode 100644 index 00000000..9efc59b4 --- /dev/null +++ b/lua/lspconfig/ocamllsp.lua @@ -0,0 +1,26 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.ocamllsp = { + default_config = { + cmd = {"ocamllsp",}; + filetypes = {'ocaml', 'reason'}; + root_dir = util.root_pattern(".merlin", "package.json", ".git"); + }; + docs = { + description = [[ +https://github.com/ocaml/ocaml-lsp + +`ocaml-lsp` can be installed as described in [installation guide](https://github.com/ocaml/ocaml-lsp#installation). + +To install the lsp server in a particular opam switch: +```sh +opam pin add ocaml-lsp-server https://github.com/ocaml/ocaml-lsp.git +opam install ocaml-lsp-server +``` + ]]; + default_config = { + root_dir = [[root_pattern(".merlin", "package.json")]]; + }; + }; +} diff --git a/lua/lspconfig/omnisharp.lua b/lua/lspconfig/omnisharp.lua new file mode 100644 index 00000000..a608537d --- /dev/null +++ b/lua/lspconfig/omnisharp.lua @@ -0,0 +1,84 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local server_name = 'omnisharp' +local bin_name = 'run' + +local function make_installer() + local install_dir = util.path.join{util.base_install_dir, server_name} + local pid = vim.fn.getpid() + local url = 'linux-x64' + + if vim.fn.has('win32') == 1 then + url = 'win-x64' + bin_name = 'Omnisharp.exe' + elseif vim.fn.has('mac') == 1 then + url = 'osx' + end + local bin_path = util.path.join{install_dir, bin_name} + + local download_target = util.path.join{install_dir, string.format("omnisharp-%s.zip", url)} + local extract_cmd = string.format("unzip '%s' -d '%s'", download_target, install_dir) + local download_cmd = string.format('curl -fLo "%s" --create-dirs "https://github.com/OmniSharp/omnisharp-roslyn/releases/latest/download/omnisharp-%s.zip"', download_target, url) + local make_executable_cmd = string.format("chmod u+x '%s'", bin_path) + + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(server_name, "is already installed") + return + end + if not (util.has_bins("curl")) then + error('Need "curl" to install this.') + return + end + vim.fn.mkdir(install_dir, 'p') + vim.fn.system(download_cmd) + vim.fn.system(extract_cmd) + vim.fn.system(make_executable_cmd) + end + function X.info() + return { + is_installed = util.path.exists(bin_path); + install_dir = install_dir; + cmd = { bin_path, "--languageserver" , "--hostPID", tostring(pid)}; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = install_info.cmd + end + end + return X +end + +local installer = make_installer() + +configs[server_name] = { + default_config = { + cmd = installer.info().cmd; + filetypes = {"cs", "vb"}; + root_dir = util.root_pattern("*.csproj", "*.sln"); + on_new_config = function(config) + installer.configure(config) + end; + init_options = { + }; + }; + -- on_new_config = function(new_config) end; + -- on_attach = function(client, bufnr) end; + docs = { + description = [[ +https://github.com/omnisharp/omnisharp-roslyn +OmniSharp server based on Roslyn workspaces +]]; + default_config = { + root_dir = [[root_pattern(".csproj", ".sln", ".git")]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/purescriptls.lua b/lua/lspconfig/purescriptls.lua new file mode 100644 index 00000000..14465d5b --- /dev/null +++ b/lua/lspconfig/purescriptls.lua @@ -0,0 +1,46 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "purescriptls" +local bin_name = "purescript-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "purescript", "purescript-language-server" }; + binaries = {bin_name, "purs"}; +} + +configs[server_name] = { + default_config = { + cmd = {"purescript-language-server", "--stdio"}; + filetypes = {"purescript"}; + root_dir = util.root_pattern("spago.dhall", "bower.json"); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + package_json = "https://raw.githubusercontent.com/nwolverson/vscode-ide-purescript/master/package.json"; + description = [[ +https://github.com/nwolverson/purescript-language-server +`purescript-language-server` can be installed via `:LspInstall purescriptls` or by yourself with `npm` +```sh +npm install -g purescript-language-server +``` +]]; + default_config = { + root_dir = [[root_pattern("spago.dhall, bower.json")]]; + }; + }; +}; +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/pyls.lua b/lua/lspconfig/pyls.lua new file mode 100644 index 00000000..fef0749d --- /dev/null +++ b/lua/lspconfig/pyls.lua @@ -0,0 +1,23 @@ +local configs = require 'lspconfig/configs' + +configs.pyls = { + default_config = { + cmd = {"pyls"}; + filetypes = {"python"}; + root_dir = function(fname) + return vim.fn.getcwd() + end; + }; + docs = { + package_json = "https://raw.githubusercontent.com/palantir/python-language-server/develop/vscode-client/package.json"; + description = [[ +https://github.com/palantir/python-language-server + +`python-language-server`, a language server for Python. + ]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/pyls_ms.lua b/lua/lspconfig/pyls_ms.lua new file mode 100644 index 00000000..a1a8b687 --- /dev/null +++ b/lua/lspconfig/pyls_ms.lua @@ -0,0 +1,153 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local name = "pyls_ms" + +local function get_latest_pyls() + local f = io.popen("curl -k --silent 'https://pvsc.blob.core.windows.net/python-language-server-stable?restype=container&comp=list&prefix=Python-Language-Server-osx-x64'") + local l = f:read("*a") + f:close() + local version + for w in string.gmatch (l, "x64%.(.-).nupkg") do + version = w + end + return version +end + +local function make_installer() + local P = util.path.join + local install_dir = P{util.base_install_dir, name} + + local bin = P{install_dir, "Microsoft.Python.LanguageServer.dll"} + local cmd = {"dotnet", "exec", bin} + + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(name, "is already installed") + return + end + if not (util.has_bins("curl")) then + error('Need "curl" to install this.') + return + end + if not (util.has_bins("dotnet")) then + error('Need ".NET Core" to install this.') + return + end + + local system + if vim.fn.has('mac') == 1 then + system = 'osx' + elseif vim.fn.has('unix') == 1 then + system = 'linux' + elseif vim.fn.has('win32') == 1 then + system = 'win' + else + error('Unable to identify host operating system') + end + + local version = get_latest_pyls() + local url = string.format("https://pvsc.azureedge.net/python-language-server-stable/Python-Language-Server-%s-x64.%s.nupkg", string.lower(system), version) + local download_cmd = string.format('curl -fLo %s --create-dirs %s', install_info.install_dir .. "/pyls.nupkg", url) + local install_cmd = '' + + if vim.fn.has('mac') == 1 or vim.fn.has('unix') == 1 then + install_cmd = "unzip " .. install_info.install_dir .. "/pyls.nupkg -d " .. install_info.install_dir + elseif vim.fn.has('win32') == 1 then + install_cmd = "Expand-Archive -Force " .. install_info.install_dir .. "/pyls.nupkg -d " .. install_info.install_dir + end + + vim.fn.system(download_cmd) + vim.fn.system(install_cmd) + end + function X.info() + return { + is_installed = util.path.exists(bin); + install_dir = install_dir; + cmd = cmd; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = cmd + end + end + return X +end + +local installer = make_installer() + +configs[name] = { + + default_config = { + filetypes = {"python"}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + settings = { + python = { + analysis = { + errors = {}; + info = {}; + disabled = {}; + }; + }; + }; + on_new_config = function(config) + installer.configure(config) + end; + init_options = { + interpreter = { + properties = + { + InterpreterPath = ""; + Version = ""; + }; + }; + displayOptions = {}; + analysisUpdates = true; + asyncStartup = true; + }; + }; + docs = { + description = [[ +https://github.com/Microsoft/python-language-server + +`python-language-server`, a language server for Python. + +Requires [.NET Core](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script) to run. On Linux or macOS: + +```bash +curl -L https://dot.net/v1/dotnet-install.sh | sh +``` + +`python-language-server` can be installed via `:LspInstall pyls_ms` or you can [build](https://github.com/microsoft/python-language-server/blob/master/CONTRIBUTING.md#setup) your own. + +If you want to use your own build, set cmd to point to `Microsoft.Python.languageServer.dll`. + +```lua +cmd = { "dotnet", "exec", "path/to/Microsoft.Python.languageServer.dll" }; +``` + +If the `python` interpreter is not in your PATH environment variable, set the `InterpreterPath` and `Version` properties accordingly. + +```lua +InterpreterPath = "path/to/python", +Version = "3.8" +``` + +This server accepts configuration via the `settings` key. + + ]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +}; + +configs[name].install = installer.install +configs[name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/r_language_server.lua b/lua/lspconfig/r_language_server.lua new file mode 100644 index 00000000..d75da11f --- /dev/null +++ b/lua/lspconfig/r_language_server.lua @@ -0,0 +1,30 @@ +local util = require 'lspconfig/util' +local configs = require 'lspconfig/configs' + +configs.r_language_server = { + default_config = { + cmd = {"R", "--slave", "-e", "languageserver::run()"}; + filetypes = {"r", "rmd"}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + log_level = vim.lsp.protocol.MessageType.Warning; + }; + docs = { + package_json = "https://raw.githubusercontent.com/REditorSupport/vscode-r-lsp/master/package.json"; + description = [[ + [languageserver](https://github.com/REditorSupport/languageserver) is an + implementation of the Microsoft's Language Server Protocol for the R + language. + + It is released on CRAN and can be easily installed by + + ```R + install.packages("languageserver") + ``` + ]]; + default_config = { + root_dir = [[root_pattern(".git") or os_homedir]] + }; + }; +} diff --git a/lua/lspconfig/rls.lua b/lua/lspconfig/rls.lua new file mode 100644 index 00000000..a1b15d9f --- /dev/null +++ b/lua/lspconfig/rls.lua @@ -0,0 +1,31 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.rls = { + default_config = { + cmd = {"rls"}; + filetypes = {"rust"}; + root_dir = util.root_pattern("Cargo.toml"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/rust-lang/rls-vscode/master/package.json"; + description = [[ +https://github.com/rust-lang/rls + +rls, a language server for Rust + +See https://github.com/rust-lang/rls#setup to setup rls itself. +See https://github.com/rust-lang/rls#configuration for rls-specific settings. + +If you want to use rls for a particular build, eg nightly, set cmd as follows: + +```lua +cmd = {"rustup", "run", "nightly", "rls"} +``` + ]]; + default_config = { + root_dir = [[root_pattern("Cargo.toml")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/rnix.lua b/lua/lspconfig/rnix.lua new file mode 100644 index 00000000..deaeac98 --- /dev/null +++ b/lua/lspconfig/rnix.lua @@ -0,0 +1,81 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local name = "rnix" + +local function make_installer() + local P = util.path.join + local install_dir = P{util.base_install_dir, name} + + local bin = P{install_dir, "bin", "rnix-lsp"} + local cmd = {bin} + + local X = {} + function X.install() + local install_info = X.info() + if install_info.is_installed then + print(name, "is already installed") + return + end + if not (util.has_bins("cargo")) then + error('Need "cargo" to install this.') + return + end + + local install_cmd = "cargo install rnix-lsp --root=" .. install_info.install_dir .. " rnix-lsp" + + vim.fn.system(install_cmd) + end + function X.info() + return { + is_installed = util.path.exists(bin); + install_dir = install_dir; + cmd = cmd; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = cmd + end + end + return X +end + +local installer = make_installer() + +configs[name] = { + + default_config = { + cmd = {"rnix-lsp"}; + filetypes = {"nix"}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + settings = { + }; + on_new_config = function(config) + installer.configure(config) + end; + init_options = { + }; + }; + docs = { + description = [[ +https://github.com/nix-community/rnix-lsp + +A language server for Nix providing basic completion and formatting via nixpkgs-fmt. + +To install manually, run `cargo install rnix-lsp`. If you are using nix, rnix-lsp is in nixpkgs. + +This server accepts configuration via the `settings` key. + + ]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +}; + +configs[name].install = installer.install +configs[name].install_info = installer.info diff --git a/lua/lspconfig/rome.lua b/lua/lspconfig/rome.lua new file mode 100644 index 00000000..a8d813f2 --- /dev/null +++ b/lua/lspconfig/rome.lua @@ -0,0 +1,37 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.rome = { + default_config = { + cmd = {'rome', 'lsp'}, + filetypes = { + 'javascript', + 'javascriptreact', + 'json', + 'typescript', + 'typescript.tsx', + 'typescriptreact' + }, + root_dir = function(fname) + return util.find_package_json_ancestor(fname) or + util.find_node_modules_ancestor(fname) or + util.find_git_ancestor(fname) or + util.path.dirname(fname) + end + }, + docs = { + description = [[ +https://romefrontend.dev + +Language server for the Rome Frontend Toolchain. + +```sh +npm install [-g] rome +``` +]], + default_config = { + root_dir = [[root_pattern('package.json', 'node_modules', '.git') or dirname]] + } + } +} + diff --git a/lua/lspconfig/rust_analyzer.lua b/lua/lspconfig/rust_analyzer.lua new file mode 100644 index 00000000..2d545517 --- /dev/null +++ b/lua/lspconfig/rust_analyzer.lua @@ -0,0 +1,27 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.rust_analyzer = { + default_config = { + cmd = {"rust-analyzer"}; + filetypes = {"rust"}; + root_dir = util.root_pattern("Cargo.toml", "rust-project.json"); + settings = { + ["rust-analyzer"] = {} + } + }; + docs = { + package_json = "https://raw.githubusercontent.com/rust-analyzer/rust-analyzer/master/editors/code/package.json"; + description = [[ +https://github.com/rust-analyzer/rust-analyzer + +rust-analyzer (aka rls 2.0), a language server for Rust + +See [docs](https://github.com/rust-analyzer/rust-analyzer/tree/master/docs/user#settings) for extra settings. + ]]; + default_config = { + root_dir = [[root_pattern("Cargo.toml", "rust-project.json")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/scry.lua b/lua/lspconfig/scry.lua new file mode 100644 index 00000000..d2b5164e --- /dev/null +++ b/lua/lspconfig/scry.lua @@ -0,0 +1,24 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.scry = { + default_config = { + cmd = {'scry'}, + filetypes = {'crystal'}, + root_dir = function(fname) + return util.root_pattern('shard.yml') or + util.find_git_ancestor(fname) or + util.path.dirname(fname) + end + }, + docs = { + description = [[ +https://github.com/crystal-lang-tools/scry + +Crystal language server. +]], + default_config = { + root_dir = [[root_pattern('shard.yml', '.git') or dirname]] + } + } +} diff --git a/lua/lspconfig/solargraph.lua b/lua/lspconfig/solargraph.lua new file mode 100644 index 00000000..5aa2ec17 --- /dev/null +++ b/lua/lspconfig/solargraph.lua @@ -0,0 +1,32 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local bin_name = "solargraph" +if vim.fn.has('win32') == 1 then + bin_name = bin_name..'.bat' +end +configs.solargraph = { + default_config = { + cmd = {bin_name, "stdio"}; + filetypes = {"ruby"}; + root_dir = util.root_pattern("Gemfile", ".git"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/castwide/vscode-solargraph/master/package.json"; + description = [[ +https://solargraph.org/ + +solargraph, a language server for Ruby + +You can install solargraph via gem install. + +```sh +gem install solargraph +``` + ]]; + default_config = { + root_dir = [[root_pattern("Gemfile", ".git")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/sourcekit.lua b/lua/lspconfig/sourcekit.lua new file mode 100644 index 00000000..4b80b085 --- /dev/null +++ b/lua/lspconfig/sourcekit.lua @@ -0,0 +1,22 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.sourcekit = { + default_config = { + cmd = {"xcrun", "sourcekit-lsp"}; + filetypes = {"swift", "c", "cpp", "objective-c", "objective-cpp"}; + root_dir = util.root_pattern("Package.swift", ".git") + }; + docs = { + package_json = "https://raw.githubusercontent.com/apple/sourcekit-lsp/master/Editors/vscode/package.json"; + description = [[ +https://github.com/apple/sourcekit-lsp + +Language server for Swift and C/C++/Objective-C. + ]]; + default_config = { + root_dir = [[root_pattern("Package.swift", ".git")]]; + }; + }; +}; +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/sqlls.lua b/lua/lspconfig/sqlls.lua new file mode 100644 index 00000000..aced4e02 --- /dev/null +++ b/lua/lspconfig/sqlls.lua @@ -0,0 +1,52 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "sqlls" +local bin_name = "sql-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "sql-language-server" }; + binaries = {bin_name}; +} + +local root_pattern = util.root_pattern(".sqllsrc.json") + +configs[server_name] = { + default_config = { + filetypes = {"sql", "mysql"}; + root_dir = function(fname) + return root_pattern(fname) or vim.loop.os_homedir() + end; + settings = {}; + }; + on_new_config = function(config) + local install_info = installer.info(); + local P = util.path.join + if install_info.is_installed then + local bin_ex = P{install_info.bin_dir, bin_name} + config.cmd = {bin_ex, "up", "--method", "stdio"} + end + end; + docs = { + description = [[ +https://github.com/joe-re/sql-language-server + +`cmd` value is **not set** by default. An installer is provided via the `:LspInstall` command that uses the *nvm_lsp node_modules* directory to find the sql-language-server executable. The `cmd` value can be overriden in the `setup` table; + +```lua +require'lspconfig'.sqlls.setup{ + cmd = {"path/to/command", "up", "--method", "stdio"}; + ... +} +``` + +This LSP can be installed via `:LspInstall sqlls` or with `npm`. If using LspInstall, run `:LspInstallInfo sqlls` to view installation paths. Find further instructions on manual installation of the sql-language-server at [joe-re/sql-language-server](https://github.com/joe-re/sql-language-server). +<br> + ]]; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/sumneko_lua.lua b/lua/lspconfig/sumneko_lua.lua new file mode 100644 index 00000000..3faca644 --- /dev/null +++ b/lua/lspconfig/sumneko_lua.lua @@ -0,0 +1,133 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local name = "sumneko_lua" +local bin_name = "lua-language-server" + +local function make_installer() + local P = util.path.join + local install_dir = P{util.base_install_dir, name} + local git_dir = P{install_dir, bin_name} + local os, bin, ninja_zip, build_file + + if vim.fn.has('osx') == 1 then + os = 'macOS' + bin = P{git_dir, "bin", "macOS", bin_name} + ninja_zip = "ninja-mac.zip" + build_file = "macos.ninja" + elseif vim.fn.has('unix') == 1 then + os = 'Linux' + bin = P{git_dir, "bin", "Linux", bin_name} + ninja_zip = "ninja-linux.zip" + build_file = "linux.ninja" + end + local main_file = P{git_dir, "main.lua"} + local cmd = {bin, '-E', main_file} + + local X = {} + function X.install() + if os == nil then + error("This installer supports Linux and macOS only") + return + end + local install_info = X.info() + if install_info.is_installed then + print(name, "is already installed") + return + end + if not (util.has_bins("ninja") or util.has_bins("curl")) then + error('Need either "ninja" or "curl" (to download ninja) to install this.') + return + end + if not util.has_bins("sh", "chmod", "unzip", "clang") then + error('Need the binaries "sh", "chmod", "unzip", "clang" to install this') + return + end + local script = [=[ +set -e +bin_name=]=]..bin_name..'\n'..[=[ +ninja_zip=]=]..ninja_zip..'\n'..[=[ +build_file=]=]..build_file..'\n'..[=[ + +# Install ninja if not available. +which ninja >/dev/null || { + test -x ninja || { + curl -LO https://github.com/ninja-build/ninja/releases/download/v1.9.0/$ninja_zip + unzip $ninja_zip + chmod +x ninja + } + export PATH="$PWD:$PATH" +} + +# clone project +git clone https://github.com/sumneko/$bin_name +cd $bin_name +git submodule update --init --recursive + +# build +cd 3rd/luamake +ninja -f ninja/$build_file +cd ../.. +./3rd/luamake/luamake rebuild + ]=] + vim.fn.mkdir(install_info.install_dir, "p") + util.sh(script, install_info.install_dir) + end + function X.info() + return { + is_installed = util.has_bins(bin); + install_dir = install_dir; + cmd = cmd; + } + end + function X.configure(config) + local install_info = X.info() + if install_info.is_installed then + config.cmd = cmd + end + end + return X +end + +local installer = make_installer() + +configs[name] = { + default_config = { + filetypes = {'lua'}; + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end; + log_level = vim.lsp.protocol.MessageType.Warning; + }; + on_new_config = function(config) + installer.configure(config) + end; + docs = { + package_json = "https://raw.githubusercontent.com/sumneko/vscode-lua/master/package.json"; + description = [[ +https://github.com/sumneko/lua-language-server + +Lua language server. **By default, this doesn't have a `cmd` set.** This is +because it doesn't provide a global binary. We provide an installer for Linux +and macOS using `:LspInstall`. If you wish to install it yourself, [here is a +guide](https://github.com/sumneko/lua-language-server/wiki/Build-and-Run-(Standalone)). +So you should set `cmd` yourself like this. + +```lua +require'lspconfig'.sumneko_lua.setup{ + cmd = {"path", "to", "cmd"}; + ... +} +``` + +If you install via our installer, if you execute `:LspInstallInfo sumneko_lua`, you can know `cmd` value. +]]; + default_config = { + root_dir = [[root_pattern(".git") or os_homedir]]; + }; + }; +} + +configs[name].install = installer.install +configs[name].install_info = installer.info +-- vim:et ts=2 diff --git a/lua/lspconfig/terraformls.lua b/lua/lspconfig/terraformls.lua new file mode 100644 index 00000000..7d551e5c --- /dev/null +++ b/lua/lspconfig/terraformls.lua @@ -0,0 +1,23 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +configs.terraformls = { + default_config = { + cmd = {"terraform-ls"}; + filetypes = {"terraform"}; + root_dir = util.root_pattern(".terraform", ".git"); + }; + docs = { + package_json = "https://raw.githubusercontent.com/hashicorp/vscode-terraform/master/package.json"; + description = [[ +https://github.com/hashicorp/terraform-ls + +Terraform language server +Download a released binary from https://github.com/hashicorp/terraform-ls/releases. +]]; + default_config = { + root_dir = [[root_pattern(".terraform", ".git")]]; + }; + }; +} +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/texlab.lua b/lua/lspconfig/texlab.lua new file mode 100644 index 00000000..b6e08927 --- /dev/null +++ b/lua/lspconfig/texlab.lua @@ -0,0 +1,85 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' +local lsp = vim.lsp + +local texlab_build_status = vim.tbl_add_reverse_lookup { + Success = 0; + Error = 1; + Failure = 2; + Cancelled = 3; +} + +local function buf_build(bufnr) + bufnr = util.validate_bufnr(bufnr) + local params = { textDocument = { uri = vim.uri_from_bufnr(bufnr) } } + lsp.buf_request(bufnr, 'textDocument/build', params, + function(err, _, result, _) + if err then error(tostring(err)) end + print("Build "..texlab_build_status[result.status]) + end) +end + +-- bufnr isn't actually required here, but we need a valid buffer in order to +-- be able to find the client for buf_request. +-- TODO find a client by looking through buffers for a valid client? +-- local function build_cancel_all(bufnr) +-- bufnr = util.validate_bufnr(bufnr) +-- local params = { token = "texlab-build-*" } +-- lsp.buf_request(bufnr, 'window/progress/cancel', params, function(err, method, result, client_id) +-- if err then error(tostring(err)) end +-- print("Cancel result", vim.inspect(result)) +-- end) +-- end + +configs.texlab = { + default_config = { + cmd = {"texlab"}; + filetypes = {"tex", "bib"}; + root_dir = vim.loop.os_homedir; + settings = { + latex = { + build = { + args = {"-pdf", "-interaction=nonstopmode", "-synctex=1"}; + executable = "latexmk"; + onSave = false; + }; + forwardSearch = { + args = {}; + executable = nil; + onSave = false; + }; + lint = { + onChange = false; + }; + }; + bibtex = { + formatting = { + lineLength = 120 + }; + }; + }; + }; + commands = { + TexlabBuild = { + function() + buf_build(0) + end; + description = "Build the current buffer"; + }; + }; + docs = { + description = [[ +https://texlab.netlify.com/ + +A completion engine built from scratch for (La)TeX. + +See https://texlab.netlify.com/docs/reference/configuration for configuration options. +]]; + default_config = { + root_dir = "vim's starting directory"; + }; + }; +} + +configs.texlab.buf_build = buf_build +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/tsserver.lua b/lua/lspconfig/tsserver.lua new file mode 100644 index 00000000..4afc6077 --- /dev/null +++ b/lua/lspconfig/tsserver.lua @@ -0,0 +1,50 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "tsserver" +local bin_name = "typescript-language-server" +if vim.fn.has('win32') == 1 then + bin_name = bin_name..".cmd" +end + +local installer = util.npm_installer { + server_name = server_name; + packages = { "typescript-language-server" }; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx"}; + root_dir = util.root_pattern("package.json", "tsconfig.json", ".git"); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + description = [[ +https://github.com/theia-ide/typescript-language-server + +`typescript-language-server` can be installed via `:LspInstall tsserver` or by yourself with `npm`: +```sh +npm install -g typescript-language-server +``` +]]; + default_config = { + root_dir = [[root_pattern("package.json", "tsconfig.json", ".git")]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/util.lua b/lua/lspconfig/util.lua new file mode 100644 index 00000000..14eee811 --- /dev/null +++ b/lua/lspconfig/util.lua @@ -0,0 +1,445 @@ +local vim = vim +local validate = vim.validate +local api = vim.api +local lsp = vim.lsp +local uv = vim.loop +local fn = vim.fn + +local M = {} + +M.default_config = { + log_level = lsp.protocol.MessageType.Warning; + message_level = lsp.protocol.MessageType.Warning; + settings = vim.empty_dict(); + init_options = vim.empty_dict(); + callbacks = {}; +} + +function M.validate_bufnr(bufnr) + validate { + bufnr = { bufnr, 'n' } + } + return bufnr == 0 and api.nvim_get_current_buf() or bufnr +end + +function M.add_hook_before(func, new_fn) + if func then + return function(...) + -- TODO which result? + new_fn(...) + return func(...) + end + else + return new_fn + end +end + +function M.add_hook_after(func, new_fn) + if func then + return function(...) + -- TODO which result? + func(...) + return new_fn(...) + end + else + return new_fn + end +end + +function M.tbl_deep_extend(behavior, ...) + if (behavior ~= 'error' and behavior ~= 'keep' and behavior ~= 'force') then + error('invalid "behavior": '..tostring(behavior)) + end + + if select('#', ...) < 2 then + error('wrong number of arguments (given '..tostring(1 + select('#', ...))..', expected at least 3)') + end + + local ret = {} + if vim._empty_dict_mt ~= nil and getmetatable(select(1, ...)) == vim._empty_dict_mt then + ret = vim.empty_dict() + end + + for i = 1, select('#', ...) do + local tbl = select(i, ...) + vim.validate{["after the second argument"] = {tbl,'t'}} + if tbl then + for k, v in pairs(tbl) do + if type(v) == 'table' and not vim.tbl_islist(v) then + ret[k] = M.tbl_deep_extend(behavior, ret[k] or vim.empty_dict(), v) + elseif behavior ~= 'force' and ret[k] ~= nil then + if behavior == 'error' then + error('key found in more than one map: '..k) + end -- Else behavior is "keep". + else + ret[k] = v + end + end + end + end + return ret +end + +function M.nvim_multiline_command(command) + validate { command = { command, 's' } } + for line in vim.gsplit(command, "\n", true) do + api.nvim_command(line) + end +end + +function M.lookup_section(settings, section) + for part in vim.gsplit(section, '.', true) do + settings = settings[part] + if not settings then + return + end + end + return settings +end + +function M.create_module_commands(module_name, commands) + for command_name, def in pairs(commands) do + local parts = {"command!"} + -- Insert attributes. + for k, v in pairs(def) do + if type(k) == 'string' and type(v) == 'boolean' and v then + table.insert(parts, "-"..k) + elseif type(k) == 'number' and type(v) == 'string' and v:match("^%-") then + table.insert(parts, v) + end + end + table.insert(parts, command_name) + -- The command definition. + table.insert(parts, + string.format("lua require'lspconfig'[%q].commands[%q][1](<f-args>)", module_name, command_name)) + api.nvim_command(table.concat(parts, " ")) + end +end + +function M.has_bins(...) + for i = 1, select("#", ...) do + if 0 == fn.executable((select(i, ...))) then + return false + end + end + return true +end + +-- Some path utilities +M.path = (function() + local function exists(filename) + local stat = uv.fs_stat(filename) + return stat and stat.type or false + end + + local function is_dir(filename) + return exists(filename) == 'directory' + end + + local function is_file(filename) + return exists(filename) == 'file' + end + + local is_windows = uv.os_uname().version:match("Windows") + local path_sep = is_windows and "\\" or "/" + + local is_fs_root + if is_windows then + is_fs_root = function(path) + return path:match("^%a:$") + end + else + is_fs_root = function(path) + return path == "/" + end + end + + local function is_absolute(filename) + if is_windows then + return filename:match("^%a:") or filename:match("^\\\\") + else + return filename:match("^/") + end + end + + local dirname + do + local strip_dir_pat = path_sep.."([^"..path_sep.."]+)$" + local strip_sep_pat = path_sep.."$" + dirname = function(path) + if not path then return end + local result = path:gsub(strip_sep_pat, ""):gsub(strip_dir_pat, "") + if #result == 0 then + return "/" + end + return result + end + end + + local function path_join(...) + local result = + table.concat( + vim.tbl_flatten {...}, path_sep):gsub(path_sep.."+", path_sep) + return result + end + + -- Traverse the path calling cb along the way. + local function traverse_parents(path, cb) + path = uv.fs_realpath(path) + local dir = path + -- Just in case our algo is buggy, don't infinite loop. + for _ = 1, 100 do + dir = dirname(dir) + if not dir then return end + -- If we can't ascend further, then stop looking. + if cb(dir, path) then + return dir, path + end + if is_fs_root(dir) then + break + end + end + end + + -- Iterate the path until we find the rootdir. + local function iterate_parents(path) + path = uv.fs_realpath(path) + local function it(s, v) + if not v then return end + if is_fs_root(v) then return end + return dirname(v), path + end + return it, path, path + end + + local function is_descendant(root, path) + if (not path) then + return false; + end + + local function cb(dir, _) + return dir == root; + end + + local dir, _ = traverse_parents(path, cb); + + return dir == root; + end + + return { + is_dir = is_dir; + is_file = is_file; + is_absolute = is_absolute; + exists = exists; + sep = path_sep; + dirname = dirname; + join = path_join; + traverse_parents = traverse_parents; + iterate_parents = iterate_parents; + is_descendant = is_descendant; + } +end)() + + +-- Returns a function(root_dir), which, when called with a root_dir it hasn't +-- seen before, will call make_config(root_dir) and start a new client. +function M.server_per_root_dir_manager(_make_config) + local clients = {} + local manager = {} + + function manager.add(root_dir) + if not root_dir then return end + if not M.path.is_dir(root_dir) then return end + + -- Check if we have a client alredy or start and store it. + local client_id = clients[root_dir] + if not client_id then + local new_config = _make_config(root_dir) + new_config.on_exit = M.add_hook_before(new_config.on_exit, function() + clients[root_dir] = nil + end) + client_id = lsp.start_client(new_config) + clients[root_dir] = client_id + end + return client_id + end + + function manager.clients() + local res = {} + for _, id in pairs(clients) do + local client = lsp.get_client_by_id(id) + if client then + table.insert(res, client) + end + end + return res + end + + return manager +end + +function M.search_ancestors(startpath, func) + validate { func = {func, 'f'} } + if func(startpath) then return startpath end + for path in M.path.iterate_parents(startpath) do + if func(path) then return path end + end +end + +function M.root_pattern(...) + local patterns = vim.tbl_flatten {...} + local function matcher(path) + for _, pattern in ipairs(patterns) do + if M.path.exists(vim.fn.glob(M.path.join(path, pattern))) then + return path + end + end + end + return function(startpath) + return M.search_ancestors(startpath, matcher) + end +end +function M.find_git_ancestor(startpath) + return M.search_ancestors(startpath, function(path) + if M.path.is_dir(M.path.join(path, ".git")) then + return path + end + end) +end +function M.find_node_modules_ancestor(startpath) + return M.search_ancestors(startpath, function(path) + if M.path.is_dir(M.path.join(path, "node_modules")) then + return path + end + end) +end +function M.find_package_json_ancestor(startpath) + return M.search_ancestors(startpath, function(path) + if M.path.is_file(M.path.join(path, "package.json")) then + return path + end + end) +end + +local function validate_string_list(t) + for _, v in ipairs(t) do + if type(v) ~= 'string' then + return false + end + end + return true +end + +local function map_list(t, func) + local res = {} + for i, v in ipairs(t) do table.insert(res, func(v, i)) end + return res +end + +local function zip_lists_to_map(a, b) + assert(#a == #b) + local res = {} + for i = 1, #a do res[a[i]] = b[i] end + return res +end + +local base_install_dir = M.path.join(fn.stdpath("cache"), "lspconfig") +M.base_install_dir = base_install_dir +function M.npm_installer(config) + validate { + server_name = {config.server_name, 's'}; + packages = {config.packages, validate_string_list, 'List of npm package names'}; + binaries = {config.binaries, validate_string_list, 'List of binary names'}; + post_install_script = {config.post_install_script, 's', true}; + } + + local install_dir = M.path.join(base_install_dir, config.server_name) + local bin_dir = M.path.join(install_dir, "node_modules", ".bin") + local function bin_path(name) + return M.path.join(bin_dir, name) + end + + local binary_paths = map_list(config.binaries, bin_path) + + local function get_install_info() + return { + bin_dir = bin_dir; + install_dir = install_dir; + binaries = zip_lists_to_map(config.binaries, binary_paths); + is_installed = M.has_bins(unpack(binary_paths)); + } + end + + local function install() + -- TODO(ashkan) need all binaries or just the first? + if M.has_bins(unpack(config.binaries)) then + return print(config.server_name, "is already installed (not by Nvim)") + end + if not M.has_bins("sh", "npm", "mkdir") then + api.nvim_err_writeln('Installation requires "sh", "npm", "mkdir"') + return + end + if get_install_info().is_installed then + return print(config.server_name, "is already installed") + end + local install_params = { + packages = table.concat(config.packages, ' '); + install_dir = install_dir; + post_install_script = config.post_install_script or ''; + } + local cmd = io.popen("sh", "w") + local install_script = ([[ + set -e + mkdir -p "{{install_dir}}" + cd "{{install_dir}}" + [ ! -f package.json ] && npm init -y + npm install {{packages}} --no-package-lock --no-save --production + {{post_install_script}} + ]]):gsub("{{(%S+)}}", install_params) + cmd:write(install_script) + cmd:close() + if not get_install_info().is_installed then + api.nvim_err_writeln('Installation of ' .. config.server_name .. ' failed') + end + end + + return { + install = install; + info = get_install_info; + } +end + +function M.sh(script, cwd) + assert(cwd and M.path.is_dir(cwd), "sh: Invalid directory") + -- switching to insert mode makes the buffer scroll as new output is added + -- and makes it easy and intuitive to cancel the operation with Ctrl-C + api.nvim_command("10new | startinsert") + local bufnr = api.nvim_get_current_buf() + local function on_exit(job_id, code, event_type) + if code == 0 then + api.nvim_command("silent bwipeout! "..bufnr) + end + end + fn.termopen({"sh", "-c", script}, {cwd = cwd, on_exit = on_exit}) +end + +function M.format_vspackage_url(extension_name) + local org, package = unpack(vim.split(extension_name, ".", true)) + assert(org and package) + return string.format("https://marketplace.visualstudio.com/_apis/public/gallery/publishers/%s/vsextensions/%s/latest/vspackage", org, package) +end + + +function M.utf8_config(config) + config.capabilities = config.capabilities or lsp.protocol.make_client_capabilities() + config.capabilities.offsetEncoding = {"utf-8", "utf-16"} + function config.on_init(client, result) + if result.offsetEncoding then + client.offset_encoding = result.offsetEncoding + end + end + return config +end + +return M +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/vimls.lua b/lua/lspconfig/vimls.lua new file mode 100644 index 00000000..15e5fed1 --- /dev/null +++ b/lua/lspconfig/vimls.lua @@ -0,0 +1,63 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "vimls" +local bin_name = "vim-language-server" +if vim.fn.has('win32') == 1 then + bin_name = bin_name..".cmd" +end + +local installer = util.npm_installer { + server_name = server_name, + packages = {"vim-language-server"}, + binaries = {bin_name} +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}, + filetypes = {"vim"}, + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.loop.os_homedir() + end, + init_options = { + iskeyword = "@,48-57,_,192-255,-#", + vimruntime = "", + runtimepath = "", + diagnostic = {enable = true}, + indexes = { + runtimepath = true, + gap = 100, + count = 3, + projectRootPatterns = {"runtime", "nvim", ".git", "autoload", "plugin"} + }, + suggest = {fromVimruntime = true, fromRuntimepath = true} + }, + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == "table" then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end, + docs = { + description = [[ +https://github.com/iamcco/vim-language-server + +If you don't want to use Nvim to install it, then you can use: +```sh +npm install -g vim-language-server +``` +]] + } + } +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info + +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/vuels.lua b/lua/lspconfig/vuels.lua new file mode 100644 index 00000000..4a8774bd --- /dev/null +++ b/lua/lspconfig/vuels.lua @@ -0,0 +1,125 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "vuels" +local bin_name = "vls" + +local installer = util.npm_installer { + server_name = server_name; + packages = { "vls" }; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name}; + filetypes = {"vue"}; + root_dir = util.root_pattern("package.json", "vue.config.js"); + init_options = { + config = { + vetur = { + useWorkspaceDependencies = false; + validation = { + template = true; + style = true; + script = true; + }; + completion = { + autoImport = false; + useScaffoldSnippets = false; + tagCasing = "kebab"; + }; + format = { + defaultFormatter = { + js = "none"; + ts = "none"; + }; + defaultFormatterOptions = {}; + scriptInitialIndent = false; + styleInitialIndent = false; + } + }; + css = {}; + html = { + suggest = {}; + }; + javascript = { + format = {}; + }; + typescript = { + format = {}; + }; + emmet = {}; + stylusSupremacy = {}; + }; + }; + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + -- Try to preserve any additional args from upstream changes. + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + package_json = "https://raw.githubusercontent.com/vuejs/vetur/master/package.json"; + description = [[ +https://github.com/vuejs/vetur/tree/master/server + +Vue language server(vls) +`vue-language-server` can be installed via `:LspInstall vuels` or by yourself with `npm`: +```sh +npm install -g vls +``` +]]; + default_config = { + root_dir = [[root_pattern("package.json", "vue.config.js")]]; + init_options = { + config = { + vetur = { + useWorkspaceDependencies = false; + validation = { + template = true; + style = true; + script = true; + }; + completion = { + autoImport = false; + useScaffoldSnippets = false; + tagCasing = "kebab"; + }; + format = { + defaultFormatter = { + js = "none"; + ts = "none"; + }; + defaultFormatterOptions = {}; + scriptInitialIndent = false; + styleInitialIndent = false; + } + }; + css = {}; + html = { + suggest = {}; + }; + javascript = { + format = {}; + }; + typescript = { + format = {}; + }; + emmet = {}; + stylusSupremacy = {}; + }; + }; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 diff --git a/lua/lspconfig/yamlls.lua b/lua/lspconfig/yamlls.lua new file mode 100644 index 00000000..787e8df3 --- /dev/null +++ b/lua/lspconfig/yamlls.lua @@ -0,0 +1,47 @@ +local configs = require 'lspconfig/configs' +local util = require 'lspconfig/util' + +local server_name = "yamlls" +local bin_name = "yaml-language-server" + +local installer = util.npm_installer { + server_name = server_name; + packages = {bin_name}; + binaries = {bin_name}; +} + +configs[server_name] = { + default_config = { + cmd = {bin_name, "--stdio"}; + filetypes = {"yaml"}; + root_dir = util.root_pattern(".git", vim.fn.getcwd()); + }; + on_new_config = function(new_config) + local install_info = installer.info() + if install_info.is_installed then + if type(new_config.cmd) == 'table' then + new_config.cmd[1] = install_info.binaries[bin_name] + else + new_config.cmd = {install_info.binaries[bin_name]} + end + end + end; + docs = { + package_json = "https://raw.githubusercontent.com/redhat-developer/vscode-yaml/master/package.json"; + description = [[ +https://github.com/redhat-developer/yaml-language-server + +`yaml-language-server` can be installed via `:LspInstall yamlls` or by yourself with `npm`: +```sh +npm install -g yaml-language-server +``` +]]; + default_config = { + root_dir = [[root_pattern(".git", vim.fn.getcwd())]]; + }; + }; +} + +configs[server_name].install = installer.install +configs[server_name].install_info = installer.info +-- vim:et ts=2 sw=2 |