Redo installation. (#17)

* Redo installation.

Servers which want to be auto installed should specify
skeleton[name].install()
and it will be automatically added to the list of installable servers.

- Add :LspInstall and :LspInstallInfo
- Auto generate docs for servers with .install() available.
- Add util.npm_installer
- Refactor utf8 capabilities common config into a single function
- Add contribution notes.
- Also expose util.base_install_dir for other installers potentially
- Fix tsserver's arguments and add javascript filetypes

7 files changed, 260 insertions, 207 deletions

diff --git a/lua/nvim_lsp.lua b/lua/nvim_lsp.lua
index 550d56dd..629b6b0a 100644
--- a/lua/nvim_lsp.lua
+++ b/lua/nvim_lsp.lua
@@ -1,5 +1,5 @@
 local skeleton = require 'nvim_lsp/skeleton'
-require 'nvim_lsp/bash'
+require 'nvim_lsp/bashls'
 require 'nvim_lsp/clangd'
 require 'nvim_lsp/elmls'
 require 'nvim_lsp/gopls'
@@ -11,6 +11,72 @@ local M = {
   util = require 'nvim_lsp/util';
 }
 
+function M.available_servers()
+  return vim.tbl_keys(skeleton)
+end
+
+function M.installable_servers()
+  local res = {}
+  for k, v in pairs(skeleton) do
+    if v.install then table.insert(res, k) end
+  end
+  return res
+end
+
+M._root = {}
+-- Called from plugin/nvim_lsp.vim because it requires knowing that the last
+-- script in scriptnames to be executed is nvim_lsp.
+function M._root._setup()
+  local snr = tonumber(table.remove(vim.split(vim.fn.execute("scriptnames"), '\n')):match("^%s*(%d+)"))
+  local function sid(s)
+    return string.format("<SNR>%d_%s", snr, s)
+  end
+
+  M._root.commands = {
+    LspInstall = {
+      function(name)
+        local template = skeleton[name]
+        if not template then
+          return print("Invalid server name:", name)
+        end
+        if not template.install then
+          return print(name, "can't be automatically installed (yet)")
+        end
+        if template.install_info().is_installed then
+          return print(name, "is already installed")
+        end
+        template.install()
+      end;
+      "-nargs=1";
+      "-complete=custom,"..sid("complete_installable_server_names");
+      description = '`:LspInstall {name}` installs a server under stdpath("cache")/nvim_lsp/{name}';
+    };
+    LspInstallInfo = {
+      function(name)
+        if name == nil then
+          local res = {}
+          for k, v in pairs(skeleton) do
+            if v.install_info then
+              res[k] = v.install_info()
+            end
+          end
+          return print(vim.inspect(res))
+        end
+        local template = skeleton[name]
+        if not template then
+          return print("Invalid server name:", name)
+        end
+        return print(vim.inspect(template.install_info()))
+      end;
+      "-nargs=?";
+      "-complete=custom,"..sid("complete_installable_server_names");
+      description = 'Print installation info for {name} if one is specified, or all installable servers.';
+    };
+  };
+
+  M.util.create_module_commands("_root", M._root.commands)
+end
+
 local mt = {}
 function mt:__index(k)
   return skeleton[k]
diff --git a/lua/nvim_lsp/bash.lua b/lua/nvim_lsp/bash.lua
deleted file mode 100644
index a28ab2aa..00000000
--- a/lua/nvim_lsp/bash.lua
+++ /dev/null
@@ -1,28 +0,0 @@
-local skeleton = require 'nvim_lsp/skeleton'
-local util = require 'nvim_lsp/util'
-local lsp = vim.lsp
-
-local cwd = vim.loop.cwd()
-
-skeleton.bash = {
-  default_config = {
-    cmd = {"bash-language-server", "start"};
-    filetypes = {"sh"};
-    root_dir = function() return cwd end;
-    log_level = lsp.protocol.MessageType.Warning;
-    settings = {};
-  };
-  -- on_new_config = function(new_config) end;
-  -- on_attach = function(client, bufnr) end;
-  docs = {
-    description = [[
-For install instruction visit:
-https://github.com/mads-hartmann/bash-language-server#installation
-]];
-    default_config = {
-      root_dir = "vim's starting directory";
-    };
-  };
-};
-
--- vim:et ts=2 sw=2
diff --git a/lua/nvim_lsp/bashls.lua b/lua/nvim_lsp/bashls.lua
new file mode 100644
index 00000000..b2ae5187
--- /dev/null
+++ b/lua/nvim_lsp/bashls.lua
@@ -0,0 +1,49 @@
+local skeleton = require 'nvim_lsp/skeleton'
+local util = require 'nvim_lsp/util'
+local lsp = vim.lsp
+
+local cwd = vim.loop.cwd()
+
+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};
+}
+
+skeleton[server_name] = {
+  default_config = {
+    cmd = {"bash-language-server", "start"};
+    filetypes = {"sh"};
+    root_dir = function() return cwd end;
+    log_level = lsp.protocol.MessageType.Warning;
+    settings = {};
+  };
+  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;
+  -- on_attach = function(client, bufnr) end;
+  docs = {
+    description = [[
+For install instruction visit:
+https://github.com/mads-hartmann/bash-language-server#installation
+]];
+    default_config = {
+      root_dir = "vim's starting directory";
+    };
+  };
+};
+
+skeleton[server_name].install = installer.install
+skeleton[server_name].install_info = installer.info
+-- vim:et ts=2 sw=2
diff --git a/lua/nvim_lsp/clangd.lua b/lua/nvim_lsp/clangd.lua
index 8abe8ea2..6ba349e5 100644
--- a/lua/nvim_lsp/clangd.lua
+++ b/lua/nvim_lsp/clangd.lua
@@ -2,22 +2,13 @@ local skeleton = require 'nvim_lsp/skeleton'
 local util = require 'nvim_lsp/util'
 local lsp = vim.lsp
 
