1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
local fs = require "nvim-lsp-installer.fs"
local notify = require "nvim-lsp-installer.notify"
local dispatcher = require "nvim-lsp-installer.dispatcher"
local process = require "nvim-lsp-installer.process"
local status_win = require "nvim-lsp-installer.ui.status-win"
local servers = require "nvim-lsp-installer.servers"
local settings = require "nvim-lsp-installer.settings"
local log = require "nvim-lsp-installer.log"
local platform = require "nvim-lsp-installer.platform"
local M = {}
M.settings = settings.set
--- Opens the status window.
function M.display()
status_win().open()
end
---Raises an error with the provided message. If in a headless environment,
---will also schedule an immediate shutdown with the provided exit code.
---@param msg string
---@param code number @The exit code to use when in headless mode.
local function raise_error(msg, code)
if platform.is_headless then
vim.schedule(function()
-- We schedule the exit to make sure the call stack is exhausted
os.exit(code or 1)
end)
end
error(msg)
end
---Installs the provided servers synchronously (blocking call). It's recommended to only use this in headless environments.
---@param server_identifiers string[] @A list of server identifiers (for example {"rust_analyzer@nightly", "tsserver"}).
function M.install_sync(server_identifiers)
local completed_servers = {}
local failed_servers = {}
local server_tuples = {}
-- Collect all servers and exit early if unable to find one.
for _, server_identifier in pairs(server_identifiers) do
local server_name, version = servers.parse_server_identifier(server_identifier)
local ok, server = servers.get_server(server_name)
if not ok then
raise_error(("Could not find server %q."):format(server_name))
end
table.insert(server_tuples, { server, version })
end
-- Start all installations.
for _, server_tuple in ipairs(server_tuples) do
local server, version = unpack(server_tuple)
server:install_attached({
stdio_sink = process.simple_sink(),
requested_server_version = version,
}, function(success)
table.insert(completed_servers, server)
if not success then
table.insert(failed_servers, server)
end
end)
end
-- Poll for completion.
if vim.wait(60000 * 15, function()
return #completed_servers >= #server_identifiers
end, 100) then
if #failed_servers > 0 then
for _, server in pairs(failed_servers) do
log.fmt_error("Server %s failed to install.", server.name)
end
raise_error(("%d/%d servers failed to install."):format(#failed_servers, #completed_servers))
end
for _, server in pairs(completed_servers) do
log.fmt_info("Server %s was successfully installed.", server.name)
end
end
end
---Unnstalls the provided servers synchronously (blocking call). It's recommended to only use this in headless environments.
---@param server_identifiers string[] @A list of server identifiers (for example {"rust_analyzer@nightly", "tsserver"}).
function M.uninstall_sync(server_identifiers)
for _, server_identifier in pairs(server_identifiers) do
local server_name = servers.parse_server_identifier(server_identifier)
local ok, server = servers.get_server(server_name)
if not ok then
log.error(server)
raise_error(("Could not find server %q."):format(server_name))
end
local uninstall_ok, uninstall_error = pcall(server.uninstall, server)
if not uninstall_ok then
log.error(tostring(uninstall_error))
raise_error(("Failed to uninstall server %q."):format(server.name))
end
log.fmt_info("Successfully uninstalled server %s.", server.name)
end
end
--- Queues a server to be installed. Will also open the status window.
--- Use the .on_server_ready(cb) function to register a handler to be executed when a server is ready to be set up.
---@param server_identifier string @The server to install. This can also include a requested version, for example "rust_analyzer@nightly".
function M.install(server_identifier)
local server_name, version = servers.parse_server_identifier(server_identifier)
local ok, server = servers.get_server(server_name)
if not ok then
return notify(("Unable to find LSP server %s.\n\n%s"):format(server_name, server), vim.log.levels.ERROR)
end
status_win().install_server(server, version)
status_win().open()
end
--- Queues a server to be uninstalled. Will also open the status window.
---@param server_name string The server to uninstall.
function M.uninstall(server_name)
local ok, server = servers.get_server(server_name)
if not ok then
return notify(("Unable to find LSP server %s.\n\n%s"):format(server_name, server), vim.log.levels.ERROR)
end
status_win().uninstall_server(server)
status_win().open()
end
--- Queues all servers to be uninstalled. Will also open the status window.
function M.uninstall_all(no_confirm)
if not no_confirm then
local choice = vim.fn.confirm(
("This will uninstall all servers currently installed at %q. Continue?"):format(
vim.fn.fnamemodify(settings.current.install_root_dir, ":~")
),
"&Yes\n&No",
2
)
if settings.current.install_root_dir ~= settings._DEFAULT_SETTINGS.install_root_dir then
choice = vim.fn.confirm(
(
"WARNING: You are using a non-default install_root_dir (%q). This command will delete the entire directory. Continue?"
):format(vim.fn.fnamemodify(settings.current.install_root_dir, ":~")),
"&Yes\n&No",
2
)
end
if choice ~= 1 then
print "Uninstalling all servers was aborted."
return
end
end
log.info "Uninstalling all servers."
if fs.dir_exists(settings.current.install_root_dir) then
local ok, err = pcall(fs.rmrf, settings.current.install_root_dir)
if not ok then
log.error(err)
raise_error "Failed to uninstall all servers."
end
end
log.info "Successfully uninstalled all servers."
status_win().mark_all_servers_uninstalled()
status_win().open()
end
---@param cb fun(server: Server) @Callback to be executed whenever a server is ready to be set up.
function M.on_server_ready(cb)
dispatcher.register_server_ready_callback(cb)
vim.schedule(function()
local installed_servers = servers.get_installed_servers()
for i = 1, #installed_servers do
dispatcher.dispatch_server_ready(installed_servers[i])
end
end)
end
-- "Proxy" function for triggering attachment of LSP servers to all buffers (useful when just installed a new server
-- that wasn't installed at launch)
M.lsp_attach_proxy = process.debounced(function()
-- As of writing, if the lspconfig server provides a filetypes setting, it uses FileType as trigger, otherwise it uses BufReadPost
vim.cmd [[ doautoall FileType | doautoall BufReadPost ]]
end)
-- old API
M.get_server = servers.get_server
M.get_available_servers = servers.get_available_servers
M.get_installed_servers = servers.get_installed_servers
M.get_uninstalled_servers = servers.get_uninstalled_servers
M.register = servers.register
return M
|
