Add gopls, path utils, and root_pattern pattern.

3 files changed, 345 insertions, 1 deletions

diff --git a/lua/common_lsp.lua b/lua/common_lsp.lua
index d412bb15..2ff03e59 100644
--- a/lua/common_lsp.lua
+++ b/lua/common_lsp.lua
@@ -1,7 +1,8 @@
 local M = {
   texlab = require 'common_lsp/texlab';
+  gopls = require 'common_lsp/gopls';
+  util = require 'common_lsp/util';
 }
 
-
 return M
 -- vim:et ts=2 sw=2
diff --git a/lua/common_lsp/gopls.lua b/lua/common_lsp/gopls.lua
new file mode 100644
index 00000000..c43f4c38
--- /dev/null
+++ b/lua/common_lsp/gopls.lua
@@ -0,0 +1,176 @@
+local util = require 'common_lsp/util'
+local api, validate, lsp = vim.api, vim.validate, vim.lsp
+
+local M = {}
+
+M.name = "gopls"
+
+local default_config
+default_config = {
+  name = M.name;
+  cmd = {"gopls"};
+  filetype = {"go"};
+  root_dir = util.root_pattern("go.mod", ".git");
+  log_level = lsp.protocol.MessageType.Warning;
+  settings = {};
+}
+
+local function setup_callbacks(config)
+  config.callbacks = config.callbacks or {}
+
+  config.callbacks["window/logMessage"] = function(err, method, params, client_id)
+    if params and params.type <= config.log_level then
+      lsp.builtin_callbacks[method](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
+        -- Uncomment this to debug.
+        -- print(string.format("config[%q] = %s", item.section, inspect(value)))
+        table.insert(result, value)
+      end
+    end
+    return result
+  end
+end
+
+-- A function to set up `gopls` easier.
+--
+-- Additionally, it sets up the following commands:
+-- - SKELETON_SPOOKY_COMMAND: This does something SPOOKY.
+--
+-- {config} is the same as |vim.lsp.add_filetype_config()|, but with some
+-- additions and changes:
+--
+-- {root_dir}
+--   REQUIRED function(filename, bufnr) which is called on new candidate
+--   buffers to attach to and returns either a root_dir or nil.
+--   If a root_dir is returned, then this file will also be attached. You can
+--   optionally use {filetype} to help pre-filter by filetype.
+--   If a root_dir is returned which differs from any previously returned
+--   root_dir, a new server will be spawned with that root_dir.
+--   If nil is returned, the buffer is skipped.
+
+--   See |common_lsp.util.search_ancestors()| and the functions which use it:
+--   - |common_lsp.util.root_pattern(patterns...)| finds an ancestor which a
+--   descendent which has one of the files in `patterns...`. This is equivalent
+--   to coc.nvim's "rootPatterns"
+--   - More specific utilities:
+--     - |common_lsp.util.find_git_root()|
+--     - |common_lsp.util.find_node_modules_root()|
+--     - |common_lsp.util.find_package_json_root()|
+--
+--   Defaults to common_lsp.util.root_pattern("go.mod", ".git")
+--
+-- {name}
+--   Defaults to "gopls"
+--
+-- {cmd}
+--   Defaults to {"gopls"}
+--
+-- {filetype}
+--   Defaults to {"go"}. This is optional and only serves to reduce the scope
+--   of files to filter for {root_dir}.
+--
+-- {log_level}
+--   controls the level of logs to show from build processes and other
+--   window/logMessage events. By default it is set to
+--   vim.lsp.protocol.MessageType.Warning instead of
+--   vim.lsp.protocol.MessageType.Log.
+--
+-- {settings}
+--   This is a table, and the keys are case sensitive.
+--   Example: `settings = { }`
+function M.setup(config)
+	validate {
+		root_dir = {config.root_dir, 'f'};
+		filetype = {config.filetype, 't', true};
+	}
+
+	if config.filetype then
+    local filetypes
+    if type(config.filetype) == 'string' then
+      filetypes = { config.filetype }
+    else
+      filetypes = config.filetype
+    end
+		api.nvim_command(string.format(
+				"autocmd FileType %s lua require'common_lsp/%s'.manager.try_add()"
+				, table.concat(filetypes, ',')
+				, M.name
+				))
+	else
+		api.nvim_command(string.format(
+				"autocmd BufReadPost * lua require'common_lsp/%s'.manager.try_add()"
+				, M.name
+				))
+	end
+
+	local get_root_dir = config.root_dir
+
+	M.manager = util.server_per_root_dir_manager(function(_root_dir)
+		local new_config = vim.tbl_extend("keep", config, default_config)
+		-- Deepcopy anything that is >1 level nested.
+		new_config.settings = vim.deepcopy(new_config.settings)
+		util.tbl_deep_extend(new_config.settings, default_config.settings)
+
+		new_config.capabilities = new_config.capabilities or lsp.protocol.make_client_capabilities()
+		util.tbl_deep_extend(new_config.capabilities, {
+			workspace = {
+				configuration = true;
+			}
+		})
+
+		setup_callbacks(new_config)
+
+		new_config.on_attach = util.add_hook_after(new_config.on_attach, function(client, bufnr)
+			if bufnr == api.nvim_get_current_buf() then
+				M._setup_buffer()
+			else
+				api.nvim_command(string.format(
+						"autocmd BufEnter <buffer=%d> ++once lua require'common_lsp/%s'._setup_buffer()",
+						M.name,
+						bufnr))
+			end
+		end)
+		return new_config
+	end)
+
+	function M.manager.try_add()
+    local root_dir = get_root_dir(api.nvim_buf_get_name(0), api.nvim_get_current_buf())
+    print(api.nvim_get_current_buf(), root_dir)
+		local id = M.manager.add(root_dir)
+    lsp.buf_attach_client(0, id)
+	end
+end
+
+-- Declare any commands here. You can use additional modifiers like "-range"
+-- which will be added as command options. All of these commands are buffer
+-- level by default.
+M.commands = {
+  SKELETON_SPOOKY_COMMAND = {
+    function()
+      local bufnr = util.validate_bufnr(0)
+      print("SPOOKY COMMAND STUFF!", bufnr)
+    end;
+  };
+}
+
+function M._setup_buffer()
+  -- Create the module commands
+  util.create_module_commands(M.name, M.commands)
+end
+
+return M
+-- vim:et ts=2 sw=2
+
+
diff --git a/lua/common_lsp/util.lua b/lua/common_lsp/util.lua
index 6da2db1c..b821854a 100644
--- a/lua/common_lsp/util.lua
+++ b/lua/common_lsp/util.lua
@@ -1,5 +1,7 @@
 local validate = vim.validate
 local api = vim.api
+local lsp = vim.lsp
+local uv = vim.loop
 
 local M = {}
 
@@ -87,6 +89,171 @@ function M.create_module_commands(module_name, commands)
   end
 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().sysname == "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 dirname
+  do
+    local strip_dir_pat = path_sep.."([^"..path_sep.."]+)$"
+    local strip_sep_pat = path_sep.."$"
+    dirname = function(path)
+      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(...)
+    return table.concat(vim.tbl_flatten {...}, path_sep)
+  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 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 is_fs_root(v) then return end
+			return dirname(v), path
+		end
+		return it, path, path
+  end
+
+  return {
+    is_dir = is_dir;
+    is_file = is_file;
+    exists = exists;
+    sep = path_sep;
+    dirname = dirname;
+    join = path_join;
+    traverse_parents = traverse_parents;
+    iterate_parents = iterate_parents;
+  }
+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
+
+    -- 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.root_dir = 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, fn)
+  validate { fn = {fn, 'f'} }
+  if fn(startpath) then return startpath end
+  for path in M.path.iterate_parents(startpath) do
+    if fn(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(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
 
 return M
 -- vim:et ts=2 sw=2