-local default_capabilities = lsp.protocol.make_client_capabilities()
-default_capabilities.offsetEncoding = {"utf-8", "utf-16"}
-
 skeleton.clangd = {
-  default_config = {
+  default_config = util.utf8_config {
     cmd = {"clangd", "--background-index"};
     filetypes = {"c", "cpp", "objc", "objcpp"};
     root_dir = util.root_pattern("compile_commands.json", "compile_flags.txt", ".git");
     log_level = lsp.protocol.MessageType.Warning;
     settings = {};
-    capabilities = default_capabilities;
-    on_init = function(client, result)
-      if result.offsetEncoding then
-        client.offset_encoding = result.offsetEncoding
-      end
-    end
   };
   -- commands = {};
   -- on_new_config = function(new_config) end;
diff --git a/lua/nvim_lsp/elmls.lua b/lua/nvim_lsp/elmls.lua
index 08a28c45..93dce340 100644
--- a/lua/nvim_lsp/elmls.lua
+++ b/lua/nvim_lsp/elmls.lua
@@ -1,59 +1,27 @@
 local skeleton = require 'nvim_lsp/skeleton'
 local util = require 'nvim_lsp/util'
 local lsp = vim.lsp
-local fn = vim.fn
 local api = vim.api
-local need_bins = util.need_bins
-
-local default_capabilities = lsp.protocol.make_client_capabilities()
-default_capabilities.offsetEncoding = {"utf-8", "utf-16"}
 
+local server_name = "elmls"
 local bin_name = "elm-language-server"
 
-local install_dir = util.path.join(fn.stdpath("cache"), "nvim_lsp", "elmls")
-local function get_install_info()
-  local bin_dir = util.path.join(install_dir, "node_modules", ".bin")
-  local bins = { bin_dir = bin_dir; install_dir = install_dir; }
-  bins.elmls = util.path.join(bin_dir, bin_name)
-  bins.elm = util.path.join(bin_dir, "elm")
-  bins.elm_format = util.path.join(bin_dir, "elm-format")
-  bins.elm_test = util.path.join(bin_dir, "elm-test")
-  bins.is_installed = need_bins(bins.elmls, bins.elm, bins.elm_format, bins.elm_test)
-  return bins
-end
-
-local global_commands = {
-  ElmlsInstall = {
-    function()
-      if get_install_info().is_installed then
-        return print("ElmLS is already installed")
-      end
-      skeleton.elmls.install()
-    end;
-    description = 'Install elmls and its dependencies to stdpath("cache")/nvim_lsp/elmls';
-  };
-  ElmlsInstallInfo = {
-    function()
-      local install_info = get_install_info()
-      if not install_info.is_installed then
-        return print("ElmLS is not installed")
-      end
-      print(vim.inspect(install_info))
-    end;
-    description = 'Print installation info for `elmls`';
-  };
-};
-
-util.create_module_commands("elmls", global_commands)
+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")
 
-skeleton.elmls = {
-  default_config = {
+skeleton[server_name] = {
+  default_config = util.utf8_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, bufnr)
+    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)
@@ -67,40 +35,27 @@ skeleton.elmls = {
       elmTestPath = "elm-test",
       elmAnalyseTrigger = "change",
     };
-    capabilities = default_capabilities;
-    on_init = function(client, result)
-      if result.offsetEncoding then
-        client.offset_encoding = result.offsetEncoding
-      end
-    end
   };
-  commands = global_commands;
   on_new_config = function(new_config)
-    local install_info = get_install_info()
+    local install_info = installer.info()
     if install_info.is_installed then
-      new_config.cmd = {install_info.elmls}
+      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
       util.tbl_deep_extend(new_config.init_options, {
-        elmPath = install_info.elm;
-        elmFormatPath = install_info.elm_format;
-        elmTestPath = install_info.elm_test;
+        elmPath = install_info.binaries["elm"];
+        elmFormatPath = install_info.binaries["elm-format"];
+        elmTestPath = install_info.binaries["elm-test"];
       })
     end
-    print(vim.inspect(new_config))
   end;
   docs = {
     description = [[
 https://github.com/elm-tooling/elm-language-server#installation
 
-You can install elmls automatically to the path at
-  `stdpath("cache")/nvim_lsp/elmls`
-by using the function `nvim_lsp.elmls.install()` or the command `:ElmlsInstall`.
-
-This will only install if it can't find `elm-language-server` and if it hasn't
-been installed before by neovim.
-
-You can see installation info via `:ElmlsInstallInfo` or via
-`nvim_lsp.elmls.get_install_info()`. This will let you know if it is installed.
-
 If you don't want to use neovim to install it, then you can use:
 ```sh
 npm install -g elm elm-test elm-format @elm-tooling/elm-language-server
@@ -114,28 +69,7 @@ npm install -g elm elm-test elm-format @elm-tooling/elm-language-server
   };
 }
 
-function skeleton.elmls.install()
-  if not need_bins(bin_name) then return end
-  if not need_bins("sh", "npm", "mkdir", "cd") then
-    vim.api.nvim_err_writeln('Installation requires "sh", "npm", "mkdir", "cd"')
-    return
-  end
-  local install_info = get_install_info()
-  if install_info.is_installed then
-    return
-  end
-  local cmd = io.popen("sh", "w")
-  local install_script = ([[
-set -eo pipefail
-mkdir -p "{{install_dir}}"
-cd "{{install_dir}}"
-npm install elm elm-test elm-format @elm-tooling/elm-language-server
-]]):gsub("{{(%S+)}}", install_info)
-  print(install_script)
-  cmd:write(install_script)
-  cmd:close()
-end
-
-skeleton.elmls.get_install_info = get_install_info
+skeleton[server_name].install = installer.install
+skeleton[server_name].install_info = installer.info
 -- vim:et ts=2 sw=2
 
diff --git a/lua/nvim_lsp/tsserver.lua b/lua/nvim_lsp/tsserver.lua
index e9f5031f..32c289da 100644
--- a/lua/nvim_lsp/tsserver.lua
+++ b/lua/nvim_lsp/tsserver.lua
@@ -1,76 +1,40 @@
 local skeleton = require 'nvim_lsp/skeleton'
 local util = require 'nvim_lsp/util'
 local lsp = vim.lsp
-local fn = vim.fn
-local api = vim.api
-local need_bins = util.need_bins
-
-local default_capabilities = lsp.protocol.make_client_capabilities()
-default_capabilities.offsetEncoding = {"utf-8", "utf-16"}
 
+local server_name = "tsserver"
 local bin_name = "typescript-language-server"
 
-local install_dir = util.path.join(fn.stdpath("cache"), "nvim_lsp", "typescript-language-server")
-
-local function get_install_info()
-  local bin_dir = util.path.join(install_dir, "node_modules", ".bin")
-  local bins = { bin_dir = bin_dir; install_dir = install_dir; }
-  bins.tsserver = util.path.join(bin_dir, bin_name)
-  bins.is_installed = need_bins(bins.tsserver)
-  return bins
-end
-
-local global_commands = {
-  TsServerInstall = {
-    function()
-      if get_install_info().is_installed then
-        return print('typescript-language-server is already installed')
-      end
-      skeleton.tsserver.install()
-    end;
-    description = 'Install typescript-language-server and its dependencies to stdpath("cache")/nvim_lsp/typescript-language-server';
-  };
-  TsServerInstallInfo = {
-    function()
-      local install_info = get_install_info()
-      if not install_info.is_installed then
-        return print('typescript-language-server is not installed')
-      end
-      print(vim.inspect(install_info))
-    end;
-    description = 'Print installation infor for `typescript-language-server`'
-  }
-};
-
-util.create_module_commands("typescript-language-server", global_commands)
-
+local installer = util.npm_installer {
+  server_name = server_name;
+  packages = { "typescript-language-server" };
+  binaries = {bin_name};
+}
 
-skeleton.tsserver = {
-  default_config = {
-    cmd = {bin_name};
-    filetypes = {"typescript", "typescriptreact", "typescript.tsx"};
+skeleton[server_name] = {
+  default_config = util.utf8_config {
+    cmd = {bin_name, "--stdio"};
+    filetypes = {"javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx"};
     root_dir = util.root_pattern("package.json");
     log_level = lsp.protocol.MessageType.Warning;
     settings = {};
-    capabilities = default_capabilities;
-    on_init = function(client, result)
-      if result.offsetEncoding then
-        client.offset_encoding = result.offsetEncoding
-      end
-    end
   };
-  commands = global_commands;
   on_new_config = function(new_config)
-    local install_info = get_install_info()
+    local install_info = installer.info()
     if install_info.is_installed then
-      new_config.cmd = {install_info.tsserver}
+      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 `:TsServerInstall` or by yourself with `npm`: 
+`typescript-language-server` can be installed via `:LspInstall tsserver` or by yourself with `npm`: 
 ```sh
 npm install -g typescript-language-server
 ```
@@ -83,27 +47,6 @@ npm install -g typescript-language-server
   };
 }
 
-function skeleton.tsserver.install()
-  if not need_bins(bin_name) then return end
-  if not need_bins("sh", "npm", "mkdir", "cd") then
-    vim.api.nvim_err_writeln('Installation requires "sh", "npm", "mkdir", "cd"')
-    return
-  end
-  local install_info = get_install_info()
-  if install_info.is_installed then
-    return
-  end
-  local cmd = io.popen("sh", "w")
-  local install_script = ([[
-set -eo pipefail
-mkdir -p "{{install_dir}}"
-cd "{{install_dir}}"
-npm install typescript-language-server
-]]):gsub("{{(%S+)}}", install_info)
-  print(install_script)
-  cmd:write(install_script)
-  cmd:close()
-end
-
-skeleton.tsserver.get_install_info = get_install_info
+skeleton[server_name].install = installer.install
+skeleton[server_name].install_info = installer.info
 -- vim:et ts=2 sw=2
diff --git a/lua/nvim_lsp/util.lua b/lua/nvim_lsp/util.lua
index 2b13d227..a9ca5680 100644
--- a/lua/nvim_lsp/util.lua
+++ b/lua/nvim_lsp/util.lua
@@ -85,12 +85,12 @@ function M.create_module_commands(module_name, commands)
     table.insert(parts, command_name)
     -- The command definition.
     table.insert(parts,
-        string.format("lua require'nvim_lsp'[%q].commands[%q][1]()", module_name, command_name))
+        string.format("lua require'nvim_lsp'[%q].commands[%q][1](<f-args>)", module_name, command_name))
     api.nvim_command(table.concat(parts, " "))
   end
 end
 
-function M.need_bins(...)
+function M.has_bins(...)
   for i = 1, select("#", ...) do
     if 0 == fn.executable((select(i, ...))) then
       return false
@@ -268,5 +268,103 @@ function M.find_package_json_ancestor(startpath)
   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, fn)
+  local res = {}
+  for i, v in ipairs(t) do table.insert(res, fn(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"), "nvim_lsp")
+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 neovim)")
+    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 -eo pipefail
+    mkdir -p "{{install_dir}}"
+    cd "{{install_dir}}"
+    npm install {{packages}}
+    {{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.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