151 lines
4.2 KiB
Lua
151 lines
4.2 KiB
Lua
local M = {}
|
|
|
|
M.root_patterns = { ".git", "/lua" }
|
|
|
|
function M.setup()
|
|
require "lazyvim.utils.term"
|
|
end
|
|
|
|
---@param on_attach fun(client, buffer)
|
|
function M.on_attach(on_attach)
|
|
vim.api.nvim_create_autocmd("LspAttach", {
|
|
callback = function(args)
|
|
local buffer = args.buf
|
|
local client = vim.lsp.get_client_by_id(args.data.client_id)
|
|
on_attach(client, buffer)
|
|
end,
|
|
})
|
|
end
|
|
|
|
-- returns the root directory based on:
|
|
-- * lsp workspace folders
|
|
-- * lsp root_dir
|
|
-- * root pattern of filename of the current buffer
|
|
-- * root pattern of cwd
|
|
---@return string
|
|
function M.get_root()
|
|
---@type string?
|
|
local path = vim.api.nvim_buf_get_name(0)
|
|
path = path ~= "" and vim.loop.fs_realpath(path) or nil
|
|
---@type string[]
|
|
local roots = {}
|
|
if path then
|
|
for _, client in pairs(vim.lsp.get_clients({ bufnr = 0 })) do
|
|
local workspace = client.config.workspace_folders
|
|
local paths = workspace
|
|
and vim.tbl_map(function(ws)
|
|
return vim.uri_to_fname(ws.uri)
|
|
end, workspace)
|
|
or client.config.root_dir and { client.config.root_dir }
|
|
or {}
|
|
for _, p in ipairs(paths) do
|
|
local r = vim.loop.fs_realpath(p)
|
|
if path:find(r, 1, true) then
|
|
roots[#roots + 1] = r
|
|
end
|
|
end
|
|
end
|
|
end
|
|
table.sort(roots, function(a, b)
|
|
return #a > #b
|
|
end)
|
|
---@type string?
|
|
local root = roots[1]
|
|
if not root then
|
|
path = path and vim.fs.dirname(path) or vim.loop.cwd()
|
|
---@type string?
|
|
root = vim.fs.find(M.root_patterns, { path = path, upward = true })[1]
|
|
root = root and vim.fs.dirname(root) or vim.loop.cwd()
|
|
end
|
|
---@cast root string
|
|
return root
|
|
end
|
|
|
|
---@param silent boolean?
|
|
---@param values? {[1]:any, [2]:any}function
|
|
function M.toggle(option, silent, values)
|
|
if values then
|
|
if vim.opt_local[option]:get() == values[1] then
|
|
vim.opt_local[option] = values[2]
|
|
else
|
|
vim.opt_local[option] = values[1]
|
|
end
|
|
return vim.notify(
|
|
"Set " .. option .. " to " .. vim.opt_local[option]:get(),
|
|
vim.log.levels.INFO,
|
|
{ title = "Option" }
|
|
)
|
|
end
|
|
vim.opt_local[option] = not vim.opt_local[option]:get()
|
|
if not silent then
|
|
vim.notify(
|
|
(vim.opt_local[option]:get() and "Enabled" or "Disabled") .. " " .. option,
|
|
vim.log.levels.INFO,
|
|
{ title = "Option" }
|
|
)
|
|
end
|
|
end
|
|
|
|
local enabled = true
|
|
function M.toggle_diagnostics()
|
|
enabled = not enabled
|
|
if enabled then
|
|
vim.diagnostic.enable()
|
|
vim.notify("Enabled diagnostics", vim.log.levels.INFO, { title = "Diagnostics" })
|
|
else
|
|
vim.diagnostic.disable()
|
|
vim.notify("Disabled diagnostics", vim.log.levels.INFO, { title = "Diagnostics" })
|
|
end
|
|
end
|
|
|
|
function M.smart_quit()
|
|
local bufnr = vim.api.nvim_get_current_buf()
|
|
local modified = vim.api.nvim_buf_get_option(bufnr, "modified")
|
|
if modified then
|
|
vim.ui.input({
|
|
prompt = "You have unsaved changes. Quit anyway? (y/n) ",
|
|
}, function(input)
|
|
if input == "y" then
|
|
vim.cmd("q!")
|
|
end
|
|
end)
|
|
else
|
|
vim.cmd("q!")
|
|
end
|
|
end
|
|
|
|
function M.isempty(s)
|
|
return s == nil or s == ""
|
|
end
|
|
|
|
function M.get_buf_option(opt)
|
|
local status_ok, buf_option = pcall(vim.api.nvim_buf_get_option, 0, opt)
|
|
if not status_ok then
|
|
return nil
|
|
else
|
|
return buf_option
|
|
end
|
|
end
|
|
|
|
function M.telescope(builtin, opts)
|
|
opts = opts or {}
|
|
opts.dir = opts.dir or M.get_root()
|
|
return function()
|
|
require("telescope.builtin")[builtin](vim.tbl_deep_extend("force", { cwd = opts.dir }, opts))
|
|
end
|
|
end
|
|
|
|
-- This might not be best, but it allows for easy resetting
|
|
function M.setColorscheme(scheme)
|
|
local colorscheme = scheme or "gruvbox-material"
|
|
|
|
local okay, _ = pcall(vim.cmd, "colorscheme " .. colorscheme)
|
|
|
|
if not okay then
|
|
vim.notify("Colorscheme " .. colorscheme .. " not found!")
|
|
vim.cmd("colorscheme habamax")
|
|
end
|
|
end
|
|
|
|
return M
|