455 lines
16 KiB
Lua
455 lines
16 KiB
Lua
local M = {}
|
|
local icons = require("config.icons")
|
|
|
|
function M.set_title()
|
|
local title = " %t"
|
|
local f = io.popen([[zsh -c '
|
|
source $XDG_CONFIG_HOME/zsh/configs/autogenerated/hashes
|
|
print -Pn "$USER@$HOST [%3~] "
|
|
']])
|
|
if f ~= nil then
|
|
title = f:read("*a") or ""
|
|
title = title .. " %t"
|
|
f:close()
|
|
end
|
|
vim.opt.titlestring = title
|
|
end
|
|
|
|
function M.buf_close(bufnr, force)
|
|
local kill_command = "bd"
|
|
|
|
local bo = vim.bo
|
|
local api = vim.api
|
|
local fnamemodify = vim.fn.fnamemodify
|
|
|
|
if bufnr == 0 or bufnr == nil then
|
|
bufnr = api.nvim_get_current_buf()
|
|
end
|
|
|
|
local bufname = api.nvim_buf_get_name(bufnr)
|
|
|
|
if not force then
|
|
local warning
|
|
if bo[bufnr].modified then
|
|
warning = string.format([[No write since last change for (%s)]], fnamemodify(bufname, ":t"))
|
|
elseif api.nvim_buf_get_option(bufnr, "buftype") == "terminal" then
|
|
warning = string.format([[Terminal %s will be killed]], bufname)
|
|
end
|
|
if warning then
|
|
vim.ui.input({
|
|
prompt = string.format([[%s. Close it anyway? [y]es or [n]o (default: no): ]], warning),
|
|
}, function(choice)
|
|
if choice:match "ye?s?" then force = true end
|
|
end)
|
|
if not force then return end
|
|
end
|
|
end
|
|
|
|
-- Get list of window IDs with the buffer to close
|
|
local windows = vim.tbl_filter(function(win)
|
|
return api.nvim_win_get_buf(win) == bufnr
|
|
end, api.nvim_list_wins())
|
|
|
|
if #windows == 0 then return end
|
|
|
|
if force then
|
|
kill_command = kill_command .. "!"
|
|
end
|
|
|
|
-- Get list of active buffers
|
|
local buffers = vim.tbl_filter(function(buf)
|
|
return api.nvim_buf_is_valid(buf) and bo[buf].buflisted
|
|
end, api.nvim_list_bufs())
|
|
|
|
-- If there is only one buffer (which has to be the current one), vim will
|
|
-- create a new buffer on :bd.
|
|
-- For more than one buffer, pick the previous buffer (wrapping around if necessary)
|
|
if #buffers > 1 then
|
|
for i, v in ipairs(buffers) do
|
|
if v == bufnr then
|
|
local prev_buf_idx = i == 1 and (#buffers - 1) or (i - 1)
|
|
local prev_buffer = buffers[prev_buf_idx]
|
|
for _, win in ipairs(windows) do
|
|
api.nvim_win_set_buf(win, prev_buffer)
|
|
end
|
|
end
|
|
end
|
|
else
|
|
vim.cmd('q!')
|
|
end
|
|
|
|
-- Check if buffer still exists, to ensure the target buffer wasn't killed
|
|
-- due to options like bufhidden=wipe.
|
|
if api.nvim_buf_is_valid(bufnr) and bo[bufnr].buflisted then
|
|
vim.cmd(string.format("%s %d", kill_command, bufnr))
|
|
end
|
|
end
|
|
|
|
function M.is_available(plugin)
|
|
local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
|
|
return lazy_config_avail and lazy_config.spec.plugins[plugin] ~= nil
|
|
end
|
|
|
|
function M.empty_map_table()
|
|
local maps = {}
|
|
for _, mode in ipairs { "", "n", "v", "x", "s", "o", "!", "i", "l", "c", "t" } do
|
|
maps[mode] = {}
|
|
end
|
|
-- TODO: Check this on 0.10.0 release
|
|
if vim.fn.has "nvim-0.10.0" == 1 then
|
|
for _, abbr_mode in ipairs { "ia", "ca", "!a" } do
|
|
maps[abbr_mode] = {}
|
|
end
|
|
end
|
|
return maps
|
|
end
|
|
|
|
function M.toggle_term_cmd(opts)
|
|
if not vim.g.user_terminals then
|
|
vim.g.user_terminals = {}
|
|
end
|
|
local terms = vim.g.user_terminals
|
|
if type(opts) == "string" then opts = { cmd = opts, hidden = true } end
|
|
local num = vim.v.count > 0 and vim.v.count or 1
|
|
if not terms[opts.cmd] then terms[opts.cmd] = {} end
|
|
if not terms[opts.cmd][num] then
|
|
if not opts.count then opts.count = vim.tbl_count(terms) * 100 + num end
|
|
if not opts.on_exit then opts.on_exit = function() terms[opts.cmd][num] = nil end end
|
|
terms[opts.cmd][num] = require("toggleterm.terminal").Terminal:new(opts)
|
|
end
|
|
terms[opts.cmd][num]:toggle()
|
|
end
|
|
|
|
-- TODO: test this
|
|
function M.file_worktree(file, worktrees)
|
|
worktrees = worktrees or vim.g.git_worktrees
|
|
if not worktrees then return end
|
|
file = file or vim.fn.expand("%")
|
|
for _, worktree in ipairs(worktrees) do
|
|
local r = vim.fn.system({
|
|
"git",
|
|
"--work-tree",
|
|
worktree.toplevel,
|
|
"--git-dir",
|
|
worktree.gitdir,
|
|
"ls-files",
|
|
"--error-unmatch",
|
|
file
|
|
---@diagnostic disable-next-line: undefined-field
|
|
}):wait()
|
|
if r.code == 0 then
|
|
return worktree
|
|
end
|
|
end
|
|
end
|
|
|
|
function M.which_key_register()
|
|
if M.which_key_queue then
|
|
local wk_avail, wk = pcall(require, "which-key")
|
|
if wk_avail then
|
|
for mode, registration in pairs(M.which_key_queue) do
|
|
wk.register(registration, { mode = mode })
|
|
end
|
|
M.which_key_queue = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
function M.set_maps(map_table, base)
|
|
base = base or {}
|
|
for mode, maps in pairs(map_table) do
|
|
for keymap, options in pairs(maps) do
|
|
if options then
|
|
local cmd = options
|
|
local keymap_opts = base
|
|
if type(options) == "table" then
|
|
cmd = options[1]
|
|
keymap_opts = vim.tbl_deep_extend("force", keymap_opts, options)
|
|
keymap_opts[1] = nil
|
|
end
|
|
if not cmd or keymap_opts.name then -- which-key mapping
|
|
if not keymap_opts.name then keymap_opts.name = keymap_opts.desc end
|
|
if not M.which_key_queue then M.which_key_queue = {} end
|
|
if not M.which_key_queue[mode] then M.which_key_queue[mode] = {} end
|
|
M.which_key_queue[mode][keymap] = keymap_opts
|
|
else -- not which-key mapping
|
|
vim.keymap.set(mode, keymap, cmd, keymap_opts)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if package.loaded["which-key"] then M.which_key_register() end
|
|
end
|
|
|
|
local function del_buffer_autocmd(augroup, bufnr)
|
|
local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
|
|
if cmds_found then vim.tbl_map(function(cmd) vim.api.nvim_del_autocmd(cmd.id) end, cmds) end
|
|
end
|
|
|
|
local function add_buffer_autocmd(augroup, bufnr, autocmds)
|
|
if not vim.tbl_islist(autocmds) then autocmds = { autocmds } end
|
|
local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
|
|
if not cmds_found or vim.tbl_isempty(cmds) then
|
|
vim.api.nvim_create_augroup(augroup, { clear = false })
|
|
for _, autocmd in ipairs(autocmds) do
|
|
local events = autocmd.events
|
|
autocmd.events = nil
|
|
autocmd.group = augroup
|
|
autocmd.buffer = bufnr
|
|
vim.api.nvim_create_autocmd(events, autocmd)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function has_capability(capability, filter)
|
|
for _, client in ipairs(vim.lsp.get_active_clients(filter)) do
|
|
if client.supports_method(capability) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- NOTE: LSP Keymaps here
|
|
function M.lsp_on_attach(client, bufnr)
|
|
local lsp_mappings = M.empty_map_table()
|
|
|
|
lsp_mappings.n["<leader>ld"] = { function() vim.diagnostic.open_float() end, desc = "Hover diagnostics" }
|
|
lsp_mappings.n["[d"] = { function() vim.diagnostic.goto_prev() end, desc = "Previous diagnostic" }
|
|
lsp_mappings.n["]d"] = { function() vim.diagnostic.goto_next() end, desc = "Next diagnostic" }
|
|
lsp_mappings.n["gl"] = { function() vim.diagnostic.open_float() end, desc = "Hover diagnostics" }
|
|
|
|
if M.is_available("telescope.nvim") then
|
|
lsp_mappings.n["<leader>lD"] = {
|
|
function() require("telescope.builtin").diagnostics() end,
|
|
desc = "Search diagnostics",
|
|
}
|
|
end
|
|
|
|
if M.is_available("mason-lspconfig.nvim") then
|
|
lsp_mappings.n["<leader>li"] = { "<cmd>LspInfo<cr>", desc = "LSP information" }
|
|
end
|
|
|
|
if M.is_available("none-ls.nvim") then
|
|
lsp_mappings.n["<leader>lI"] = { "<cmd>NullLsInfo<cr>", desc = "Null-ls information" }
|
|
end
|
|
|
|
if client.supports_method("textDocument/codeAction") then
|
|
lsp_mappings.n["<leader>la"] = {
|
|
function() vim.lsp.buf.code_action() end,
|
|
desc = "Code action",
|
|
}
|
|
lsp_mappings.v["<leader>la"] = lsp_mappings.n["<leader>la"]
|
|
end
|
|
|
|
if client.supports_method("textDocument/codeLens") then
|
|
vim.lsp.codelens.refresh()
|
|
lsp_mappings.n["<leader>ll"] = {
|
|
function() vim.lsp.codelens.refresh() end,
|
|
desc = "Refresh CodeLens",
|
|
}
|
|
lsp_mappings.n["<leader>lL"] = {
|
|
function() vim.lsp.codelens.run() end,
|
|
desc = "Run CodeLens",
|
|
}
|
|
lsp_mappings.n["<Leader>u"] = { desc = icons.Gear .. " Utility" }
|
|
lsp_mappings.n["<leader>uL"] = {
|
|
function() vim.lsp.codelens.clear() end,
|
|
desc = "Toggle CodeLens"
|
|
}
|
|
end
|
|
|
|
if client.supports_method("textDocument/definition") then
|
|
lsp_mappings.n["gd"] = {
|
|
function() vim.lsp.buf.definition() end,
|
|
desc = "Go to definition",
|
|
}
|
|
end
|
|
|
|
if client.supports_method "textDocument/typeDefinition" then
|
|
lsp_mappings.n["gy"] = {
|
|
function() vim.lsp.buf.type_definition() end,
|
|
desc = "Go to type definition",
|
|
}
|
|
end
|
|
|
|
if client.supports_method("textDocument/declaration") then
|
|
lsp_mappings.n["gD"] = {
|
|
function() vim.lsp.buf.declaration() end,
|
|
desc = "Go to declaration",
|
|
}
|
|
end
|
|
|
|
if client.supports_method("textDocument/implementation") then
|
|
lsp_mappings.n["gI"] = {
|
|
function() vim.lsp.buf.implementation() end,
|
|
desc = "List implementations",
|
|
}
|
|
end
|
|
|
|
if client.supports_method("textDocument/references") then
|
|
lsp_mappings.n["gr"] = {
|
|
function() vim.lsp.buf.references() end,
|
|
desc = "List references",
|
|
}
|
|
end
|
|
|
|
if client.supports_method "workspace/symbol" then
|
|
lsp_mappings.n["<leader>lG"] = {
|
|
function() vim.lsp.buf.workspace_symbol() end,
|
|
desc = "List symbols"
|
|
}
|
|
end
|
|
|
|
if client.supports_method "textDocument/rename" then
|
|
lsp_mappings.n["<leader>lr"] = {
|
|
function() vim.lsp.buf.rename() end,
|
|
desc = "Rename symbol",
|
|
}
|
|
end
|
|
|
|
-- TODO: Check this on 0.10.0 release
|
|
if client.supports_method "textDocument/semanticTokens/full" and vim.lsp.semantic_tokens then
|
|
vim.b[bufnr].semantic_tokens_enabled = true
|
|
lsp_mappings.n["<Leader>u"] = { desc = icons.Gear .. " Utility" }
|
|
lsp_mappings.n["<leader>uY"] = {
|
|
function()
|
|
vim.b[bufnr].semantic_tokens_enabled = not vim.b[bufnr].semantic_tokens_enabled
|
|
for _, active_client in ipairs(vim.lsp.get_active_clients { bufnr = bufnr }) do
|
|
if active_client.server_capabilities.semanticTokensProvider then
|
|
vim.lsp.semantic_tokens[vim.b[bufnr].semantic_tokens_enabled and "start" or "stop"](bufnr,
|
|
active_client.id)
|
|
end
|
|
end
|
|
end,
|
|
desc = "Toggle LSP semantic highlight (buffer)",
|
|
}
|
|
end
|
|
|
|
if client.supports_method("textDocument/formatting") then
|
|
lsp_mappings.n["<leader>lf"] = {
|
|
function()
|
|
vim.lsp.buf.format({
|
|
filter = function(c)
|
|
local filetype = vim.bo.filetype
|
|
local n = require "null-ls"
|
|
local s = require "null-ls.sources"
|
|
local method = n.methods.FORMATTING
|
|
local available_formatters = s.get_available(filetype, method)
|
|
if #available_formatters > 0 then
|
|
return c.name == "null-ls"
|
|
end
|
|
return true
|
|
end
|
|
})
|
|
end,
|
|
desc = "Format buffer",
|
|
}
|
|
lsp_mappings.v["<leader>lf"] = lsp_mappings.n["<leader>lf"]
|
|
end
|
|
|
|
if client.supports_method("textDocument/documentHighlight") then
|
|
add_buffer_autocmd("lsp_document_highlight", bufnr, {
|
|
{
|
|
events = { "CursorHold", "CursorHoldI" },
|
|
desc = "highlight references when cursor holds",
|
|
callback = function()
|
|
if not has_capability("textDocument/documentHighlight", { bufnr = bufnr }) then
|
|
del_buffer_autocmd("lsp_document_highlight", bufnr)
|
|
return
|
|
end
|
|
vim.lsp.buf.document_highlight()
|
|
end,
|
|
},
|
|
{
|
|
events = { "CursorMoved", "CursorMovedI", "BufLeave" },
|
|
desc = "clear references when cursor moves",
|
|
callback = function() vim.lsp.buf.clear_references() end,
|
|
},
|
|
})
|
|
end
|
|
|
|
if client.supports_method("textDocument/hover") then
|
|
-- TODO: Check this on 0.10.0 release
|
|
if vim.fn.has "nvim-0.10" == 0 then
|
|
lsp_mappings.n["K"] = {
|
|
function() vim.lsp.buf.hover() end,
|
|
desc = "Hover symbol",
|
|
}
|
|
end
|
|
end
|
|
|
|
if client.supports_method("textDocument/inlayHint") then
|
|
if vim.b.inlay_hints_enabled == nil then vim.b.inlay_hints_enabled = true end
|
|
-- TODO: Check this on 0.10.0 release
|
|
if vim.lsp.inlay_hint then
|
|
if vim.b.inlay_hints_enabled then vim.lsp.inlay_hint.enable(bufnr, true) end
|
|
lsp_mappings.n["<Leader>u"] = { desc = icons.Gear .. " Utility" }
|
|
lsp_mappings.n["<leader>uH"] = {
|
|
function()
|
|
vim.b[bufnr].inlay_hints_enabled = not vim.b[bufnr].inlay_hints_enabled
|
|
if vim.lsp.inlay_hint then
|
|
vim.lsp.inlay_hint.enable(bufnr, vim.b[bufnr].inlay_hints_enabled)
|
|
end
|
|
end,
|
|
desc = "Toggle inlay hints",
|
|
}
|
|
end
|
|
end
|
|
|
|
if client.supports_method "textDocument/signatureHelp" then
|
|
lsp_mappings.n["<leader>lh"] = {
|
|
function() vim.lsp.buf.signature_help() end,
|
|
desc = "Signature help",
|
|
}
|
|
end
|
|
|
|
if M.is_available "telescope.nvim" then
|
|
if lsp_mappings.n.gd then
|
|
lsp_mappings.n.gd[1] = function() require("telescope.builtin").lsp_definitions() end
|
|
end
|
|
if lsp_mappings.n.gI then
|
|
lsp_mappings.n.gI[1] = function() require("telescope.builtin").lsp_implementations() end
|
|
end
|
|
if lsp_mappings.n.gr then
|
|
lsp_mappings.n.gr[1] = function() require("telescope.builtin").lsp_references() end
|
|
end
|
|
if lsp_mappings.n["<leader>lR"] then
|
|
lsp_mappings.n["<leader>lR"][1] = function() require("telescope.builtin").lsp_references() end
|
|
end
|
|
if lsp_mappings.n.gy then
|
|
lsp_mappings.n.gy[1] = function() require("telescope.builtin").lsp_type_definitions() end
|
|
end
|
|
if lsp_mappings.n["<leader>lG"] then
|
|
lsp_mappings.n["<leader>lG"][1] = function()
|
|
vim.ui.input({ prompt = "Symbol Query: (leave empty for word under cursor)" }, function(query)
|
|
if query then
|
|
-- word under cursor if given query is empty
|
|
if query == "" then query = vim.fn.expand "<cword>" end
|
|
require("telescope.builtin").lsp_workspace_symbols {
|
|
query = query,
|
|
prompt_title = ("Find word (%s)"):format(query),
|
|
}
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
if not vim.tbl_isempty(lsp_mappings.v) then
|
|
if lsp_mappings.v["<leader>l"] then lsp_mappings.v["<leader>l"] = { desc = icons.Code .. " LSP" } end
|
|
if lsp_mappings.v["<leader>u"] then lsp_mappings.v["<leader>u"] = { desc = icons.Code .. " LSP" } end
|
|
end
|
|
|
|
M.set_maps(lsp_mappings, { buffer = bufnr })
|
|
end
|
|
|
|
function M.has_value (table, value)
|
|
for _, v in ipairs(table) do
|
|
if v == value then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
return M
|