dp/nixcfg
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Squashed 'users/configs/system/nvim/nvim/' content from commit e088bce2

Browse Source 
git-subtree-dir: users/configs/system/nvim/nvim
git-subtree-split: e088bce2bd90c0b5c35d13a8615a55455b96294d
This commit is contained in:
Daniel Patterson
2023-06-25 15:39:19 +01:00
parent 99c223a78d
commit 4132b0ea05
96 changed files with 7965 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

269
lua/astronvim/autocmds.lua Normal file
View File

@@ -0,0 +1,269 @@
local augroup = vim.api.nvim_create_augroup
local autocmd = vim.api.nvim_create_autocmd
local cmd = vim.api.nvim_create_user_command
local namespace = vim.api.nvim_create_namespace
local utils = require "astronvim.utils"
local is_available = utils.is_available
local astroevent = utils.event
vim.on_key(function(char)
if vim.fn.mode() == "n" then
local new_hlsearch = vim.tbl_contains({ "<CR>", "n", "N", "*", "#", "?", "/" }, vim.fn.keytrans(char))
if vim.opt.hlsearch:get() ~= new_hlsearch then vim.opt.hlsearch = new_hlsearch end
end
end, namespace "auto_hlsearch")
local bufferline_group = augroup("bufferline", { clear = true })
autocmd({ "BufAdd", "BufEnter", "TabNewEntered" }, {
desc = "Update buffers when adding new buffers",
group = bufferline_group,
callback = function(args)
if not vim.t.bufs then vim.t.bufs = {} end
local bufs = vim.t.bufs
if not vim.tbl_contains(bufs, args.buf) then
table.insert(bufs, args.buf)
vim.t.bufs = bufs
end
vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
astroevent "BufsUpdated"
end,
})
autocmd("BufDelete", {
desc = "Update buffers when deleting buffers",
group = bufferline_group,
callback = function(args)
for _, tab in ipairs(vim.api.nvim_list_tabpages()) do
local bufs = vim.t[tab].bufs
if bufs then
for i, bufnr in ipairs(bufs) do
if bufnr == args.buf then
table.remove(bufs, i)
vim.t[tab].bufs = bufs
break
end
end
end
end
vim.t.bufs = vim.tbl_filter(require("astronvim.utils.buffer").is_valid, vim.t.bufs)
astroevent "BufsUpdated"
vim.cmd.redrawtabline()
end,
})
autocmd({ "VimEnter", "FileType", "BufEnter", "WinEnter" }, {
desc = "URL Highlighting",
group = augroup("highlighturl", { clear = true }),
callback = function() utils.set_url_match() end,
})
local view_group = augroup("auto_view", { clear = true })
autocmd({ "BufWinLeave", "BufWritePost", "WinLeave" }, {
desc = "Save view with mkview for real files",
group = view_group,
callback = function(event)
if vim.b[event.buf].view_activated then vim.cmd.mkview { mods = { emsg_silent = true } } end
end,
})
autocmd("BufWinEnter", {
desc = "Try to load file view if available and enable view saving for real files",
group = view_group,
callback = function(event)
if not vim.b[event.buf].view_activated then
local filetype = vim.api.nvim_get_option_value("filetype", { buf = event.buf })
local buftype = vim.api.nvim_get_option_value("buftype", { buf = event.buf })
local ignore_filetypes = { "gitcommit", "gitrebase", "svg", "hgcommit" }
if buftype == "" and filetype and filetype ~= "" and not vim.tbl_contains(ignore_filetypes, filetype) then
vim.b[event.buf].view_activated = true
vim.cmd.loadview { mods = { emsg_silent = true } }
end
end
end,
})
autocmd("BufWinEnter", {
desc = "Make q close help, man, quickfix, dap floats",
group = augroup("q_close_windows", { clear = true }),
callback = function(event)
local filetype = vim.api.nvim_get_option_value("filetype", { buf = event.buf })
local buftype = vim.api.nvim_get_option_value("buftype", { buf = event.buf })
if buftype == "nofile" or filetype == "help" then
vim.keymap.set("n", "q", "<cmd>close<cr>", {
desc = "Close window",
buffer = event.buf,
silent = true,
nowait = true,
})
end
end,
})
autocmd("TextYankPost", {
desc = "Highlight yanked text",
group = augroup("highlightyank", { clear = true }),
pattern = "*",
callback = function() vim.highlight.on_yank() end,
})
autocmd("FileType", {
desc = "Unlist quickfist buffers",
group = augroup("unlist_quickfist", { clear = true }),
pattern = "qf",
callback = function() vim.opt_local.buflisted = false end,
})
autocmd("BufEnter", {
desc = "Quit AstroNvim if more than one window is open and only sidebar windows are list",
group = augroup("auto_quit", { clear = true }),
callback = function()
local wins = vim.api.nvim_tabpage_list_wins(0)
-- Both neo-tree and aerial will auto-quit if there is only a single window left
if #wins <= 1 then return end
local sidebar_fts = { aerial = true, ["neo-tree"] = true }
for _, winid in ipairs(wins) do
if vim.api.nvim_win_is_valid(winid) then
local bufnr = vim.api.nvim_win_get_buf(winid)
local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
-- If any visible windows are not sidebars, early return
if not sidebar_fts[filetype] then
return
-- If the visible window is a sidebar
else
-- only count filetypes once, so remove a found sidebar from the detection
sidebar_fts[filetype] = nil
end
end
end
if #vim.api.nvim_list_tabpages() > 1 then
vim.cmd.tabclose()
else
vim.cmd.qall()
end
end,
})
if is_available "alpha-nvim" then
autocmd({ "User", "BufEnter" }, {
desc = "Disable status and tablines for alpha",
group = augroup("alpha_settings", { clear = true }),
callback = function(event)
if
(
(event.event == "User" and event.file == "AlphaReady")
or (event.event == "BufEnter" and vim.api.nvim_get_option_value("filetype", { buf = event.buf }) == "alpha")
) and not vim.g.before_alpha
then
vim.g.before_alpha = { showtabline = vim.opt.showtabline:get(), laststatus = vim.opt.laststatus:get() }
vim.opt.showtabline, vim.opt.laststatus = 0, 0
elseif
vim.g.before_alpha
and event.event == "BufEnter"
and vim.api.nvim_get_option_value("buftype", { buf = event.buf }) ~= "nofile"
then
vim.opt.laststatus, vim.opt.showtabline = vim.g.before_alpha.laststatus, vim.g.before_alpha.showtabline
vim.g.before_alpha = nil
end
end,
})
autocmd("VimEnter", {
desc = "Start Alpha when vim is opened with no arguments",
group = augroup("alpha_autostart", { clear = true }),
callback = function()
local should_skip = false
if vim.fn.argc() > 0 or vim.fn.line2byte(vim.fn.line "$") ~= -1 or not vim.o.modifiable then
should_skip = true
else
for _, arg in pairs(vim.v.argv) do
if arg == "-b" or arg == "-c" or vim.startswith(arg, "+") or arg == "-S" then
should_skip = true
break
end
end
end
if not should_skip then require("alpha").start(true, require("alpha").default_config) end
end,
})
end
if is_available "resession.nvim" then
autocmd("VimLeavePre", {
desc = "Save session on close",
group = augroup("resession_auto_save", { clear = true }),
callback = function()
local buf_utils = require "astronvim.utils.buffer"
local autosave = buf_utils.sessions.autosave
if autosave and buf_utils.is_valid_session() then
local save = require("resession").save
if autosave.last then save "Last Session" end
if autosave.cwd then save(vim.fn.getcwd(), { dir = "dirsession", notify = false }) end
end
end,
})
end
if is_available "neo-tree.nvim" then
autocmd("BufEnter", {
desc = "Open Neo-Tree on startup with directory",
group = augroup("neotree_start", { clear = true }),
callback = function()
if package.loaded["neo-tree"] then
vim.api.nvim_del_augroup_by_name "neotree_start"
else
local stats = vim.loop.fs_stat(vim.api.nvim_buf_get_name(0))
if stats and stats.type == "directory" then
vim.api.nvim_del_augroup_by_name "neotree_start"
require "neo-tree"
end
end
end,
})
autocmd("TermClose", {
pattern = "*lazygit",
desc = "Refresh Neo-Tree git when closing lazygit",
group = augroup("neotree_git_refresh", { clear = true }),
callback = function()
if package.loaded["neo-tree.sources.git_status"] then require("neo-tree.sources.git_status").refresh() end
end,
})
end
autocmd({ "VimEnter", "ColorScheme" }, {
desc = "Load custom highlights from user configuration",
group = augroup("astronvim_highlights", { clear = true }),
callback = function()
if vim.g.colors_name then
for _, module in ipairs { "init", vim.g.colors_name } do
for group, spec in pairs(astronvim.user_opts("highlights." .. module)) do
vim.api.nvim_set_hl(0, group, spec)
end
end
end
astroevent "ColorScheme"
end,
})
autocmd({ "BufReadPost", "BufNewFile" }, {
desc = "AstroNvim user events for file detection (AstroFile and AstroGitFile)",
group = augroup("file_user_events", { clear = true }),
callback = function(args)
if not (vim.fn.expand "%" == "" or vim.api.nvim_get_option_value("buftype", { buf = args.buf }) == "nofile") then
utils.event "File"
if utils.cmd({ "git", "-C", vim.fn.expand "%:p:h", "rev-parse" }, false) then utils.event "GitFile" end
end
end,
})
cmd(
"AstroChangelog",
function() require("astronvim.utils.updater").changelog() end,
{ desc = "Check AstroNvim Changelog" }
)
cmd(
"AstroUpdatePackages",
function() require("astronvim.utils.updater").update_packages() end,
{ desc = "Update Plugins and Mason" }
)
cmd("AstroRollback", function() require("astronvim.utils.updater").rollback() end, { desc = "Rollback AstroNvim" })
cmd("AstroUpdate", function() require("astronvim.utils.updater").update() end, { desc = "Update AstroNvim" })
cmd("AstroVersion", function() require("astronvim.utils.updater").version() end, { desc = "Check AstroNvim Version" })
cmd("AstroReload", function() require("astronvim.utils").reload() end, { desc = "Reload AstroNvim (Experimental)" })

132
lua/astronvim/bootstrap.lua Normal file
View File

@@ -0,0 +1,132 @@
--- ### AstroNvim Core Bootstrap
--
-- This module simply sets up the global `astronvim` module.
-- This is automatically loaded and should not be resourced, everything is accessible through the global `astronvim` variable.
--
-- @module astronvim.bootstrap
-- @copyright 2022
-- @license GNU General Public License v3.0
_G.astronvim = {}
--- installation details from external installers
astronvim.install = _G["astronvim_installation"] or { home = vim.fn.stdpath "config" }
astronvim.supported_configs = { astronvim.install.home }
--- external astronvim configuration folder
astronvim.install.config = vim.fn.stdpath("config"):gsub("[^/\\]+$", "astronvim")
-- check if they are the same, protects against NVIM_APPNAME use for isolated install
if astronvim.install.home ~= astronvim.install.config then
vim.opt.rtp:append(astronvim.install.config)
--- supported astronvim user conifg folders
table.insert(astronvim.supported_configs, astronvim.install.config)
end
--- Looks to see if a module path references a lua file in a configuration folder and tries to load it. If there is an error loading the file, write an error and continue
---@param module string The module path to try and load
---@return table|nil # The loaded module if successful or nil
local function load_module_file(module)
-- placeholder for final return value
local found_file = nil
-- search through each of the supported configuration locations
for _, config_path in ipairs(astronvim.supported_configs) do
-- convert the module path to a file path (example user.init -> user/init.lua)
local module_path = config_path .. "/lua/" .. module:gsub("%.", "/") .. ".lua"
-- check if there is a readable file, if so, set it as found
if vim.fn.filereadable(module_path) == 1 then found_file = module_path end
end
-- if we found a readable lua file, try to load it
local out = nil
if found_file then
-- try to load the file
local status_ok, loaded_module = pcall(require, module)
-- if successful at loading, set the return variable
if status_ok then
out = loaded_module
-- if unsuccessful, throw an error
else
vim.api.nvim_err_writeln("Error loading file: " .. found_file .. "\n\n" .. loaded_module)
end
end
-- return the loaded module or nil if no file found
return out
end
--- Main configuration engine logic for extending a default configuration table with either a function override or a table to merge into the default option
-- @param overrides the override definition, either a table or a function that takes a single parameter of the original table
-- @param default the default configuration table
-- @param extend boolean value to either extend the default or simply overwrite it if an override is provided
-- @return the new configuration table
local function func_or_extend(overrides, default, extend)
-- if we want to extend the default with the provided override
if extend then
-- if the override is a table, use vim.tbl_deep_extend
if type(overrides) == "table" then
local opts = overrides or {}
default = default and vim.tbl_deep_extend("force", default, opts) or opts
-- if the override is a function, call it with the default and overwrite default with the return value
elseif type(overrides) == "function" then
default = overrides(default)
end
-- if extend is set to false and we have a provided override, simply override the default
elseif overrides ~= nil then
default = overrides
end
-- return the modified default table
return default
end
--- user settings from the base `user/init.lua` file
local user_settings = load_module_file "user.init"
--- Search the user settings (user/init.lua table) for a table with a module like path string
-- @param module the module path like string to look up in the user settings table
-- @return the value of the table entry if exists or nil
local function user_setting_table(module)
-- get the user settings table
local settings = user_settings or {}
-- iterate over the path string split by '.' to look up the table value
for tbl in string.gmatch(module, "([^%.]+)") do
settings = settings[tbl]
-- if key doesn't exist, keep the nil value and stop searching
if settings == nil then break end
end
-- return the found settings
return settings
end
--- User configuration entry point to override the default options of a configuration table with a user configuration file or table in the user/init.lua user settings
---@param module string The module path of the override setting
---@param default? any The default value that will be overridden
---@param extend? boolean # Whether extend the default settings or overwrite them with the user settings entirely (default: true)
---@return any # The new configuration settings with the user overrides applied
function astronvim.user_opts(module, default, extend)
-- default to extend = true
if extend == nil then extend = true end
-- if no default table is provided set it to an empty table
if default == nil then default = {} end
-- try to load a module file if it exists
local user_module_settings = load_module_file("user." .. module)
-- if no user module file is found, try to load an override from the user settings table from user/init.lua
if user_module_settings == nil then user_module_settings = user_setting_table(module) end
-- if a user override was found call the configuration engine
if user_module_settings ~= nil then default = func_or_extend(user_module_settings, default, extend) end
-- return the final configuration table with any overrides applied
return default
end
--- Updater settings overridden with any user provided configuration
astronvim.updater = {
options = astronvim.user_opts("updater", { remote = "origin", channel = "stable" }),
snapshot = { module = "lazy_snapshot", path = vim.fn.stdpath "config" .. "/lua/lazy_snapshot.lua" },
rollback_file = vim.fn.stdpath "cache" .. "/astronvim_rollback.lua",
}
local options = astronvim.updater.options
if astronvim.install.is_stable ~= nil then options.channel = astronvim.install.is_stable and "stable" or "nightly" end
if options.pin_plugins == nil then options.pin_plugins = options.channel == "stable" end
--- table of user created terminals
astronvim.user_terminals = {}
--- table of language servers to ignore the setup of, configured through lsp.skip_setup in the user configuration
astronvim.lsp = { skip_setup = astronvim.user_opts("lsp.skip_setup", {}), progress = {} }
--- the default colorscheme to apply on startup
astronvim.default_colorscheme = astronvim.user_opts("colorscheme", "astrotheme", false)

75
lua/astronvim/health.lua Normal file
View File

@@ -0,0 +1,75 @@
local M = {}
-- TODO: remove deprecated method check after dropping support for neovim v0.9
local health = {
start = vim.health.start or vim.health.report_start,
ok = vim.health.ok or vim.health.report_ok,
warn = vim.health.warn or vim.health.report_warn,
error = vim.health.error or vim.health.report_error,
info = vim.health.info or vim.health.report_info,
}
function M.check()
health.start "AstroNvim"
health.info("AstroNvim Version: " .. require("astronvim.utils.updater").version(true))
health.info("Neovim Version: v" .. vim.fn.matchstr(vim.fn.execute "version", "NVIM v\\zs[^\n]*"))
if vim.version().prerelease then
health.warn "Neovim nightly is not officially supported and may have breaking changes"
elseif vim.fn.has "nvim-0.8" == 1 then
health.ok "Using stable Neovim >= 0.8.0"
else
health.error "Neovim >= 0.8.0 is required"
end
local programs = {
{
cmd = { "git" },
type = "error",
msg = "Used for core functionality such as updater and plugin management",
extra_check = function(program)
local git_version = require("astronvim.utils.git").git_version()
if git_version then
if git_version.major < 2 or (git_version.major == 2 and git_version.min < 19) then
program.msg = ("Git %s installed, >= 2.19.0 is required"):format(git_version.str)
else
return true
end
else
program.msg = "Unable to validate git version"
end
end,
},
{
cmd = { "xdg-open", "open", "explorer" },
type = "warn",
msg = "Used for `gx` mapping for opening files with system opener (Optional)",
},
{ cmd = { "lazygit" }, type = "warn", msg = "Used for mappings to pull up git TUI (Optional)" },
{ cmd = { "node" }, type = "warn", msg = "Used for mappings to pull up node REPL (Optional)" },
{ cmd = { "gdu" }, type = "warn", msg = "Used for mappings to pull up disk usage analyzer (Optional)" },
{ cmd = { "btm" }, type = "warn", msg = "Used for mappings to pull up system monitor (Optional)" },
{ cmd = { "python", "python3" }, type = "warn", msg = "Used for mappings to pull up python REPL (Optional)" },
}
for _, program in ipairs(programs) do
local name = table.concat(program.cmd, "/")
local found = false
for _, cmd in ipairs(program.cmd) do
if vim.fn.executable(cmd) == 1 then
name = cmd
if not program.extra_check or program.extra_check(program) then found = true end
break
end
end
if found then
health.ok(("`%s` is installed: %s"):format(name, program.msg))
else
health[program.type](("`%s` is not installed: %s"):format(name, program.msg))
end
end
end
return M

60
lua/astronvim/icons/nerd_font.lua Normal file
View File

@@ -0,0 +1,60 @@
return {
ActiveLSP = "",
ActiveTS = "",
ArrowLeft = "",
ArrowRight = "",
Bookmarks = "",
BufferClose = "󰅖",
DapBreakpoint = "",
DapBreakpointCondition = "",
DapBreakpointRejected = "",
DapLogPoint = ".>",
DapStopped = "󰁕",
Debugger = "",
DefaultFile = "󰈙",
Diagnostic = "󰒡",
DiagnosticError = "",
DiagnosticHint = "󰌵",
DiagnosticInfo = "󰋼",
DiagnosticWarn = "",
Ellipsis = "…",
FileNew = "",
FileModified = "",
FileReadOnly = "",
FoldClosed = "",
FoldOpened = "",
FoldSeparator = " ",
FolderClosed = "",
FolderEmpty = "",
FolderOpen = "",
Git = "󰊢",
GitAdd = "",
GitBranch = "",
GitChange = "",
GitConflict = "",
GitDelete = "",
GitIgnored = "◌",
GitRenamed = "➜",
GitSign = "▎",
GitStaged = "✓",
GitUnstaged = "✗",
GitUntracked = "★",
LSPLoaded = "", -- TODO: Remove unused icon in AstroNvim v4
LSPLoading1 = "",
LSPLoading2 = "󰀚",
LSPLoading3 = "",
MacroRecording = "",
Package = "󰏖",
Paste = "󰅌",
Refresh = "",
Search = "",
Selected = "❯",
Session = "󱂬",
Sort = "󰒺",
Spellcheck = "󰓆",
Tab = "󰓩",
TabClose = "󰅙",
Terminal = "",
Window = "",
WordFile = "󰈭",
}

41
lua/astronvim/icons/text.lua Normal file
View File

@@ -0,0 +1,41 @@
return {
ActiveLSP = "LSP:",
ArrowLeft = "<",
ArrowRight = ">",
BufferClose = "x",
DapBreakpoint = "B",
DapBreakpointCondition = "C",
DapBreakpointRejected = "R",
DapLogPoint = "L",
DapStopped = ">",
DefaultFile = "[F]",
DiagnosticError = "X",
DiagnosticHint = "?",
DiagnosticInfo = "i",
DiagnosticWarn = "!",
Ellipsis = "...",
FileModified = "*",
FileReadOnly = "[lock]",
FoldClosed = "+",
FoldOpened = "-",
FoldSeparator = " ",
FolderClosed = "[D]",
FolderEmpty = "[E]",
FolderOpen = "[O]",
GitAdd = "[+]",
GitChange = "[/]",
GitConflict = "[!]",
GitDelete = "[-]",
GitIgnored = "[I]",
GitRenamed = "[R]",
GitSign = "|",
GitStaged = "[S]",
GitUnstaged = "[U]",
GitUntracked = "[?]",
MacroRecording = "Recording:",
Paste = "[PASTE]",
Search = "?",
Selected = "*",
Spellcheck = "[SPELL]",
TabClose = "X",
}

52
lua/astronvim/lazy.lua Normal file
View File

@@ -0,0 +1,52 @@
local lazypath = vim.fn.stdpath "data" .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
local output = vim.fn.system {
"git",
"clone",
"--filter=blob:none",
"--branch=stable",
"https://github.com/folke/lazy.nvim.git",
lazypath,
}
if vim.api.nvim_get_vvar "shell_error" ~= 0 then
vim.api.nvim_err_writeln("Error cloning lazy.nvim repository...\n\n" .. output)
end
local oldcmdheight = vim.opt.cmdheight:get()
vim.opt.cmdheight = 1
vim.notify "Please wait while plugins are installed..."
vim.api.nvim_create_autocmd("User", {
desc = "Load Mason and Treesitter after Lazy installs plugins",
once = true,
pattern = "LazyInstall",
callback = function()
vim.cmd.bw()
vim.opt.cmdheight = oldcmdheight
vim.tbl_map(function(module) pcall(require, module) end, { "nvim-treesitter", "mason" })
require("astronvim.utils").notify "Mason is installing packages if configured, check status with :Mason"
end,
})
end
vim.opt.rtp:prepend(lazypath)
local user_plugins = astronvim.user_opts "plugins"
for _, config_dir in ipairs(astronvim.supported_configs) do
if vim.fn.isdirectory(config_dir .. "/lua/user/plugins") == 1 then user_plugins = { import = "user.plugins" } end
end
local spec = astronvim.updater.options.pin_plugins and { { import = astronvim.updater.snapshot.module } } or {}
vim.list_extend(spec, { { import = "plugins" }, user_plugins })
local colorscheme = astronvim.default_colorscheme and { astronvim.default_colorscheme } or nil
require("lazy").setup(astronvim.user_opts("lazy", {
spec = spec,
defaults = { lazy = true },
install = { colorscheme = colorscheme },
performance = {
rtp = {
paths = astronvim.supported_configs,
disabled_plugins = { "tohtml", "gzip", "zipPlugin", "netrwPlugin", "tarPlugin" },
},
},
lockfile = vim.fn.stdpath "data" .. "/lazy-lock.json",
}))

433
lua/astronvim/mappings.lua Normal file
View File

@@ -0,0 +1,433 @@
-- TODO: replace <leader> to <Leader> everywhere in AstroNvim v4 to match vimdoc
local utils = require "astronvim.utils"
local get_icon = utils.get_icon
local is_available = utils.is_available
local ui = require "astronvim.utils.ui"
local maps = { i = {}, n = {}, v = {}, t = {} }
local sections = {
f = { desc = get_icon("Search", 1, true) .. "Find" },
p = { desc = get_icon("Package", 1, true) .. "Packages" },
l = { desc = get_icon("ActiveLSP", 1, true) .. "LSP" },
u = { desc = get_icon("Window", 1, true) .. "UI/UX" },
b = { desc = get_icon("Tab", 1, true) .. "Buffers" },
bs = { desc = get_icon("Sort", 1, true) .. "Sort Buffers" },
d = { desc = get_icon("Debugger", 1, true) .. "Debugger" },
g = { desc = get_icon("Git", 1, true) .. "Git" },
S = { desc = get_icon("Session", 1, true) .. "Session" },
t = { desc = get_icon("Terminal", 1, true) .. "Terminal" },
}
-- Normal --
-- Standard Operations
maps.n["j"] = { "v:count == 0 ? 'gj' : 'j'", expr = true, desc = "Move cursor down" }
maps.n["k"] = { "v:count == 0 ? 'gk' : 'k'", expr = true, desc = "Move cursor up" }
maps.n["<leader>w"] = { "<cmd>w<cr>", desc = "Save" }
maps.n["<leader>q"] = { "<cmd>confirm q<cr>", desc = "Quit" }
maps.n["<leader>n"] = { "<cmd>enew<cr>", desc = "New File" }
maps.n["gx"] = { utils.system_open, desc = "Open the file under cursor with system app" }
maps.n["<C-s>"] = { "<cmd>w!<cr>", desc = "Force write" }
maps.n["<C-q>"] = { "<cmd>q!<cr>", desc = "Force quit" }
maps.n["|"] = { "<cmd>vsplit<cr>", desc = "Vertical Split" }
maps.n["\\"] = { "<cmd>split<cr>", desc = "Horizontal Split" }
-- Plugin Manager
maps.n["<leader>p"] = sections.p
maps.n["<leader>pi"] = { function() require("lazy").install() end, desc = "Plugins Install" }
maps.n["<leader>ps"] = { function() require("lazy").home() end, desc = "Plugins Status" }
maps.n["<leader>pS"] = { function() require("lazy").sync() end, desc = "Plugins Sync" }
maps.n["<leader>pu"] = { function() require("lazy").check() end, desc = "Plugins Check Updates" }
maps.n["<leader>pU"] = { function() require("lazy").update() end, desc = "Plugins Update" }
-- AstroNvim
maps.n["<leader>pa"] = { "<cmd>AstroUpdatePackages<cr>", desc = "Update Plugins and Mason Packages" }
maps.n["<leader>pA"] = { "<cmd>AstroUpdate<cr>", desc = "AstroNvim Update" }
maps.n["<leader>pv"] = { "<cmd>AstroVersion<cr>", desc = "AstroNvim Version" }
maps.n["<leader>pl"] = { "<cmd>AstroChangelog<cr>", desc = "AstroNvim Changelog" }
-- Manage Buffers
maps.n["<leader>c"] = { function() require("astronvim.utils.buffer").close() end, desc = "Close buffer" }
maps.n["<leader>C"] = { function() require("astronvim.utils.buffer").close(0, true) end, desc = "Force close buffer" }
maps.n["]b"] =
{ function() require("astronvim.utils.buffer").nav(vim.v.count > 0 and vim.v.count or 1) end, desc = "Next buffer" }
maps.n["[b"] = {
function() require("astronvim.utils.buffer").nav(-(vim.v.count > 0 and vim.v.count or 1)) end,
desc = "Previous buffer",
}
maps.n[">b"] = {
function() require("astronvim.utils.buffer").move(vim.v.count > 0 and vim.v.count or 1) end,
desc = "Move buffer tab right",
}
maps.n["<b"] = {
function() require("astronvim.utils.buffer").move(-(vim.v.count > 0 and vim.v.count or 1)) end,
desc = "Move buffer tab left",
}
maps.n["<leader>b"] = sections.b
maps.n["<leader>bc"] =
{ function() require("astronvim.utils.buffer").close_all(true) end, desc = "Close all buffers except current" }
maps.n["<leader>bC"] = { function() require("astronvim.utils.buffer").close_all() end, desc = "Close all buffers" }
maps.n["<leader>bb"] = {
function()
require("astronvim.utils.status.heirline").buffer_picker(function(bufnr) vim.api.nvim_win_set_buf(0, bufnr) end)
end,
desc = "Select buffer from tabline",
}
maps.n["<leader>bd"] = {
function()
require("astronvim.utils.status.heirline").buffer_picker(
function(bufnr) require("astronvim.utils.buffer").close(bufnr) end
)
end,
desc = "Close buffer from tabline",
}
maps.n["<leader>bl"] =
{ function() require("astronvim.utils.buffer").close_left() end, desc = "Close all buffers to the left" }
maps.n["<leader>br"] =
{ function() require("astronvim.utils.buffer").close_right() end, desc = "Close all buffers to the right" }
maps.n["<leader>bs"] = sections.bs
maps.n["<leader>bse"] = { function() require("astronvim.utils.buffer").sort "extension" end, desc = "By extension" }
maps.n["<leader>bsr"] =
{ function() require("astronvim.utils.buffer").sort "unique_path" end, desc = "By relative path" }
maps.n["<leader>bsp"] = { function() require("astronvim.utils.buffer").sort "full_path" end, desc = "By full path" }
maps.n["<leader>bsi"] = { function() require("astronvim.utils.buffer").sort "bufnr" end, desc = "By buffer number" }
maps.n["<leader>bsm"] = { function() require("astronvim.utils.buffer").sort "modified" end, desc = "By modification" }
maps.n["<leader>b\\"] = {
function()
require("astronvim.utils.status.heirline").buffer_picker(function(bufnr)
vim.cmd.split()
vim.api.nvim_win_set_buf(0, bufnr)
end)
end,
desc = "Horizontal split buffer from tabline",
}
maps.n["<leader>b|"] = {
function()
require("astronvim.utils.status.heirline").buffer_picker(function(bufnr)
vim.cmd.vsplit()
vim.api.nvim_win_set_buf(0, bufnr)
end)
end,
desc = "Vertical split buffer from tabline",
}
-- Navigate tabs
maps.n["]t"] = { function() vim.cmd.tabnext() end, desc = "Next tab" }
maps.n["[t"] = { function() vim.cmd.tabprevious() end, desc = "Previous tab" }
-- Alpha
if is_available "alpha-nvim" then
maps.n["<leader>h"] = {
function()
local wins = vim.api.nvim_tabpage_list_wins(0)
if #wins > 1 and vim.api.nvim_get_option_value("filetype", { win = wins[1] }) == "neo-tree" then
vim.fn.win_gotoid(wins[2]) -- go to non-neo-tree window to toggle alpha
end
require("alpha").start(false, require("alpha").default_config)
end,
desc = "Home Screen",
}
end
-- Comment
if is_available "Comment.nvim" then
maps.n["<leader>/"] = {
function() require("Comment.api").toggle.linewise.count(vim.v.count > 0 and vim.v.count or 1) end,
desc = "Toggle comment line",
}
maps.v["<leader>/"] = {
"<esc><cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<cr>",
desc = "Toggle comment for selection",
}
end
-- GitSigns
if is_available "gitsigns.nvim" then
maps.n["<leader>g"] = sections.g
maps.n["]g"] = { function() require("gitsigns").next_hunk() end, desc = "Next Git hunk" }
maps.n["[g"] = { function() require("gitsigns").prev_hunk() end, desc = "Previous Git hunk" }
maps.n["<leader>gl"] = { function() require("gitsigns").blame_line() end, desc = "View Git blame" }
maps.n["<leader>gL"] = { function() require("gitsigns").blame_line { full = true } end, desc = "View full Git blame" }
maps.n["<leader>gp"] = { function() require("gitsigns").preview_hunk() end, desc = "Preview Git hunk" }
maps.n["<leader>gh"] = { function() require("gitsigns").reset_hunk() end, desc = "Reset Git hunk" }
maps.n["<leader>gr"] = { function() require("gitsigns").reset_buffer() end, desc = "Reset Git buffer" }
maps.n["<leader>gs"] = { function() require("gitsigns").stage_hunk() end, desc = "Stage Git hunk" }
maps.n["<leader>gS"] = { function() require("gitsigns").stage_buffer() end, desc = "Stage Git buffer" }
maps.n["<leader>gu"] = { function() require("gitsigns").undo_stage_hunk() end, desc = "Unstage Git hunk" }
maps.n["<leader>gd"] = { function() require("gitsigns").diffthis() end, desc = "View Git diff" }
end
-- NeoTree
if is_available "neo-tree.nvim" then
maps.n["<leader>e"] = { "<cmd>Neotree toggle<cr>", desc = "Toggle Explorer" }
maps.n["<leader>o"] = {
function()
if vim.bo.filetype == "neo-tree" then
vim.cmd.wincmd "p"
else
vim.cmd.Neotree "focus"
end
end,
desc = "Toggle Explorer Focus",
}
end
-- Session Manager
if is_available "neovim-session-manager" then
maps.n["<leader>S"] = sections.S
maps.n["<leader>Sl"] = { "<cmd>SessionManager! load_last_session<cr>", desc = "Load last session" }
maps.n["<leader>Ss"] = { "<cmd>SessionManager! save_current_session<cr>", desc = "Save this session" }
maps.n["<leader>Sd"] = { "<cmd>SessionManager! delete_session<cr>", desc = "Delete session" }
maps.n["<leader>Sf"] = { "<cmd>SessionManager! load_session<cr>", desc = "Search sessions" }
maps.n["<leader>S."] =
{ "<cmd>SessionManager! load_current_dir_session<cr>", desc = "Load current directory session" }
end
if is_available "resession.nvim" then
maps.n["<leader>S"] = sections.S
maps.n["<leader>Sl"] = { function() require("resession").load "Last Session" end, desc = "Load last session" }
maps.n["<leader>Ss"] = { function() require("resession").save() end, desc = "Save this session" }
maps.n["<leader>St"] = { function() require("resession").save_tab() end, desc = "Save this tab's session" }
maps.n["<leader>Sd"] = { function() require("resession").delete() end, desc = "Delete a session" }
maps.n["<leader>Sf"] = { function() require("resession").load() end, desc = "Load a session" }
maps.n["<leader>S."] = {
function() require("resession").load(vim.fn.getcwd(), { dir = "dirsession" }) end,
desc = "Load current directory session",
}
end
-- Package Manager
if is_available "mason.nvim" then
maps.n["<leader>pm"] = { "<cmd>Mason<cr>", desc = "Mason Installer" }
maps.n["<leader>pM"] = { "<cmd>MasonUpdateAll<cr>", desc = "Mason Update" }
end
-- Smart Splits
if is_available "smart-splits.nvim" then
maps.n["<C-h>"] = { function() require("smart-splits").move_cursor_left() end, desc = "Move to left split" }
maps.n["<C-j>"] = { function() require("smart-splits").move_cursor_down() end, desc = "Move to below split" }
maps.n["<C-k>"] = { function() require("smart-splits").move_cursor_up() end, desc = "Move to above split" }
maps.n["<C-l>"] = { function() require("smart-splits").move_cursor_right() end, desc = "Move to right split" }
maps.n["<C-Up>"] = { function() require("smart-splits").resize_up() end, desc = "Resize split up" }
maps.n["<C-Down>"] = { function() require("smart-splits").resize_down() end, desc = "Resize split down" }
maps.n["<C-Left>"] = { function() require("smart-splits").resize_left() end, desc = "Resize split left" }
maps.n["<C-Right>"] = { function() require("smart-splits").resize_right() end, desc = "Resize split right" }
else
maps.n["<C-h>"] = { "<C-w>h", desc = "Move to left split" }
maps.n["<C-j>"] = { "<C-w>j", desc = "Move to below split" }
maps.n["<C-k>"] = { "<C-w>k", desc = "Move to above split" }
maps.n["<C-l>"] = { "<C-w>l", desc = "Move to right split" }
maps.n["<C-Up>"] = { "<cmd>resize -2<CR>", desc = "Resize split up" }
maps.n["<C-Down>"] = { "<cmd>resize +2<CR>", desc = "Resize split down" }
maps.n["<C-Left>"] = { "<cmd>vertical resize -2<CR>", desc = "Resize split left" }
maps.n["<C-Right>"] = { "<cmd>vertical resize +2<CR>", desc = "Resize split right" }
end
-- SymbolsOutline
if is_available "aerial.nvim" then
maps.n["<leader>l"] = sections.l
maps.n["<leader>lS"] = { function() require("aerial").toggle() end, desc = "Symbols outline" }
end
-- Telescope
if is_available "telescope.nvim" then
maps.n["<leader>f"] = sections.f
maps.n["<leader>g"] = sections.g
maps.n["<leader>gb"] = { function() require("telescope.builtin").git_branches() end, desc = "Git branches" }
maps.n["<leader>gc"] = { function() require("telescope.builtin").git_commits() end, desc = "Git commits" }
maps.n["<leader>gt"] = { function() require("telescope.builtin").git_status() end, desc = "Git status" }
maps.n["<leader>f<CR>"] = { function() require("telescope.builtin").resume() end, desc = "Resume previous search" }
maps.n["<leader>f'"] = { function() require("telescope.builtin").marks() end, desc = "Find marks" }
maps.n["<leader>fa"] = {
function()
local cwd = vim.fn.stdpath "config" .. "/.."
local search_dirs = {}
for _, dir in ipairs(astronvim.supported_configs) do -- search all supported config locations
if dir == astronvim.install.home then dir = dir .. "/lua/user" end -- don't search the astronvim core files
if vim.fn.isdirectory(dir) == 1 then table.insert(search_dirs, dir) end -- add directory to search if exists
end
if vim.tbl_isempty(search_dirs) then -- if no config folders found, show warning
utils.notify("No user configuration files found", vim.log.levels.WARN)
else
if #search_dirs == 1 then cwd = search_dirs[1] end -- if only one directory, focus cwd
require("telescope.builtin").find_files {
prompt_title = "Config Files",
search_dirs = search_dirs,
cwd = cwd,
} -- call telescope
end
end,
desc = "Find AstroNvim config files",
}
maps.n["<leader>fb"] = { function() require("telescope.builtin").buffers() end, desc = "Find buffers" }
maps.n["<leader>fc"] =
{ function() require("telescope.builtin").grep_string() end, desc = "Find for word under cursor" }
maps.n["<leader>fC"] = { function() require("telescope.builtin").commands() end, desc = "Find commands" }
maps.n["<leader>ff"] = { function() require("telescope.builtin").find_files() end, desc = "Find files" }
maps.n["<leader>fF"] = {
function() require("telescope.builtin").find_files { hidden = true, no_ignore = true } end,
desc = "Find all files",
}
maps.n["<leader>fh"] = { function() require("telescope.builtin").help_tags() end, desc = "Find help" }
maps.n["<leader>fk"] = { function() require("telescope.builtin").keymaps() end, desc = "Find keymaps" }
maps.n["<leader>fm"] = { function() require("telescope.builtin").man_pages() end, desc = "Find man" }
if is_available "nvim-notify" then
maps.n["<leader>fn"] =
{ function() require("telescope").extensions.notify.notify() end, desc = "Find notifications" }
end
maps.n["<leader>fo"] = { function() require("telescope.builtin").oldfiles() end, desc = "Find history" }
maps.n["<leader>fr"] = { function() require("telescope.builtin").registers() end, desc = "Find registers" }
maps.n["<leader>ft"] =
{ function() require("telescope.builtin").colorscheme { enable_preview = true } end, desc = "Find themes" }
maps.n["<leader>fw"] = { function() require("telescope.builtin").live_grep() end, desc = "Find words" }
maps.n["<leader>fW"] = {
function()
require("telescope.builtin").live_grep {
additional_args = function(args) return vim.list_extend(args, { "--hidden", "--no-ignore" }) end,
}
end,
desc = "Find words in all files",
}
maps.n["<leader>l"] = sections.l
maps.n["<leader>ls"] = {
function()
local aerial_avail, _ = pcall(require, "aerial")
if aerial_avail then
require("telescope").extensions.aerial.aerial()
else
require("telescope.builtin").lsp_document_symbols()
end
end,
desc = "Search symbols",
}
end
-- Terminal
if is_available "toggleterm.nvim" then
maps.n["<leader>t"] = sections.t
if vim.fn.executable "lazygit" == 1 then
maps.n["<leader>g"] = sections.g
maps.n["<leader>gg"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
maps.n["<leader>tl"] = { function() utils.toggle_term_cmd "lazygit" end, desc = "ToggleTerm lazygit" }
end
if vim.fn.executable "node" == 1 then
maps.n["<leader>tn"] = { function() utils.toggle_term_cmd "node" end, desc = "ToggleTerm node" }
end
if vim.fn.executable "gdu" == 1 then
maps.n["<leader>tu"] = { function() utils.toggle_term_cmd "gdu" end, desc = "ToggleTerm gdu" }
end
if vim.fn.executable "btm" == 1 then
maps.n["<leader>tt"] = { function() utils.toggle_term_cmd "btm" end, desc = "ToggleTerm btm" }
end
local python = vim.fn.executable "python" == 1 and "python" or vim.fn.executable "python3" == 1 and "python3"
if python then maps.n["<leader>tp"] = { function() utils.toggle_term_cmd(python) end, desc = "ToggleTerm python" } end
maps.n["<leader>tf"] = { "<cmd>ToggleTerm direction=float<cr>", desc = "ToggleTerm float" }
maps.n["<leader>th"] = { "<cmd>ToggleTerm size=10 direction=horizontal<cr>", desc = "ToggleTerm horizontal split" }
maps.n["<leader>tv"] = { "<cmd>ToggleTerm size=80 direction=vertical<cr>", desc = "ToggleTerm vertical split" }
maps.n["<F7>"] = { "<cmd>ToggleTerm<cr>", desc = "Toggle terminal" }
maps.t["<F7>"] = maps.n["<F7>"]
maps.n["<C-'>"] = maps.n["<F7>"] -- requires terminal that supports binding <C-'>
maps.t["<C-'>"] = maps.n["<F7>"] -- requires terminal that supports binding <C-'>
end
if is_available "nvim-dap" then
maps.n["<leader>d"] = sections.d
maps.v["<leader>d"] = sections.d
-- modified function keys found with `showkey -a` in the terminal to get key code
-- run `nvim -V3log +quit` and search through the "Terminal info" in the `log` file for the correct keyname
maps.n["<F5>"] = { function() require("dap").continue() end, desc = "Debugger: Start" }
maps.n["<F17>"] = { function() require("dap").terminate() end, desc = "Debugger: Stop" } -- Shift+F5
maps.n["<F21>"] = {
function()
vim.ui.input({ prompt = "Condition: " }, function(condition)
if condition then require("dap").set_breakpoint(condition) end
end)
end,
desc = "Debugger: Conditional Breakpoint",
}
maps.n["<F29>"] = { function() require("dap").restart_frame() end, desc = "Debugger: Restart" } -- Control+F5
maps.n["<F6>"] = { function() require("dap").pause() end, desc = "Debugger: Pause" }
maps.n["<F9>"] = { function() require("dap").toggle_breakpoint() end, desc = "Debugger: Toggle Breakpoint" }
maps.n["<F10>"] = { function() require("dap").step_over() end, desc = "Debugger: Step Over" }
maps.n["<F11>"] = { function() require("dap").step_into() end, desc = "Debugger: Step Into" }
maps.n["<F23>"] = { function() require("dap").step_out() end, desc = "Debugger: Step Out" } -- Shift+F11
maps.n["<leader>db"] = { function() require("dap").toggle_breakpoint() end, desc = "Toggle Breakpoint (F9)" }
maps.n["<leader>dB"] = { function() require("dap").clear_breakpoints() end, desc = "Clear Breakpoints" }
maps.n["<leader>dc"] = { function() require("dap").continue() end, desc = "Start/Continue (F5)" }
maps.n["<leader>dC"] = {
function()
vim.ui.input({ prompt = "Condition: " }, function(condition)
if condition then require("dap").set_breakpoint(condition) end
end)
end,
desc = "Conditional Breakpoint (S-F9)",
}
maps.n["<leader>di"] = { function() require("dap").step_into() end, desc = "Step Into (F11)" }
maps.n["<leader>do"] = { function() require("dap").step_over() end, desc = "Step Over (F10)" }
maps.n["<leader>dO"] = { function() require("dap").step_out() end, desc = "Step Out (S-F11)" }
maps.n["<leader>dq"] = { function() require("dap").close() end, desc = "Close Session" }
maps.n["<leader>dQ"] = { function() require("dap").terminate() end, desc = "Terminate Session (S-F5)" }
maps.n["<leader>dp"] = { function() require("dap").pause() end, desc = "Pause (F6)" }
maps.n["<leader>dr"] = { function() require("dap").restart_frame() end, desc = "Restart (C-F5)" }
maps.n["<leader>dR"] = { function() require("dap").repl.toggle() end, desc = "Toggle REPL" }
maps.n["<leader>ds"] = { function() require("dap").run_to_cursor() end, desc = "Run To Cursor" }
if is_available "nvim-dap-ui" then
maps.n["<leader>dE"] = {
function()
vim.ui.input({ prompt = "Expression: " }, function(expr)
if expr then require("dapui").eval(expr) end
end)
end,
desc = "Evaluate Input",
}
maps.v["<leader>dE"] = { function() require("dapui").eval() end, desc = "Evaluate Input" }
maps.n["<leader>du"] = { function() require("dapui").toggle() end, desc = "Toggle Debugger UI" }
maps.n["<leader>dh"] = { function() require("dap.ui.widgets").hover() end, desc = "Debugger Hover" }
end
end
-- Improved Code Folding
if is_available "nvim-ufo" then
maps.n["zR"] = { function() require("ufo").openAllFolds() end, desc = "Open all folds" }
maps.n["zM"] = { function() require("ufo").closeAllFolds() end, desc = "Close all folds" }
maps.n["zr"] = { function() require("ufo").openFoldsExceptKinds() end, desc = "Fold less" }
maps.n["zm"] = { function() require("ufo").closeFoldsWith() end, desc = "Fold more" }
maps.n["zp"] = { function() require("ufo").peekFoldedLinesUnderCursor() end, desc = "Peek fold" }
end
-- Stay in indent mode
maps.v["<S-Tab>"] = { "<gv", desc = "Unindent line" }
maps.v["<Tab>"] = { ">gv", desc = "Indent line" }
-- Improved Terminal Navigation
maps.t["<C-h>"] = { "<cmd>wincmd h<cr>", desc = "Terminal left window navigation" }
maps.t["<C-j>"] = { "<cmd>wincmd j<cr>", desc = "Terminal down window navigation" }
maps.t["<C-k>"] = { "<cmd>wincmd k<cr>", desc = "Terminal up window navigation" }
maps.t["<C-l>"] = { "<cmd>wincmd l<cr>", desc = "Terminal right window navigation" }
maps.n["<leader>u"] = sections.u
-- Custom menu for modification of the user experience
if is_available "nvim-autopairs" then maps.n["<leader>ua"] = { ui.toggle_autopairs, desc = "Toggle autopairs" } end
maps.n["<leader>ub"] = { ui.toggle_background, desc = "Toggle background" }
if is_available "nvim-cmp" then maps.n["<leader>uc"] = { ui.toggle_cmp, desc = "Toggle autocompletion" } end
if is_available "nvim-colorizer.lua" then
maps.n["<leader>uC"] = { "<cmd>ColorizerToggle<cr>", desc = "Toggle color highlight" }
end
maps.n["<leader>ud"] = { ui.toggle_diagnostics, desc = "Toggle diagnostics" }
maps.n["<leader>ug"] = { ui.toggle_signcolumn, desc = "Toggle signcolumn" }
maps.n["<leader>ui"] = { ui.set_indent, desc = "Change indent setting" }
maps.n["<leader>ul"] = { ui.toggle_statusline, desc = "Toggle statusline" }
maps.n["<leader>uL"] = { ui.toggle_codelens, desc = "Toggle CodeLens" }
maps.n["<leader>un"] = { ui.change_number, desc = "Change line numbering" }
maps.n["<leader>uN"] = { ui.toggle_ui_notifications, desc = "Toggle Notifications" }
maps.n["<leader>up"] = { ui.toggle_paste, desc = "Toggle paste mode" }
maps.n["<leader>us"] = { ui.toggle_spell, desc = "Toggle spellcheck" }
maps.n["<leader>uS"] = { ui.toggle_conceal, desc = "Toggle conceal" }
maps.n["<leader>ut"] = { ui.toggle_tabline, desc = "Toggle tabline" }
maps.n["<leader>uu"] = { ui.toggle_url_match, desc = "Toggle URL highlight" }
maps.n["<leader>uw"] = { ui.toggle_wrap, desc = "Toggle wrap" }
maps.n["<leader>uy"] = { ui.toggle_syntax, desc = "Toggle syntax highlight" }
maps.n["<leader>uh"] = { ui.toggle_foldcolumn, desc = "Toggle foldcolumn" }
utils.set_mappings(astronvim.user_opts("mappings", maps))

74
lua/astronvim/options.lua Normal file
View File

@@ -0,0 +1,74 @@
vim.opt.viewoptions:remove "curdir" -- disable saving current directory with views
vim.opt.shortmess:append { s = true, I = true } -- disable startup message
vim.opt.backspace:append { "nostop" } -- Don't stop backspace at insert
if vim.fn.has "nvim-0.9" == 1 then
vim.opt.diffopt:append "linematch:60" -- enable linematch diff algorithm
end
local options = astronvim.user_opts("options", {
opt = {
breakindent = true, -- Wrap indent to match line start
clipboard = "unnamedplus", -- Connection to the system clipboard
cmdheight = 0, -- hide command line unless needed
completeopt = { "menu", "menuone", "noselect" }, -- Options for insert mode completion
copyindent = true, -- Copy the previous indentation on autoindenting
cursorline = true, -- Highlight the text line of the cursor
expandtab = true, -- Enable the use of space in tab
fileencoding = "utf-8", -- File content encoding for the buffer
fillchars = { eob = " " }, -- Disable `~` on nonexistent lines
foldenable = true, -- enable fold for nvim-ufo
foldlevel = 99, -- set high foldlevel for nvim-ufo
foldlevelstart = 99, -- start with all code unfolded
foldcolumn = vim.fn.has "nvim-0.9" == 1 and "1" or nil, -- show foldcolumn in nvim 0.9
history = 100, -- Number of commands to remember in a history table
ignorecase = true, -- Case insensitive searching
infercase = true, -- Infer cases in keyword completion
laststatus = 3, -- globalstatus
linebreak = true, -- Wrap lines at 'breakat'
mouse = "a", -- Enable mouse support
number = true, -- Show numberline
preserveindent = true, -- Preserve indent structure as much as possible
pumheight = 10, -- Height of the pop up menu
relativenumber = true, -- Show relative numberline
scrolloff = 8, -- Number of lines to keep above and below the cursor
shiftwidth = 2, -- Number of space inserted for indentation
showmode = false, -- Disable showing modes in command line
showtabline = 2, -- always display tabline
sidescrolloff = 8, -- Number of columns to keep at the sides of the cursor
signcolumn = "yes", -- Always show the sign column
smartcase = true, -- Case sensitivie searching
smartindent = true, -- Smarter autoindentation
splitbelow = true, -- Splitting a new window below the current one
splitright = true, -- Splitting a new window at the right of the current one
tabstop = 2, -- Number of space in a tab
termguicolors = true, -- Enable 24-bit RGB color in the TUI
timeoutlen = 500, -- Shorten key timeout length a little bit for which-key
undofile = true, -- Enable persistent undo
updatetime = 300, -- Length of time to wait before triggering the plugin
virtualedit = "block", -- allow going past end of line in visual block mode
wrap = false, -- Disable wrapping of lines longer than the width of window
writebackup = false, -- Disable making a backup before overwriting a file
},
g = {
mapleader = " ", -- set leader key
maplocalleader = ",", -- set default local leader key
-- AstroNvim specific global options
autoformat_enabled = true, -- enable or disable auto formatting at start (lsp.formatting.format_on_save must be enabled)
autopairs_enabled = true, -- enable autopairs at start
cmp_enabled = true, -- enable completion at start
codelens_enabled = true, -- enable or disable automatic codelens refreshing for lsp that support it
diagnostics_mode = 3, -- set the visibility of diagnostics in the UI (0=off, 1=only show in status line, 2=virtual text off, 3=all on)
highlighturl_enabled = true, -- highlight URLs by default
icons_enabled = true, -- disable icons in the UI (disable if no nerd font is available)
inlay_hints_enabled = false, -- enable or disable LSP inlay hints on startup (Neovim v0.10 only)
lsp_handlers_enabled = true, -- enable or disable default vim.lsp.handlers (hover and signatureHelp)
semantic_tokens_enabled = true, -- enable or disable LSP semantic tokens on startup
ui_notifications_enabled = true, -- disable notifications (TODO: rename to notifications_enabled in AstroNvim v4)
},
t = vim.t.bufs and vim.t.bufs or { bufs = vim.api.nvim_list_bufs() }, -- initialize buffers for the current tab
})
for scope, table in pairs(options) do
for setting, value in pairs(table) do
vim[scope][setting] = value
end
end

228
lua/astronvim/utils/buffer.lua Normal file
View File

@@ -0,0 +1,228 @@
--- ### AstroNvim Buffer Utilities
--
-- Buffer management related utility functions
--
-- This module can be loaded with `local buffer_utils = require "astronvim.utils.buffer"`
--
-- @module astronvim.utils.buffer
-- @copyright 2022
-- @license GNU General Public License v3.0
local M = {}
-- TODO: Add user configuration table for this once resession is default
--- Configuration table for controlling session options
M.sessions = {
autosave = {
last = true, -- auto save last session
cwd = true, -- auto save session for each working directory
},
ignore = {
dirs = {}, -- working directories to ignore sessions in
filetypes = { "gitcommit", "gitrebase" }, -- filetypes to ignore sessions
buftypes = {}, -- buffer types to ignore sessions
},
}
--- Check if a buffer is valid
---@param bufnr number The buffer to check
---@return boolean # Whether the buffer is valid or not
function M.is_valid(bufnr)
if not bufnr or bufnr < 1 then return false end
return vim.api.nvim_buf_is_valid(bufnr) and vim.bo[bufnr].buflisted
end
--- Check if a buffer can be restored
---@param bufnr number The buffer to check
---@return boolean # Whether the buffer is restorable or not
function M.is_restorable(bufnr)
if not M.is_valid(bufnr) or vim.api.nvim_get_option_value("bufhidden", { buf = bufnr }) ~= "" then return false end
local buftype = vim.api.nvim_get_option_value("buftype", { buf = bufnr })
if buftype == "" then
-- Normal buffer, check if it listed.
if not vim.api.nvim_get_option_value("buflisted", { buf = bufnr }) then return false end
-- Check if it has a filename.
if vim.api.nvim_buf_get_name(bufnr) == "" then return false end
end
if
vim.tbl_contains(M.sessions.ignore.filetypes, vim.api.nvim_get_option_value("filetype", { buf = bufnr }))
or vim.tbl_contains(M.sessions.ignore.buftypes, vim.api.nvim_get_option_value("buftype", { buf = bufnr }))
then
return false
end
return true
end
--- Check if the current buffers form a valid session
---@return boolean # Whether the current session of buffers is a valid session
function M.is_valid_session()
local cwd = vim.fn.getcwd()
for _, dir in ipairs(M.sessions.ignore.dirs) do
if vim.fn.expand(dir) == cwd then return false end
end
for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
if M.is_restorable(bufnr) then return true end
end
return false
end
--- Move the current buffer tab n places in the bufferline
---@param n number The number of tabs to move the current buffer over by (positive = right, negative = left)
function M.move(n)
if n == 0 then return end -- if n = 0 then no shifts are needed
local bufs = vim.t.bufs -- make temp variable
for i, bufnr in ipairs(bufs) do -- loop to find current buffer
if bufnr == vim.api.nvim_get_current_buf() then -- found index of current buffer
for _ = 0, (n % #bufs) - 1 do -- calculate number of right shifts
local new_i = i + 1 -- get next i
if i == #bufs then -- if at end, cycle to beginning
new_i = 1 -- next i is actually 1 if at the end
local val = bufs[i] -- save value
table.remove(bufs, i) -- remove from end
table.insert(bufs, new_i, val) -- insert at beginning
else -- if not at the end,then just do an in place swap
bufs[i], bufs[new_i] = bufs[new_i], bufs[i]
end
i = new_i -- iterate i to next value
end
break
end
end
vim.t.bufs = bufs -- set buffers
require("astronvim.utils").event "BufsUpdated"
vim.cmd.redrawtabline() -- redraw tabline
end
--- Navigate left and right by n places in the bufferline
-- @param n number The number of tabs to navigate to (positive = right, negative = left)
function M.nav(n)
local current = vim.api.nvim_get_current_buf()
for i, v in ipairs(vim.t.bufs) do
if current == v then
vim.cmd.b(vim.t.bufs[(i + n - 1) % #vim.t.bufs + 1])
break
end
end
end
--- Navigate to a specific buffer by its position in the bufferline
---@param tabnr number The position of the buffer to navigate to
function M.nav_to(tabnr) vim.cmd.b(vim.t.bufs[tabnr]) end
--- Close a given buffer
---@param bufnr? number The buffer to close or the current buffer if not provided
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
function M.close(bufnr, force)
if force == nil then force = false end
if require("astronvim.utils").is_available "bufdelete.nvim" then
require("bufdelete").bufdelete(bufnr, force)
else
vim.cmd((force and "bd!" or "confirm bd") .. (bufnr == nil and "" or bufnr))
end
end
--- Close all buffers
---@param keep_current? boolean Whether or not to keep the current buffer (default: false)
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
function M.close_all(keep_current, force)
if keep_current == nil then keep_current = false end
local current = vim.api.nvim_get_current_buf()
for _, bufnr in ipairs(vim.t.bufs) do
if not keep_current or bufnr ~= current then M.close(bufnr, force) end
end
end
--- Close buffers to the left of the current buffer
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
function M.close_left(force)
local current = vim.api.nvim_get_current_buf()
for _, bufnr in ipairs(vim.t.bufs) do
if bufnr == current then break end
M.close(bufnr, force)
end
end
--- Close buffers to the right of the current buffer
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
function M.close_right(force)
local current = vim.api.nvim_get_current_buf()
local after_current = false
for _, bufnr in ipairs(vim.t.bufs) do
if after_current then M.close(bufnr, force) end
if bufnr == current then after_current = true end
end
end
--- Sort a the buffers in the current tab based on some comparator
---@param compare_func string|function a string of a comparator defined in require("astronvim.utils.buffer").comparator or a custom comparator function
---@param skip_autocmd boolean|nil whether or not to skip triggering AstroBufsUpdated autocmd event
---@return boolean # Whether or not the buffers were sorted
function M.sort(compare_func, skip_autocmd)
if type(compare_func) == "string" then compare_func = M.comparator[compare_func] end
if type(compare_func) == "function" then
local bufs = vim.t.bufs
table.sort(bufs, compare_func)
vim.t.bufs = bufs
if not skip_autocmd then require("astronvim.utils").event "BufsUpdated" end
vim.cmd.redrawtabline()
return true
end
return false
end
--- Close the current tab
function M.close_tab()
if #vim.api.nvim_list_tabpages() > 1 then
vim.t.bufs = nil
require("astronvim.utils").event "BufsUpdated"
vim.cmd.tabclose()
end
end
--- A table of buffer comparator functions
M.comparator = {}
local fnamemodify = vim.fn.fnamemodify
local function bufinfo(bufnr) return vim.fn.getbufinfo(bufnr)[1] end
local function unique_path(bufnr)
return require("astronvim.utils.status.provider").unique_path() { bufnr = bufnr }
.. fnamemodify(bufinfo(bufnr).name, ":t")
end
--- Comparator of two buffer numbers
---@param bufnr_a integer buffer number A
---@param bufnr_b integer buffer number B
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
function M.comparator.bufnr(bufnr_a, bufnr_b) return bufnr_a < bufnr_b end
--- Comparator of two buffer numbers based on the file extensions
---@param bufnr_a integer buffer number A
---@param bufnr_b integer buffer number B
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
function M.comparator.extension(bufnr_a, bufnr_b)
return fnamemodify(bufinfo(bufnr_a).name, ":e") < fnamemodify(bufinfo(bufnr_b).name, ":e")
end
--- Comparator of two buffer numbers based on the full path
---@param bufnr_a integer buffer number A
---@param bufnr_b integer buffer number B
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
function M.comparator.full_path(bufnr_a, bufnr_b)
return fnamemodify(bufinfo(bufnr_a).name, ":p") < fnamemodify(bufinfo(bufnr_b).name, ":p")
end
--- Comparator of two buffers based on their unique path
---@param bufnr_a integer buffer number A
---@param bufnr_b integer buffer number B
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
function M.comparator.unique_path(bufnr_a, bufnr_b) return unique_path(bufnr_a) < unique_path(bufnr_b) end
--- Comparator of two buffers based on modification date
---@param bufnr_a integer buffer number A
---@param bufnr_b integer buffer number B
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
function M.comparator.modified(bufnr_a, bufnr_b) return bufinfo(bufnr_a).lastused > bufinfo(bufnr_b).lastused end
return M

20
lua/astronvim/utils/ffi.lua Normal file
View File

@@ -0,0 +1,20 @@
-- ### AstroNvim C Extensions
local ffi = require "ffi"
-- Custom C extension to get direct fold information from Neovim
ffi.cdef [[
typedef struct {} Error;
typedef struct {} win_T;
typedef struct {
int start; // line number where deepest fold starts
int level; // fold level, when zero other fields are N/A
int llevel; // lowest level that starts in v:lnum
int lines; // number of lines from v:lnum to end of closed fold
} foldinfo_T;
foldinfo_T fold_info(win_T* wp, int lnum);
win_T *find_window_by_handle(int Window, Error *err);
int compute_foldcolumn(win_T *wp, int col);
]]
return ffi

189
lua/astronvim/utils/git.lua Normal file
View File

@@ -0,0 +1,189 @@
--- ### Git LUA API
--
-- This module can be loaded with `local git = require "astronvim.utils.git"`
--
-- @module astronvim.utils.git
-- @copyright 2022
-- @license GNU General Public License v3.0
local git = { url = "https://github.com/" }
local function trim_or_nil(str) return type(str) == "string" and vim.trim(str) or nil end
--- Run a git command from the AstroNvim installation directory
---@param args string|string[] the git arguments
---@return string|nil # The result of the command or nil if unsuccessful
function git.cmd(args, ...)
if type(args) == "string" then args = { args } end
return require("astronvim.utils").cmd(vim.list_extend({ "git", "-C", astronvim.install.home }, args), ...)
end
--- Check if the AstroNvim is able to reach the `git` command
---@return boolean # The result of running `git --help`
function git.available() return vim.fn.executable "git" == 1 end
--- Check the git client version number
---@return table|nil # A table with version information or nil if there is an error
function git.git_version()
local output = git.cmd({ "--version" }, false)
if output then
local version_str = output:match "%d+%.%d+%.%d"
local major, min, patch = unpack(vim.tbl_map(tonumber, vim.split(version_str, "%.")))
return { major = major, min = min, patch = patch, str = version_str }
end
end
--- Check if the AstroNvim home is a git repo
---@return string|nil # The result of the command
function git.is_repo() return git.cmd({ "rev-parse", "--is-inside-work-tree" }, false) end
--- Fetch git remote
---@param remote string the remote to fetch
---@return string|nil # The result of the command
function git.fetch(remote, ...) return git.cmd({ "fetch", remote }, ...) end
--- Pull the git repo
---@return string|nil # The result of the command
function git.pull(...) return git.cmd({ "pull", "--rebase" }, ...) end
--- Checkout git target
---@param dest string the target to checkout
---@return string|nil # The result of the command
function git.checkout(dest, ...) return git.cmd({ "checkout", dest }, ...) end
--- Hard reset to a git target
-- @param dest the target to hard reset to
---@return string|nil # The result of the command
function git.hard_reset(dest, ...) return git.cmd({ "reset", "--hard", dest }, ...) end
--- Check if a branch contains a commit
---@param remote string the git remote to check
---@param branch string the git branch to check
---@param commit string the git commit to check for
---@return boolean # The result of the command
function git.branch_contains(remote, branch, commit, ...)
return git.cmd({ "merge-base", "--is-ancestor", commit, remote .. "/" .. branch }, ...) ~= nil
end
--- Get the remote name for a given branch
---@param branch string the git branch to check
---@return string|nil # The name of the remote for the given branch
function git.branch_remote(branch, ...) return trim_or_nil(git.cmd({ "config", "branch." .. branch .. ".remote" }, ...)) end
--- Add a git remote
---@param remote string the remote to add
---@param url string the url of the remote
---@return string|nil # The result of the command
function git.remote_add(remote, url, ...) return git.cmd({ "remote", "add", remote, url }, ...) end
--- Update a git remote URL
---@param remote string the remote to update
---@param url string the new URL of the remote
---@return string|nil # The result of the command
function git.remote_update(remote, url, ...) return git.cmd({ "remote", "set-url", remote, url }, ...) end
--- Get the URL of a given git remote
---@param remote string the remote to get the URL of
---@return string|nil # The url of the remote
function git.remote_url(remote, ...) return trim_or_nil(git.cmd({ "remote", "get-url", remote }, ...)) end
--- Get branches from a git remote
---@param remote string the remote to setup branches for
---@param branch string the branch to setup
---@return string|nil # The result of the command
function git.remote_set_branches(remote, branch, ...) return git.cmd({ "remote", "set-branches", remote, branch }, ...) end
--- Get the current version with git describe including tags
---@return string|nil # The current git describe string
function git.current_version(...) return trim_or_nil(git.cmd({ "describe", "--tags" }, ...)) end
--- Get the current branch
---@return string|nil # The branch of the AstroNvim installation
function git.current_branch(...) return trim_or_nil(git.cmd({ "rev-parse", "--abbrev-ref", "HEAD" }, ...)) end
--- Verify a reference
---@return string|nil # The referenced commit
function git.ref_verify(ref, ...) return trim_or_nil(git.cmd({ "rev-parse", "--verify", ref }, ...)) end
--- Get the current head of the git repo
---@return string|nil # the head string
function git.local_head(...) return trim_or_nil(git.cmd({ "rev-parse", "HEAD" }, ...)) end
--- Get the current head of a git remote
---@param remote string the remote to check
---@param branch string the branch to check
---@return string|nil # The head string of the remote branch
function git.remote_head(remote, branch, ...)
return trim_or_nil(git.cmd({ "rev-list", "-n", "1", remote .. "/" .. branch }, ...))
end
--- Get the commit hash of a given tag
---@param tag string the tag to resolve
---@return string|nil # The commit hash of a git tag
function git.tag_commit(tag, ...) return trim_or_nil(git.cmd({ "rev-list", "-n", "1", tag }, ...)) end
--- Get the commit log between two commit hashes
---@param start_hash? string the start commit hash
---@param end_hash? string the end commit hash
---@return string[] # An array like table of commit messages
function git.get_commit_range(start_hash, end_hash, ...)
local range = start_hash and end_hash and start_hash .. ".." .. end_hash or nil
local log = git.cmd({ "log", "--no-merges", '--pretty="format:[%h] %s"', range }, ...)
return log and vim.fn.split(log, "\n") or {}
end
--- Get a list of all tags with a regex filter
---@param search? string a regex to search the tags with (defaults to "v*" for version tags)
---@return string[] # An array like table of tags that match the search
function git.get_versions(search, ...)
local tags = git.cmd({ "tag", "-l", "--sort=version:refname", search == "latest" and "v*" or search }, ...)
return tags and vim.fn.split(tags, "\n") or {}
end
--- Get the latest version of a list of versions
---@param versions? table a list of versions to search (defaults to all versions available)
---@return string|nil # The latest version from the array
function git.latest_version(versions, ...)
if not versions then versions = git.get_versions(...) end
return versions[#versions]
end
--- Parse a remote url
---@param str string the remote to parse to a full git url
---@return string # The full git url for the given remote string
function git.parse_remote_url(str)
return vim.fn.match(str, require("astronvim.utils").url_matcher) == -1
and git.url .. str .. (vim.fn.match(str, "/") == -1 and "/AstroNvim.git" or ".git")
or str
end
--- Check if a Conventional Commit commit message is breaking or not
---@param commit string a commit message
---@return boolean true if the message is breaking, false if the commit message is not breaking
function git.is_breaking(commit) return vim.fn.match(commit, "\\[.*\\]\\s\\+\\w\\+\\((\\w\\+)\\)\\?!:") ~= -1 end
--- Get a list of breaking commits from commit messages using Conventional Commit standard
---@param commits string[] an array like table of commit messages
---@return string[] # An array like table of commits that are breaking
function git.breaking_changes(commits) return vim.tbl_filter(git.is_breaking, commits) end
--- Generate a table of commit messages for neovim's echo API with highlighting
---@param commits string[] an array like table of commit messages
---@return string[][] # An array like table of echo messages to provide to nvim_echo or astronvim.echo
function git.pretty_changelog(commits)
local changelog = {}
for _, commit in ipairs(commits) do
local hash, type, msg = commit:match "(%[.*%])(.*:)(.*)"
if hash and type and msg then
vim.list_extend(changelog, {
{ hash, "DiffText" },
{ type, git.is_breaking(commit) and "DiffDelete" or "DiffChange" },
{ msg },
{ "\n" },
})
end
end
return changelog
end
return git

321
lua/astronvim/utils/init.lua Normal file
View File

@@ -0,0 +1,321 @@
--- ### AstroNvim Utilities
--
-- Various utility functions to use within AstroNvim and user configurations.
--
-- This module can be loaded with `local utils = require "astronvim.utils"`
--
-- @module astronvim.utils
-- @copyright 2022
-- @license GNU General Public License v3.0
local M = {}
--- Merge extended options with a default table of options
---@param default? table The default table that you want to merge into
---@param opts? table The new options that should be merged with the default table
---@return table # The merged table
function M.extend_tbl(default, opts)
opts = opts or {}
return default and vim.tbl_deep_extend("force", default, opts) or opts
end
--- Partially reload AstroNvim user settings. Includes core vim options, mappings, and highlights. This is an experimental feature and may lead to instabilities until restart.
---@param quiet? boolean Whether or not to notify on completion of reloading
---@return boolean # True if the reload was successful, False otherwise
function M.reload(quiet)
local core_modules = { "astronvim.bootstrap", "astronvim.options", "astronvim.mappings" }
local modules = vim.tbl_filter(function(module) return module:find "^user%." end, vim.tbl_keys(package.loaded))
vim.tbl_map(require("plenary.reload").reload_module, vim.list_extend(modules, core_modules))
local success = true
for _, module in ipairs(core_modules) do
local status_ok, fault = pcall(require, module)
if not status_ok then
vim.api.nvim_err_writeln("Failed to load " .. module .. "\n\n" .. fault)
success = false
end
end
if not quiet then -- if not quiet, then notify of result
if success then
M.notify("AstroNvim successfully reloaded", vim.log.levels.INFO)
else
M.notify("Error reloading AstroNvim...", vim.log.levels.ERROR)
end
end
vim.cmd.doautocmd "ColorScheme"
return success
end
--- Insert one or more values into a list like table and maintain that you do not insert non-unique values (THIS MODIFIES `lst`)
---@param lst any[]|nil The list like table that you want to insert into
---@param vals any|any[] Either a list like table of values to be inserted or a single value to be inserted
---@return any[] # The modified list like table
function M.list_insert_unique(lst, vals)
if not lst then lst = {} end
assert(vim.tbl_islist(lst), "Provided table is not a list like table")
if not vim.tbl_islist(vals) then vals = { vals } end
local added = {}
vim.tbl_map(function(v) added[v] = true end, lst)
for _, val in ipairs(vals) do
if not added[val] then
table.insert(lst, val)
added[val] = true
end
end
return lst
end
--- Call function if a condition is met
---@param func function The function to run
---@param condition boolean # Whether to run the function or not
---@return any|nil result # the result of the function running or nil
function M.conditional_func(func, condition, ...)
-- if the condition is true or no condition is provided, evaluate the function with the rest of the parameters and return the result
if condition and type(func) == "function" then return func(...) end
end
--- Get an icon from the AstroNvim internal icons if it is available and return it
---@param kind string The kind of icon in astronvim.icons to retrieve
---@param padding? integer Padding to add to the end of the icon
---@param no_fallback? boolean Whether or not to disable fallback to text icon
---@return string icon
function M.get_icon(kind, padding, no_fallback)
if not vim.g.icons_enabled and no_fallback then return "" end
local icon_pack = vim.g.icons_enabled and "icons" or "text_icons"
if not M[icon_pack] then
M.icons = astronvim.user_opts("icons", require "astronvim.icons.nerd_font")
M.text_icons = astronvim.user_opts("text_icons", require "astronvim.icons.text")
end
local icon = M[icon_pack] and M[icon_pack][kind]
return icon and icon .. string.rep(" ", padding or 0) or ""
end
--- Get a icon spinner table if it is available in the AstroNvim icons. Icons in format `kind1`,`kind2`, `kind3`, ...
---@param kind string The kind of icon to check for sequential entries of
---@return string[]|nil spinners # A collected table of spinning icons in sequential order or nil if none exist
function M.get_spinner(kind, ...)
local spinner = {}
repeat
local icon = M.get_icon(("%s%d"):format(kind, #spinner + 1), ...)
if icon ~= "" then table.insert(spinner, icon) end
until not icon or icon == ""
if #spinner > 0 then return spinner end
end
--- Get highlight properties for a given highlight name
---@param name string The highlight group name
---@param fallback? table The fallback highlight properties
---@return table properties # the highlight group properties
function M.get_hlgroup(name, fallback)
if vim.fn.hlexists(name) == 1 then
local hl
if vim.api.nvim_get_hl then -- check for new neovim 0.9 API
hl = vim.api.nvim_get_hl(0, { name = name, link = false })
if not hl.fg then hl.fg = "NONE" end
if not hl.bg then hl.bg = "NONE" end
else
hl = vim.api.nvim_get_hl_by_name(name, vim.o.termguicolors)
if not hl.foreground then hl.foreground = "NONE" end
if not hl.background then hl.background = "NONE" end
hl.fg, hl.bg = hl.foreground, hl.background
hl.ctermfg, hl.ctermbg = hl.fg, hl.bg
hl.sp = hl.special
end
return hl
end
return fallback or {}
end
--- Serve a notification with a title of AstroNvim
---@param msg string The notification body
---@param type number|nil The type of the notification (:help vim.log.levels)
---@param opts? table The nvim-notify options to use (:help notify-options)
function M.notify(msg, type, opts)
vim.schedule(function() vim.notify(msg, type, M.extend_tbl({ title = "AstroNvim" }, opts)) end)
end
--- Trigger an AstroNvim user event
---@param event string The event name to be appended to Astro
function M.event(event)
vim.schedule(function() vim.api.nvim_exec_autocmds("User", { pattern = "Astro" .. event, modeline = false }) end)
end
--- Open a URL under the cursor with the current operating system
---@param path string The path of the file to open with the system opener
function M.system_open(path)
local cmd
if vim.fn.has "win32" == 1 and vim.fn.executable "explorer" == 1 then
cmd = { "cmd.exe", "/K", "explorer" }
elseif vim.fn.has "unix" == 1 and vim.fn.executable "xdg-open" == 1 then
cmd = { "xdg-open" }
elseif (vim.fn.has "mac" == 1 or vim.fn.has "unix" == 1) and vim.fn.executable "open" == 1 then
cmd = { "open" }
end
if not cmd then M.notify("Available system opening tool not found!", vim.log.levels.ERROR) end
vim.fn.jobstart(vim.fn.extend(cmd, { path or vim.fn.expand "<cfile>" }), { detach = true })
end
--- Toggle a user terminal if it exists, if not then create a new one and save it
---@param opts string|table A terminal command string or a table of options for Terminal:new() (Check toggleterm.nvim documentation for table format)
function M.toggle_term_cmd(opts)
local terms = astronvim.user_terminals
-- if a command string is provided, create a basic table for Terminal:new() options
if type(opts) == "string" then opts = { cmd = opts, hidden = true } end
local num = vim.v.count > 0 and vim.v.count or 1
-- if terminal doesn't exist yet, create it
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
-- toggle the terminal
terms[opts.cmd][num]:toggle()
end
--- Create a button entity to use with the alpha dashboard
---@param sc string The keybinding string to convert to a button
---@param txt string The explanation text of what the keybinding does
---@return table # A button entity table for an alpha configuration
function M.alpha_button(sc, txt)
-- replace <leader> in shortcut text with LDR for nicer printing
local sc_ = sc:gsub("%s", ""):gsub("LDR", "<leader>")
-- if the leader is set, replace the text with the actual leader key for nicer printing
if vim.g.mapleader then sc = sc:gsub("LDR", vim.g.mapleader == " " and "SPC" or vim.g.mapleader) end
-- return the button entity to display the correct text and send the correct keybinding on press
return {
type = "button",
val = txt,
on_press = function()
local key = vim.api.nvim_replace_termcodes(sc_, true, false, true)
vim.api.nvim_feedkeys(key, "normal", false)
end,
opts = {
position = "center",
text = txt,
shortcut = sc,
cursor = 5,
width = 36,
align_shortcut = "right",
hl = "DashboardCenter",
hl_shortcut = "DashboardShortcut",
},
}
end
--- Check if a plugin is defined in lazy. Useful with lazy loading when a plugin is not necessarily loaded yet
---@param plugin string The plugin to search for
---@return boolean available # Whether the plugin is available
function M.is_available(plugin)
local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
return lazy_config_avail and lazy_config.plugins[plugin] ~= nil
end
--- Resolve the options table for a given plugin with lazy
---@param plugin string The plugin to search for
---@return table opts # The plugin options
function M.plugin_opts(plugin)
local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
local lazy_plugin_avail, lazy_plugin = pcall(require, "lazy.core.plugin")
local opts = {}
if lazy_config_avail and lazy_plugin_avail then
local spec = lazy_config.spec.plugins[plugin]
if spec then opts = lazy_plugin.values(spec, "opts") end
end
return opts
end
--- A helper function to wrap a module function to require a plugin before running
---@param plugin string The plugin to call `require("lazy").load` with
---@param module table The system module where the functions live (e.g. `vim.ui`)
---@param func_names string|string[] The functions to wrap in the given module (e.g. `{ "ui", "select }`)
function M.load_plugin_with_func(plugin, module, func_names)
if type(func_names) == "string" then func_names = { func_names } end
for _, func in ipairs(func_names) do
local old_func = module[func]
module[func] = function(...)
module[func] = old_func
require("lazy").load { plugins = { plugin } }
module[func](...)
end
end
end
--- Register queued which-key mappings
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
--- Table based API for setting keybindings
---@param map_table table A nested table where the first key is the vim mode, the second key is the key to map, and the value is the function to set the mapping to
---@param base? table A base set of options to set on every keybinding
function M.set_mappings(map_table, base)
-- iterate over the first keys for each mode
base = base or {}
for mode, maps in pairs(map_table) do
-- iterate over each keybinding set in the current mode
for keymap, options in pairs(maps) do
-- build the options for the command accordingly
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 -- if which-key mapping, queue it
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 -- if not which-key mapping, set it
vim.keymap.set(mode, keymap, cmd, keymap_opts)
end
end
end
end
if package.loaded["which-key"] then M.which_key_register() end -- if which-key is loaded already, register
end
--- regex used for matching a valid URL/URI string
M.url_matcher =
"\\v\\c%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)%([&:#*@~%_\\-=?!+;/0-9a-z]+%(%([.;/?]|[.][.]+)[&:#*@~%_\\-=?!+/0-9a-z]+|:\\d+|,%(%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)@![0-9a-z]+))*|\\([&:#*@~%_\\-=?!+;/.0-9a-z]*\\)|\\[[&:#*@~%_\\-=?!+;/.0-9a-z]*\\]|\\{%([&:#*@~%_\\-=?!+;/.0-9a-z]*|\\{[&:#*@~%_\\-=?!+;/.0-9a-z]*})\\})+"
--- Delete the syntax matching rules for URLs/URIs if set
function M.delete_url_match()
for _, match in ipairs(vim.fn.getmatches()) do
if match.group == "HighlightURL" then vim.fn.matchdelete(match.id) end
end
end
--- Add syntax matching rules for highlighting URLs/URIs
function M.set_url_match()
M.delete_url_match()
if vim.g.highlighturl_enabled then vim.fn.matchadd("HighlightURL", M.url_matcher, 15) end
end
--- Run a shell command and capture the output and if the command succeeded or failed
---@param cmd string|string[] The terminal command to execute
---@param show_error? boolean Whether or not to show an unsuccessful command as an error to the user
---@return string|nil # The result of a successfully executed command or nil
function M.cmd(cmd, show_error)
if type(cmd) == "string" then cmd = { cmd } end
if vim.fn.has "win32" == 1 then cmd = vim.list_extend({ "cmd.exe", "/C" }, cmd) end
local result = vim.fn.system(cmd)
local success = vim.api.nvim_get_vvar "shell_error" == 0
if not success and (show_error == nil or show_error) then
vim.api.nvim_err_writeln(("Error running command %s\nError message:\n%s"):format(table.concat(cmd, " "), result))
end
return success and result:gsub("[\27\155][][()#;?%d]*[A-PRZcf-ntqry=><~]", "") or nil
end
return M

448
lua/astronvim/utils/lsp.lua Normal file
View File

@@ -0,0 +1,448 @@
--- ### AstroNvim LSP Utils
--
-- LSP related utility functions to use within AstroNvim and user configurations.
--
-- This module can be loaded with `local lsp_utils = require("astronvim.utils.lsp")`
--
-- @module astronvim.utils.lsp
-- @see astronvim.utils
-- @copyright 2022
-- @license GNU General Public License v3.0
local M = {}
local tbl_contains = vim.tbl_contains
local tbl_isempty = vim.tbl_isempty
local user_opts = astronvim.user_opts
local utils = require "astronvim.utils"
local conditional_func = utils.conditional_func
local is_available = utils.is_available
local extend_tbl = utils.extend_tbl
local server_config = "lsp.config."
local setup_handlers = user_opts("lsp.setup_handlers", {
function(server, opts) require("lspconfig")[server].setup(opts) end,
})
M.diagnostics = { [0] = {}, {}, {}, {} }
M.setup_diagnostics = function(signs)
local default_diagnostics = astronvim.user_opts("diagnostics", {
virtual_text = true,
signs = { active = signs },
update_in_insert = true,
underline = true,
severity_sort = true,
float = {
focused = false,
style = "minimal",
border = "rounded",
source = "always",
header = "",
prefix = "",
},
})
M.diagnostics = {
-- diagnostics off
[0] = extend_tbl(
default_diagnostics,
{ underline = false, virtual_text = false, signs = false, update_in_insert = false }
),
-- status only
extend_tbl(default_diagnostics, { virtual_text = false, signs = false }),
-- virtual text off, signs on
extend_tbl(default_diagnostics, { virtual_text = false }),
-- all diagnostics on
default_diagnostics,
}
vim.diagnostic.config(M.diagnostics[vim.g.diagnostics_mode])
end
M.formatting = user_opts("lsp.formatting", { format_on_save = { enabled = true }, disabled = {} })
if type(M.formatting.format_on_save) == "boolean" then
M.formatting.format_on_save = { enabled = M.formatting.format_on_save }
end
M.format_opts = vim.deepcopy(M.formatting)
M.format_opts.disabled = nil
M.format_opts.format_on_save = nil
M.format_opts.filter = function(client)
local filter = M.formatting.filter
local disabled = M.formatting.disabled or {}
-- check if client is fully disabled or filtered by function
return not (vim.tbl_contains(disabled, client.name) or (type(filter) == "function" and not filter(client)))
end
--- Helper function to set up a given server with the Neovim LSP client
---@param server string The name of the server to be setup
M.setup = function(server)
-- if server doesn't exist, set it up from user server definition
local config_avail, config = pcall(require, "lspconfig.server_configurations." .. server)
if not config_avail or not config.default_config then
local server_definition = user_opts(server_config .. server)
if server_definition.cmd then require("lspconfig.configs")[server] = { default_config = server_definition } end
end
local opts = M.config(server)
local setup_handler = setup_handlers[server] or setup_handlers[1]
if not vim.tbl_contains(astronvim.lsp.skip_setup, server) and setup_handler then setup_handler(server, opts) end
end
--- Helper function to check if any active LSP clients given a filter provide a specific capability
---@param capability string The server capability to check for (example: "documentFormattingProvider")
---@param filter vim.lsp.get_active_clients.filter|nil (table|nil) A table with
--- key-value pairs used to filter the returned clients.
--- The available keys are:
--- - id (number): Only return clients with the given id
--- - bufnr (number): Only return clients attached to this buffer
--- - name (string): Only return clients with the given name
---@return boolean # Whether or not any of the clients provide the capability
function M.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
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 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
--- The `on_attach` function used by AstroNvim
---@param client table The LSP client details when attaching
---@param bufnr number The buffer that the LSP client is attaching to
M.on_attach = function(client, bufnr)
local lsp_mappings = {
n = {
["<leader>ld"] = {
function() vim.diagnostic.open_float() end,
desc = "Hover diagnostics",
},
["[d"] = {
function() vim.diagnostic.goto_prev() end,
desc = "Previous diagnostic",
},
["]d"] = {
function() vim.diagnostic.goto_next() end,
desc = "Next diagnostic",
},
["gl"] = {
function() vim.diagnostic.open_float() end,
desc = "Hover diagnostics",
},
},
v = {},
}
if is_available "telescope.nvim" then
lsp_mappings.n["<leader>lD"] =
{ function() require("telescope.builtin").diagnostics() end, desc = "Search diagnostics" }
end
if is_available "mason-lspconfig.nvim" then
lsp_mappings.n["<leader>li"] = { "<cmd>LspInfo<cr>", desc = "LSP information" }
end
if is_available "null-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 = "LSP code action",
}
lsp_mappings.v["<leader>la"] = lsp_mappings.n["<leader>la"]
end
if client.supports_method "textDocument/codeLens" then
add_buffer_autocmd("lsp_codelens_refresh", bufnr, {
events = { "InsertLeave", "BufEnter" },
desc = "Refresh codelens",
callback = function()
if not M.has_capability("textDocument/codeLens", { bufnr = bufnr }) then
del_buffer_autocmd("lsp_codelens_refresh", bufnr)
return
end
if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
end,
})
if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
lsp_mappings.n["<leader>ll"] = {
function() vim.lsp.codelens.refresh() end,
desc = "LSP CodeLens refresh",
}
lsp_mappings.n["<leader>lL"] = {
function() vim.lsp.codelens.run() end,
desc = "LSP CodeLens run",
}
end
if client.supports_method "textDocument/declaration" then
lsp_mappings.n["gD"] = {
function() vim.lsp.buf.declaration() end,
desc = "Declaration of current symbol",
}
end
if client.supports_method "textDocument/definition" then
lsp_mappings.n["gd"] = {
function() vim.lsp.buf.definition() end,
desc = "Show the definition of current symbol",
}
end
if client.supports_method "textDocument/formatting" and not tbl_contains(M.formatting.disabled, client.name) then
lsp_mappings.n["<leader>lf"] = {
function() vim.lsp.buf.format(M.format_opts) end,
desc = "Format buffer",
}
lsp_mappings.v["<leader>lf"] = lsp_mappings.n["<leader>lf"]
vim.api.nvim_buf_create_user_command(
bufnr,
"Format",
function() vim.lsp.buf.format(M.format_opts) end,
{ desc = "Format file with LSP" }
)
local autoformat = M.formatting.format_on_save
local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
if
autoformat.enabled
and (tbl_isempty(autoformat.allow_filetypes or {}) or tbl_contains(autoformat.allow_filetypes, filetype))
and (tbl_isempty(autoformat.ignore_filetypes or {}) or not tbl_contains(autoformat.ignore_filetypes, filetype))
then
add_buffer_autocmd("lsp_auto_format", bufnr, {
events = "BufWritePre",
desc = "autoformat on save",
callback = function()
if not M.has_capability("textDocument/formatting", { bufnr = bufnr }) then
del_buffer_autocmd("lsp_auto_format", bufnr)
return
end
local autoformat_enabled = vim.b.autoformat_enabled
if autoformat_enabled == nil then autoformat_enabled = vim.g.autoformat_enabled end
if autoformat_enabled and ((not autoformat.filter) or autoformat.filter(bufnr)) then
vim.lsp.buf.format(extend_tbl(M.format_opts, { bufnr = bufnr }))
end
end,
})
lsp_mappings.n["<leader>uf"] = {
function() require("astronvim.utils.ui").toggle_buffer_autoformat() end,
desc = "Toggle autoformatting (buffer)",
}
lsp_mappings.n["<leader>uF"] = {
function() require("astronvim.utils.ui").toggle_autoformat() end,
desc = "Toggle autoformatting (global)",
}
end
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 M.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" },
desc = "clear references when cursor moves",
callback = function() vim.lsp.buf.clear_references() end,
},
})
end
if client.supports_method "textDocument/hover" then
lsp_mappings.n["K"] = {
function() vim.lsp.buf.hover() end,
desc = "Hover symbol details",
}
end
if client.supports_method "textDocument/implementation" then
lsp_mappings.n["gI"] = {
function() vim.lsp.buf.implementation() end,
desc = "Implementation of current symbol",
}
end
if client.supports_method "textDocument/inlayHint" then
if vim.b.inlay_hints_enabled == nil then vim.b.inlay_hints_enabled = vim.g.inlay_hints_enabled end
-- TODO: remove check after dropping support for Neovim v0.9
if vim.lsp.buf.inlay_hint then
if vim.b.inlay_hints_enabled then vim.lsp.buf.inlay_hint(bufnr, true) end
lsp_mappings.n["<leader>uH"] = {
function() require("astronvim.utils.ui").toggle_buffer_inlay_hints(bufnr) end,
desc = "Toggle LSP inlay hints (buffer)",
}
end
end
if client.supports_method "textDocument/references" then
lsp_mappings.n["gr"] = {
function() vim.lsp.buf.references() end,
desc = "References of current symbol",
}
lsp_mappings.n["<leader>lR"] = {
function() vim.lsp.buf.references() end,
desc = "Search references",
}
end
if client.supports_method "textDocument/rename" then
lsp_mappings.n["<leader>lr"] = {
function() vim.lsp.buf.rename() end,
desc = "Rename current symbol",
}
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 client.supports_method "textDocument/typeDefinition" then
lsp_mappings.n["gT"] = {
function() vim.lsp.buf.type_definition() end,
desc = "Definition of current type",
}
end
if client.supports_method "workspace/symbol" then
lsp_mappings.n["<leader>lG"] = { function() vim.lsp.buf.workspace_symbol() end, desc = "Search workspace symbols" }
end
if
(
client.supports_method "textDocument/semanticTokens/full"
or client.supports_method "textDocument/semanticTokens/full/delta"
) and vim.lsp.semantic_tokens
then
if vim.b.semantic_tokens_enabled == nil then vim.b.semantic_tokens_enabled = vim.g.semantic_tokens_enabled end
vim.lsp.semantic_tokens[vim.b.semantic_tokens_enabled and "start" or "stop"](bufnr, client.id)
lsp_mappings.n["<leader>uY"] = {
function() require("astronvim.utils.ui").toggle_buffer_semantic_tokens(bufnr) end,
desc = "Toggle LSP semantic highlight (buffer)",
}
end
if is_available "telescope.nvim" then -- setup telescope mappings if available
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.gT then
lsp_mappings.n.gT[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: " }, function(query)
if query then require("telescope.builtin").lsp_workspace_symbols { query = query } end
end)
end
end
end
if not vim.tbl_isempty(lsp_mappings.v) then
lsp_mappings.v["<leader>l"] = { desc = (vim.g.icons_enabled and "" or "") .. "LSP" }
end
utils.set_mappings(user_opts("lsp.mappings", lsp_mappings), { buffer = bufnr })
for id, _ in pairs(astronvim.lsp.progress) do -- clear lingering progress messages
if not next(vim.lsp.get_active_clients { id = tonumber(id:match "^%d+") }) then astronvim.lsp.progress[id] = nil end
end
local on_attach_override = user_opts("lsp.on_attach", nil, false)
conditional_func(on_attach_override, true, client, bufnr)
end
--- The default AstroNvim LSP capabilities
M.capabilities = vim.lsp.protocol.make_client_capabilities()
M.capabilities.textDocument.completion.completionItem.documentationFormat = { "markdown", "plaintext" }
M.capabilities.textDocument.completion.completionItem.snippetSupport = true
M.capabilities.textDocument.completion.completionItem.preselectSupport = true
M.capabilities.textDocument.completion.completionItem.insertReplaceSupport = true
M.capabilities.textDocument.completion.completionItem.labelDetailsSupport = true
M.capabilities.textDocument.completion.completionItem.deprecatedSupport = true
M.capabilities.textDocument.completion.completionItem.commitCharactersSupport = true
M.capabilities.textDocument.completion.completionItem.tagSupport = { valueSet = { 1 } }
M.capabilities.textDocument.completion.completionItem.resolveSupport =
{ properties = { "documentation", "detail", "additionalTextEdits" } }
M.capabilities.textDocument.foldingRange = { dynamicRegistration = false, lineFoldingOnly = true }
M.capabilities = user_opts("lsp.capabilities", M.capabilities)
M.flags = user_opts "lsp.flags"
--- Get the server configuration for a given language server to be provided to the server's `setup()` call
---@param server_name string The name of the server
---@return table # The table of LSP options used when setting up the given language server
function M.config(server_name)
local server = require("lspconfig")[server_name]
local lsp_opts = extend_tbl(
extend_tbl(server.document_config.default_config, server),
{ capabilities = M.capabilities, flags = M.flags }
)
if server_name == "jsonls" then -- by default add json schemas
local schemastore_avail, schemastore = pcall(require, "schemastore")
if schemastore_avail then
lsp_opts.settings = { json = { schemas = schemastore.json.schemas(), validate = { enable = true } } }
end
end
if server_name == "yamlls" then -- by default add yaml schemas
local schemastore_avail, schemastore = pcall(require, "schemastore")
if schemastore_avail then lsp_opts.settings = { yaml = { schemas = schemastore.yaml.schemas() } } end
end
if server_name == "lua_ls" then -- by default initialize neodev and disable third party checking
pcall(require, "neodev")
lsp_opts.before_init = function(param, config)
if vim.b.neodev_enabled then
for _, astronvim_config in ipairs(astronvim.supported_configs) do
if param.rootPath:match(astronvim_config) then
table.insert(config.settings.Lua.workspace.library, astronvim.install.home .. "/lua")
break
end
end
end
end
lsp_opts.settings = { Lua = { workspace = { checkThirdParty = false } } }
end
local opts = user_opts(server_config .. server_name, lsp_opts)
local old_on_attach = server.on_attach
local user_on_attach = opts.on_attach
opts.on_attach = function(client, bufnr)
conditional_func(old_on_attach, true, client, bufnr)
M.on_attach(client, bufnr)
conditional_func(user_on_attach, true, client, bufnr)
end
return opts
end
return M

119
lua/astronvim/utils/mason.lua Normal file
View File

@@ -0,0 +1,119 @@
--- ### Mason Utils
--
-- Mason related utility functions to use within AstroNvim and user configurations.
--
-- This module can be loaded with `local mason_utils = require("astronvim.utils.mason")`
--
-- @module astronvim.utils.mason
-- @see astronvim.utils
-- @copyright 2022
-- @license GNU General Public License v3.0
local M = {}
local utils = require "astronvim.utils"
local notify = utils.notify
local astroevent = utils.event
--- Update specified mason packages, or just update the registries if no packages are listed
---@param pkg_names? string|string[] The package names as defined in Mason (Not mason-lspconfig or mason-null-ls) if the value is nil then it will just update the registries
---@param auto_install? boolean whether or not to install a package that is not currently installed (default: True)
function M.update(pkg_names, auto_install)
pkg_names = pkg_names or {}
if type(pkg_names) == "string" then pkg_names = { pkg_names } end
if auto_install == nil then auto_install = true end
local registry_avail, registry = pcall(require, "mason-registry")
if not registry_avail then
vim.api.nvim_err_writeln "Unable to access mason registry"
return
end
registry.update(vim.schedule_wrap(function(success, updated_registries)
if success then
local count = #updated_registries
if vim.tbl_count(pkg_names) == 0 then
notify(("Successfully updated %d %s."):format(count, count == 1 and "registry" or "registries"))
end
for _, pkg_name in ipairs(pkg_names) do
local pkg_avail, pkg = pcall(registry.get_package, pkg_name)
if not pkg_avail then
notify(("Mason: %s is not available"):format(pkg_name), vim.log.levels.ERROR)
else
if not pkg:is_installed() then
if auto_install then
notify(("Mason: Installing %s"):format(pkg.name))
pkg:install()
else
notify(("Mason: %s not installed"):format(pkg.name), vim.log.levels.WARN)
end
else
pkg:check_new_version(function(update_available, version)
if update_available then
notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
pkg:install():on("closed", function() notify(("Mason: Updated %s"):format(pkg.name)) end)
else
notify(("Mason: No updates available for %s"):format(pkg.name))
end
end)
end
end
end
else
notify(("Failed to update registries: %s"):format(updated_registries), vim.log.levels.ERROR)
end
end))
end
--- Update all packages in Mason
function M.update_all()
local registry_avail, registry = pcall(require, "mason-registry")
if not registry_avail then
vim.api.nvim_err_writeln "Unable to access mason registry"
return
end
notify "Mason: Checking for package updates..."
registry.update(vim.schedule_wrap(function(success, updated_registries)
if success then
local installed_pkgs = registry.get_installed_packages()
local running = #installed_pkgs
local no_pkgs = running == 0
if no_pkgs then
notify "Mason: No updates available"
astroevent "MasonUpdateCompleted"
else
local updated = false
for _, pkg in ipairs(installed_pkgs) do
pkg:check_new_version(function(update_available, version)
if update_available then
updated = true
notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
pkg:install():on("closed", function()
running = running - 1
if running == 0 then
notify "Mason: Update Complete"
astroevent "MasonUpdateCompleted"
end
end)
else
running = running - 1
if running == 0 then
if updated then
notify "Mason: Update Complete"
else
notify "Mason: No updates available"
end
astroevent "MasonUpdateCompleted"
end
end
end)
end
end
else
notify(("Failed to update registries: %s"):format(updated_registries), vim.log.levels.ERROR)
end
end))
end
return M

10
lua/astronvim/utils/status.lua Normal file
View File

@@ -0,0 +1,10 @@
return {
component = require "astronvim.utils.status.component",
condition = require "astronvim.utils.status.condition",
env = require "astronvim.utils.status.env",
heirline = require "astronvim.utils.status.heirline",
hl = require "astronvim.utils.status.hl",
init = require "astronvim.utils.status.init",
provider = require "astronvim.utils.status.provider",
utils = require "astronvim.utils.status.utils",
}

435
lua/astronvim/utils/status/component.lua Normal file
View File

@@ -0,0 +1,435 @@
--- ### AstroNvim Status Components
--
-- Statusline related component functions to use with Heirline
--
-- This module can be loaded with `local component = require "astronvim.utils.status.component"`
--
-- @module astronvim.utils.status.component
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local condition = require "astronvim.utils.status.condition"
local env = require "astronvim.utils.status.env"
local hl = require "astronvim.utils.status.hl"
local init = require "astronvim.utils.status.init"
local provider = require "astronvim.utils.status.provider"
local status_utils = require "astronvim.utils.status.utils"
local utils = require "astronvim.utils"
local buffer_utils = require "astronvim.utils.buffer"
local extend_tbl = utils.extend_tbl
local get_icon = utils.get_icon
local is_available = utils.is_available
--- A Heirline component for filling in the empty space of the bar
---@param opts? table options for configuring the other fields of the heirline component
---@return table # The heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.fill()
function M.fill(opts) return extend_tbl({ provider = provider.fill() }, opts) end
--- A function to build a set of children components for an entire file information section
---@param opts? table options for configuring file_icon, filename, filetype, file_modified, file_read_only, and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.file_info()
function M.file_info(opts)
opts = extend_tbl({
file_icon = { hl = hl.file_icon "statusline", padding = { left = 1, right = 1 } },
filename = {},
file_modified = { padding = { left = 1 } },
file_read_only = { padding = { left = 1 } },
surround = { separator = "left", color = "file_info_bg", condition = condition.has_filetype },
hl = hl.get_attributes "file_info",
}, opts)
return M.builder(status_utils.setup_providers(opts, {
"file_icon",
"unique_path",
"filename",
"filetype",
"file_modified",
"file_read_only",
"close_button",
}))
end
--- A function with different file_info defaults specifically for use in the tabline
---@param opts? table options for configuring file_icon, filename, filetype, file_modified, file_read_only, and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.tabline_file_info()
function M.tabline_file_info(opts)
return M.file_info(extend_tbl({
file_icon = {
condition = function(self) return not self._show_picker end,
hl = hl.file_icon "tabline",
},
unique_path = {
hl = function(self) return hl.get_attributes(self.tab_type .. "_path") end,
},
close_button = {
hl = function(self) return hl.get_attributes(self.tab_type .. "_close") end,
padding = { left = 1, right = 1 },
on_click = {
callback = function(_, minwid) buffer_utils.close(minwid) end,
minwid = function(self) return self.bufnr end,
name = "heirline_tabline_close_buffer_callback",
},
},
padding = { left = 1, right = 1 },
hl = function(self)
local tab_type = self.tab_type
if self._show_picker and self.tab_type ~= "buffer_active" then tab_type = "buffer_visible" end
return hl.get_attributes(tab_type)
end,
surround = false,
}, opts))
end
--- A function to build a set of children components for an entire navigation section
---@param opts? table options for configuring ruler, percentage, scrollbar, and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.nav()
function M.nav(opts)
opts = extend_tbl({
ruler = {},
percentage = { padding = { left = 1 } },
scrollbar = { padding = { left = 1 }, hl = { fg = "scrollbar" } },
surround = { separator = "right", color = "nav_bg" },
hl = hl.get_attributes "nav",
update = { "CursorMoved", "CursorMovedI", "BufEnter" },
}, opts)
return M.builder(status_utils.setup_providers(opts, { "ruler", "percentage", "scrollbar" }))
end
--- A function to build a set of children components for information shown in the cmdline
---@param opts? table options for configuring macro recording, search count, and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.cmd_info()
function M.cmd_info(opts)
opts = extend_tbl({
macro_recording = {
icon = { kind = "MacroRecording", padding = { right = 1 } },
condition = condition.is_macro_recording,
update = {
"RecordingEnter",
"RecordingLeave",
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
},
},
search_count = {
icon = { kind = "Search", padding = { right = 1 } },
padding = { left = 1 },
condition = condition.is_hlsearch,
},
showcmd = {
padding = { left = 1 },
condition = condition.is_statusline_showcmd,
},
surround = {
separator = "center",
color = "cmd_info_bg",
condition = function()
return condition.is_hlsearch() or condition.is_macro_recording() or condition.is_statusline_showcmd()
end,
},
condition = function() return vim.opt.cmdheight:get() == 0 end,
hl = hl.get_attributes "cmd_info",
}, opts)
return M.builder(status_utils.setup_providers(opts, { "macro_recording", "search_count", "showcmd" }))
end
--- A function to build a set of children components for a mode section
---@param opts? table options for configuring mode_text, paste, spell, and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.mode { mode_text = true }
function M.mode(opts)
opts = extend_tbl({
mode_text = false,
paste = false,
spell = false,
surround = { separator = "left", color = hl.mode_bg },
hl = hl.get_attributes "mode",
update = {
"ModeChanged",
pattern = "*:*",
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
},
}, opts)
if not opts["mode_text"] then opts.str = { str = " " } end
return M.builder(status_utils.setup_providers(opts, { "mode_text", "str", "paste", "spell" }))
end
--- A function to build a set of children components for an LSP breadcrumbs section
---@param opts? table options for configuring breadcrumbs and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.breadcumbs()
function M.breadcrumbs(opts)
opts = extend_tbl({ padding = { left = 1 }, condition = condition.aerial_available, update = "CursorMoved" }, opts)
opts.init = init.breadcrumbs(opts)
return opts
end
--- A function to build a set of children components for the current file path
---@param opts? table options for configuring path and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.separated_path()
function M.separated_path(opts)
opts = extend_tbl({ padding = { left = 1 }, update = { "BufEnter", "DirChanged" } }, opts)
opts.init = init.separated_path(opts)
return opts
end
--- A function to build a set of children components for a git branch section
---@param opts? table options for configuring git branch and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.git_branch()
function M.git_branch(opts)
opts = extend_tbl({
git_branch = { icon = { kind = "GitBranch", padding = { right = 1 } } },
surround = { separator = "left", color = "git_branch_bg", condition = condition.is_git_repo },
hl = hl.get_attributes "git_branch",
on_click = {
name = "heirline_branch",
callback = function()
if is_available "telescope.nvim" then
vim.defer_fn(function() require("telescope.builtin").git_branches() end, 100)
end
end,
},
update = { "User", pattern = "GitSignsUpdate" },
init = init.update_events { "BufEnter" },
}, opts)
return M.builder(status_utils.setup_providers(opts, { "git_branch" }))
end
--- A function to build a set of children components for a git difference section
---@param opts? table options for configuring git changes and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.git_diff()
function M.git_diff(opts)
opts = extend_tbl({
added = { icon = { kind = "GitAdd", padding = { left = 1, right = 1 } } },
changed = { icon = { kind = "GitChange", padding = { left = 1, right = 1 } } },
removed = { icon = { kind = "GitDelete", padding = { left = 1, right = 1 } } },
hl = hl.get_attributes "git_diff",
on_click = {
name = "heirline_git",
callback = function()
if is_available "telescope.nvim" then
vim.defer_fn(function() require("telescope.builtin").git_status() end, 100)
end
end,
},
surround = { separator = "left", color = "git_diff_bg", condition = condition.git_changed },
update = { "User", pattern = "GitSignsUpdate" },
init = init.update_events { "BufEnter" },
}, opts)
return M.builder(status_utils.setup_providers(opts, { "added", "changed", "removed" }, function(p_opts, p)
local out = status_utils.build_provider(p_opts, p)
if out then
out.provider = "git_diff"
out.opts.type = p
if out.hl == nil then out.hl = { fg = "git_" .. p } end
end
return out
end))
end
--- A function to build a set of children components for a diagnostics section
---@param opts? table options for configuring diagnostic providers and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.diagnostics()
function M.diagnostics(opts)
opts = extend_tbl({
ERROR = { icon = { kind = "DiagnosticError", padding = { left = 1, right = 1 } } },
WARN = { icon = { kind = "DiagnosticWarn", padding = { left = 1, right = 1 } } },
INFO = { icon = { kind = "DiagnosticInfo", padding = { left = 1, right = 1 } } },
HINT = { icon = { kind = "DiagnosticHint", padding = { left = 1, right = 1 } } },
surround = { separator = "left", color = "diagnostics_bg", condition = condition.has_diagnostics },
hl = hl.get_attributes "diagnostics",
on_click = {
name = "heirline_diagnostic",
callback = function()
if is_available "telescope.nvim" then
vim.defer_fn(function() require("telescope.builtin").diagnostics() end, 100)
end
end,
},
update = { "DiagnosticChanged", "BufEnter" },
}, opts)
return M.builder(status_utils.setup_providers(opts, { "ERROR", "WARN", "INFO", "HINT" }, function(p_opts, p)
local out = status_utils.build_provider(p_opts, p)
if out then
out.provider = "diagnostics"
out.opts.severity = p
if out.hl == nil then out.hl = { fg = "diag_" .. p } end
end
return out
end))
end
--- A function to build a set of children components for a Treesitter section
---@param opts? table options for configuring diagnostic providers and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.treesitter()
function M.treesitter(opts)
opts = extend_tbl({
str = { str = "TS", icon = { kind = "ActiveTS", padding = { right = 1 } } },
surround = {
separator = "right",
color = "treesitter_bg",
condition = condition.treesitter_available,
},
hl = hl.get_attributes "treesitter",
update = { "OptionSet", pattern = "syntax" },
init = init.update_events { "BufEnter" },
}, opts)
return M.builder(status_utils.setup_providers(opts, { "str" }))
end
--- A function to build a set of children components for an LSP section
---@param opts? table options for configuring lsp progress and client_name providers and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.lsp()
function M.lsp(opts)
opts = extend_tbl({
lsp_progress = {
str = "",
padding = { right = 1 },
update = {
"User",
pattern = "AstroLspProgress",
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
},
},
lsp_client_names = {
str = "LSP",
update = {
"LspAttach",
"LspDetach",
"BufEnter",
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
},
icon = { kind = "ActiveLSP", padding = { right = 2 } },
},
hl = hl.get_attributes "lsp",
surround = { separator = "right", color = "lsp_bg", condition = condition.lsp_attached },
on_click = {
name = "heirline_lsp",
callback = function()
vim.defer_fn(function() vim.cmd.LspInfo() end, 100)
end,
},
}, opts)
return M.builder(status_utils.setup_providers(
opts,
{ "lsp_progress", "lsp_client_names" },
function(p_opts, p, i)
return p_opts
and {
flexible = i,
status_utils.build_provider(p_opts, provider[p](p_opts)),
status_utils.build_provider(p_opts, provider.str(p_opts)),
}
or false
end
))
end
--- A function to build a set of components for a foldcolumn section in a statuscolumn
---@param opts? table options for configuring foldcolumn and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.foldcolumn()
function M.foldcolumn(opts)
opts = extend_tbl({
foldcolumn = { padding = { right = 1 } },
condition = condition.foldcolumn_enabled,
on_click = {
name = "fold_click",
callback = function(...)
local char = status_utils.statuscolumn_clickargs(...).char
local fillchars = vim.opt_local.fillchars:get()
if char == (fillchars.foldopen or get_icon "FoldOpened") then
vim.cmd "norm! zc"
elseif char == (fillchars.foldcolse or get_icon "FoldClosed") then
vim.cmd "norm! zo"
end
end,
},
}, opts)
return M.builder(status_utils.setup_providers(opts, { "foldcolumn" }))
end
--- A function to build a set of components for a numbercolumn section in statuscolumn
---@param opts? table options for configuring numbercolumn and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.numbercolumn()
function M.numbercolumn(opts)
opts = extend_tbl({
numbercolumn = { padding = { right = 1 } },
condition = condition.numbercolumn_enabled,
on_click = {
name = "line_click",
callback = function(...)
local args = status_utils.statuscolumn_clickargs(...)
if args.mods:find "c" then
local dap_avail, dap = pcall(require, "dap")
if dap_avail then vim.schedule(dap.toggle_breakpoint) end
end
end,
},
}, opts)
return M.builder(status_utils.setup_providers(opts, { "numbercolumn" }))
end
--- A function to build a set of components for a signcolumn section in statuscolumn
---@param opts? table options for configuring signcolumn and the overall padding
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").component.signcolumn()
function M.signcolumn(opts)
opts = extend_tbl({
signcolumn = {},
condition = condition.signcolumn_enabled,
on_click = {
name = "sign_click",
callback = function(...)
local args = status_utils.statuscolumn_clickargs(...)
if args.sign and args.sign.name and env.sign_handlers[args.sign.name] then
env.sign_handlers[args.sign.name](args)
end
end,
},
}, opts)
return M.builder(status_utils.setup_providers(opts, { "signcolumn" }))
end
--- A general function to build a section of astronvim status providers with highlights, conditions, and section surrounding
---@param opts? table a list of components to build into a section
---@return table # The Heirline component table
-- @usage local heirline_component = require("astronvim.utils.status").components.builder({ { provider = "file_icon", opts = { padding = { right = 1 } } }, { provider = "filename" } })
function M.builder(opts)
opts = extend_tbl({ padding = { left = 0, right = 0 } }, opts)
local children = {}
if opts.padding.left > 0 then -- add left padding
table.insert(children, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
end
for key, entry in pairs(opts) do
if
type(key) == "number"
and type(entry) == "table"
and provider[entry.provider]
and (entry.opts == nil or type(entry.opts) == "table")
then
entry.provider = provider[entry.provider](entry.opts)
end
children[key] = entry
end
if opts.padding.right > 0 then -- add right padding
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
end
return opts.surround
and status_utils.surround(opts.surround.separator, opts.surround.color, children, opts.surround.condition)
or children
end
return M

137
lua/astronvim/utils/status/condition.lua Normal file
View File

@@ -0,0 +1,137 @@
--- ### AstroNvim Status Conditions
--
-- Statusline related condition functions to use with Heirline
--
-- This module can be loaded with `local condition = require "astronvim.utils.status.condition"`
--
-- @module astronvim.utils.status.condition
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local env = require "astronvim.utils.status.env"
--- A condition function if the window is currently active
---@return boolean # whether or not the window is currently actie
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_active }
function M.is_active() return vim.api.nvim_get_current_win() == tonumber(vim.g.actual_curwin) end
--- A condition function if the buffer filetype,buftype,bufname match a pattern
---@param patterns table the table of patterns to match
---@param bufnr number of the buffer to match (Default: 0 [current])
---@return boolean # whether or not LSP is attached
-- @usage local heirline_component = { provider = "Example Provider", condition = function() return require("astronvim.utils.status").condition.buffer_matches { buftype = { "terminal" } } end }
function M.buffer_matches(patterns, bufnr)
for kind, pattern_list in pairs(patterns) do
if env.buf_matchers[kind](pattern_list, bufnr) then return true end
end
return false
end
--- A condition function if a macro is being recorded
---@return boolean # whether or not a macro is currently being recorded
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_macro_recording }
function M.is_macro_recording() return vim.fn.reg_recording() ~= "" end
--- A condition function if search is visible
---@return boolean # whether or not searching is currently visible
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_hlsearch }
function M.is_hlsearch() return vim.v.hlsearch ~= 0 end
--- A condition function if showcmdloc is set to statusline
---@return boolean # whether or not statusline showcmd is enabled
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_statusline_showcmd }
function M.is_statusline_showcmd() return vim.fn.has "nvim-0.9" == 1 and vim.opt.showcmdloc:get() == "statusline" end
--- A condition function if the current file is in a git repo
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not the current file is in a git repo
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_git_repo }
function M.is_git_repo(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
return vim.b[bufnr or 0].gitsigns_head or vim.b[bufnr or 0].gitsigns_status_dict
end
--- A condition function if there are any git changes
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not there are any git changes
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.git_changed }
function M.git_changed(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
local git_status = vim.b[bufnr or 0].gitsigns_status_dict
return git_status and (git_status.added or 0) + (git_status.removed or 0) + (git_status.changed or 0) > 0
end
--- A condition function if the current buffer is modified
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not the current buffer is modified
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.file_modified }
function M.file_modified(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
return vim.bo[bufnr or 0].modified
end
--- A condition function if the current buffer is read only
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not the current buffer is read only or not modifiable
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.file_read_only }
function M.file_read_only(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
local buffer = vim.bo[bufnr or 0]
return not buffer.modifiable or buffer.readonly
end
--- A condition function if the current file has any diagnostics
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not the current file has any diagnostics
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.has_diagnostics }
function M.has_diagnostics(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
return vim.g.diagnostics_mode > 0 and #vim.diagnostic.get(bufnr or 0) > 0
end
--- A condition function if there is a defined filetype
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not there is a filetype
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.has_filetype }
function M.has_filetype(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
return vim.fn.empty(vim.fn.expand "%:t") ~= 1 and vim.bo[bufnr or 0].filetype and vim.bo[bufnr or 0].filetype ~= ""
end
--- A condition function if Aerial is available
---@return boolean # whether or not aerial plugin is installed
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.aerial_available }
-- function M.aerial_available() return is_available "aerial.nvim" end
function M.aerial_available() return package.loaded["aerial"] end
--- A condition function if LSP is attached
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not LSP is attached
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.lsp_attached }
function M.lsp_attached(bufnr)
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
return next(vim.lsp.get_active_clients { bufnr = bufnr or 0 }) ~= nil
end
--- A condition function if treesitter is in use
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
---@return boolean # whether or not treesitter is active
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.treesitter_available }
function M.treesitter_available(bufnr)
if not package.loaded["nvim-treesitter"] then return false end
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
local parsers = require "nvim-treesitter.parsers"
return parsers.has_parser(parsers.get_buf_lang(bufnr or vim.api.nvim_get_current_buf()))
end
--- A condition function if the foldcolumn is enabled
---@return boolean # true if vim.opt.foldcolumn > 0, false if vim.opt.foldcolumn == 0
function M.foldcolumn_enabled() return vim.opt.foldcolumn:get() ~= "0" end
--- A condition function if the number column is enabled
---@return boolean # true if vim.opt.number or vim.opt.relativenumber, false if neither
function M.numbercolumn_enabled() return vim.opt.number:get() or vim.opt.relativenumber:get() end
return M

143
lua/astronvim/utils/status/env.lua Normal file
View File

@@ -0,0 +1,143 @@
--- ### AstroNvim Status Environment
--
-- Statusline related environment variables shared between components/providers/etc.
--
-- This module can be loaded with `local env = require "astronvim.utils.status.env"`
--
-- @module astronvim.utils.status.env
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
M.fallback_colors = {
none = "NONE",
fg = "#abb2bf",
bg = "#1e222a",
dark_bg = "#2c323c",
blue = "#61afef",
green = "#98c379",
grey = "#5c6370",
bright_grey = "#777d86",
dark_grey = "#5c5c5c",
orange = "#ff9640",
purple = "#c678dd",
bright_purple = "#a9a1e1",
red = "#e06c75",
bright_red = "#ec5f67",
white = "#c9c9c9",
yellow = "#e5c07b",
bright_yellow = "#ebae34",
}
M.modes = {
["n"] = { "NORMAL", "normal" },
["no"] = { "OP", "normal" },
["nov"] = { "OP", "normal" },
["noV"] = { "OP", "normal" },
["no"] = { "OP", "normal" },
["niI"] = { "NORMAL", "normal" },
["niR"] = { "NORMAL", "normal" },
["niV"] = { "NORMAL", "normal" },
["i"] = { "INSERT", "insert" },
["ic"] = { "INSERT", "insert" },
["ix"] = { "INSERT", "insert" },
["t"] = { "TERM", "terminal" },
["nt"] = { "TERM", "terminal" },
["v"] = { "VISUAL", "visual" },
["vs"] = { "VISUAL", "visual" },
["V"] = { "LINES", "visual" },
["Vs"] = { "LINES", "visual" },
[""] = { "BLOCK", "visual" },
["s"] = { "BLOCK", "visual" },
["R"] = { "REPLACE", "replace" },
["Rc"] = { "REPLACE", "replace" },
["Rx"] = { "REPLACE", "replace" },
["Rv"] = { "V-REPLACE", "replace" },
["s"] = { "SELECT", "visual" },
["S"] = { "SELECT", "visual" },
[""] = { "BLOCK", "visual" },
["c"] = { "COMMAND", "command" },
["cv"] = { "COMMAND", "command" },
["ce"] = { "COMMAND", "command" },
["r"] = { "PROMPT", "inactive" },
["rm"] = { "MORE", "inactive" },
["r?"] = { "CONFIRM", "inactive" },
["!"] = { "SHELL", "inactive" },
["null"] = { "null", "inactive" },
}
M.separators = astronvim.user_opts("heirline.separators", {
none = { "", "" },
left = { "", " " },
right = { " ", "" },
center = { " ", " " },
tab = { "", " " },
breadcrumbs = "",
path = "",
})
M.attributes = astronvim.user_opts("heirline.attributes", {
buffer_active = { bold = true, italic = true },
buffer_picker = { bold = true },
macro_recording = { bold = true },
git_branch = { bold = true },
git_diff = { bold = true },
})
M.icon_highlights = astronvim.user_opts("heirline.icon_highlights", {
file_icon = {
tabline = function(self) return self.is_active or self.is_visible end,
statusline = true,
},
})
local function pattern_match(str, pattern_list)
for _, pattern in ipairs(pattern_list) do
if str:find(pattern) then return true end
end
return false
end
M.buf_matchers = {
filetype = function(pattern_list, bufnr) return pattern_match(vim.bo[bufnr or 0].filetype, pattern_list) end,
buftype = function(pattern_list, bufnr) return pattern_match(vim.bo[bufnr or 0].buftype, pattern_list) end,
bufname = function(pattern_list, bufnr)
return pattern_match(vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr or 0), ":t"), pattern_list)
end,
}
M.sign_handlers = {}
-- gitsigns handlers
local gitsigns = function(_)
local gitsigns_avail, gitsigns = pcall(require, "gitsigns")
if gitsigns_avail then vim.schedule(gitsigns.preview_hunk) end
end
for _, sign in ipairs { "Topdelete", "Untracked", "Add", "Changedelete", "Delete" } do
local name = "GitSigns" .. sign
if not M.sign_handlers[name] then M.sign_handlers[name] = gitsigns end
end
-- diagnostic handlers
local diagnostics = function(args)
if args.mods:find "c" then
vim.schedule(vim.lsp.buf.code_action)
else
vim.schedule(vim.diagnostic.open_float)
end
end
for _, sign in ipairs { "Error", "Hint", "Info", "Warn" } do
local name = "DiagnosticSign" .. sign
if not M.sign_handlers[name] then M.sign_handlers[name] = diagnostics end
end
-- DAP handlers
local dap_breakpoint = function(_)
local dap_avail, dap = pcall(require, "dap")
if dap_avail then vim.schedule(dap.toggle_breakpoint) end
end
for _, sign in ipairs { "", "Rejected", "Condition" } do
local name = "DapBreakpoint" .. sign
if not M.sign_handlers[name] then M.sign_handlers[name] = dap_breakpoint end
end
M.sign_handlers = astronvim.user_opts("heirline.sign_handlers", M.sign_handlers)
return M

115
lua/astronvim/utils/status/heirline.lua Normal file
View File

@@ -0,0 +1,115 @@
--- ### AstroNvim Status Heirline Extensions
--
-- Statusline related heirline specific extensions
--
-- This module can be loaded with `local astro_heirline = require "astronvim.utils.status.heirline"`
--
-- @module astronvim.utils.status.heirline
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local hl = require "astronvim.utils.status.hl"
local provider = require "astronvim.utils.status.provider"
local status_utils = require "astronvim.utils.status.utils"
local utils = require "astronvim.utils"
local buffer_utils = require "astronvim.utils.buffer"
local get_icon = utils.get_icon
--- A helper function to get the type a tab or buffer is
---@param self table the self table from a heirline component function
---@param prefix? string the prefix of the type, either "tab" or "buffer" (Default: "buffer")
---@return string # the string of prefix with the type (i.e. "_active" or "_visible")
function M.tab_type(self, prefix)
local tab_type = ""
if self.is_active then
tab_type = "_active"
elseif self.is_visible then
tab_type = "_visible"
end
return (prefix or "buffer") .. tab_type
end
--- Make a list of buffers, rendering each buffer with the provided component
---@param component table
---@return table
M.make_buflist = function(component)
local overflow_hl = hl.get_attributes("buffer_overflow", true)
return require("heirline.utils").make_buflist(
status_utils.surround(
"tab",
function(self)
return {
main = M.tab_type(self) .. "_bg",
left = "tabline_bg",
right = "tabline_bg",
}
end,
{ -- bufferlist
init = function(self) self.tab_type = M.tab_type(self) end,
on_click = { -- add clickable component to each buffer
callback = function(_, minwid) vim.api.nvim_win_set_buf(0, minwid) end,
minwid = function(self) return self.bufnr end,
name = "heirline_tabline_buffer_callback",
},
{ -- add buffer picker functionality to each buffer
condition = function(self) return self._show_picker end,
update = false,
init = function(self)
if not (self.label and self._picker_labels[self.label]) then
local bufname = provider.filename()(self)
local label = bufname:sub(1, 1)
local i = 2
while label ~= " " and self._picker_labels[label] do
if i > #bufname then break end
label = bufname:sub(i, i)
i = i + 1
end
self._picker_labels[label] = self.bufnr
self.label = label
end
end,
provider = function(self) return provider.str { str = self.label, padding = { left = 1, right = 1 } } end,
hl = hl.get_attributes "buffer_picker",
},
component, -- create buffer component
},
function(self) return buffer_utils.is_valid(self.bufnr) end -- disable surrounding
),
{ provider = get_icon "ArrowLeft" .. " ", hl = overflow_hl },
{ provider = get_icon "ArrowRight" .. " ", hl = overflow_hl },
function() return vim.t.bufs end, -- use astronvim bufs variable
false -- disable internal caching
)
end
--- Alias to require("heirline.utils").make_tablist
function M.make_tablist(...) return require("heirline.utils").make_tablist(...) end
--- Run the buffer picker and execute the callback function on the selected buffer
---@param callback function with a single parameter of the buffer number
function M.buffer_picker(callback)
local tabline = require("heirline").tabline
-- if buflist then
local prev_showtabline = vim.opt.showtabline:get()
if prev_showtabline ~= 2 then vim.opt.showtabline = 2 end
vim.cmd.redrawtabline()
---@diagnostic disable-next-line: undefined-field
local buflist = tabline and tabline._buflist and tabline._buflist[1]
if buflist then
buflist._picker_labels = {}
buflist._show_picker = true
vim.cmd.redrawtabline()
local char = vim.fn.getcharstr()
local bufnr = buflist._picker_labels[char]
if bufnr then callback(bufnr) end
buflist._show_picker = false
end
if prev_showtabline ~= 2 then vim.opt.showtabline = prev_showtabline end
vim.cmd.redrawtabline()
-- end
end
return M

76
lua/astronvim/utils/status/hl.lua Normal file
View File

@@ -0,0 +1,76 @@
--- ### AstroNvim Status Highlighting
--
-- Statusline related highlighting utilities
--
-- This module can be loaded with `local hl = require "astronvim.utils.status.hl"`
--
-- @module astronvim.utils.status.hl
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local env = require "astronvim.utils.status.env"
--- Get the highlight background color of the lualine theme for the current colorscheme
---@param mode string the neovim mode to get the color of
---@param fallback string the color to fallback on if a lualine theme is not present
---@return string # The background color of the lualine theme or the fallback parameter if one doesn't exist
function M.lualine_mode(mode, fallback)
if not vim.g.colors_name then return fallback end
local lualine_avail, lualine = pcall(require, "lualine.themes." .. vim.g.colors_name)
local lualine_opts = lualine_avail and lualine[mode]
return lualine_opts and type(lualine_opts.a) == "table" and lualine_opts.a.bg or fallback
end
--- Get the highlight for the current mode
---@return table # the highlight group for the current mode
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.mode },
function M.mode() return { bg = M.mode_bg() } end
--- Get the foreground color group for the current mode, good for usage with Heirline surround utility
---@return string # the highlight group for the current mode foreground
-- @usage local heirline_component = require("heirline.utils").surround({ "|", "|" }, require("astronvim.utils.status").hl.mode_bg, heirline_component),
function M.mode_bg() return env.modes[vim.fn.mode()][2] end
--- Get the foreground color group for the current filetype
---@return table # the highlight group for the current filetype foreground
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.fileicon(), hl = require("astronvim.utils.status").hl.filetype_color },
function M.filetype_color(self)
local devicons_avail, devicons = pcall(require, "nvim-web-devicons")
if not devicons_avail then return {} end
local _, color = devicons.get_icon_color(
vim.fn.fnamemodify(vim.api.nvim_buf_get_name(self and self.bufnr or 0), ":t"),
nil,
{ default = true }
)
return { fg = color }
end
--- Merge the color and attributes from user settings for a given name
---@param name string, the name of the element to get the attributes and colors for
---@param include_bg? boolean whether or not to include background color (Default: false)
---@return table # a table of highlight information
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.get_attributes("treesitter") },
function M.get_attributes(name, include_bg)
local hl = env.attributes[name] or {}
hl.fg = name .. "_fg"
if include_bg then hl.bg = name .. "_bg" end
return hl
end
--- Enable filetype color highlight if enabled in icon_highlights.file_icon options
---@param name string the icon_highlights.file_icon table element
---@return function # for setting hl property in a component
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.file_icon("winbar") },
function M.file_icon(name)
local hl_enabled = env.icon_highlights.file_icon[name]
return function(self)
if hl_enabled == true or (type(hl_enabled) == "function" and hl_enabled(self)) then
return M.filetype_color(self)
end
end
end
return M

155
lua/astronvim/utils/status/init.lua Normal file
View File

@@ -0,0 +1,155 @@
--- ### AstroNvim Status Initializers
--
-- Statusline related init functions for building dynamic statusline components
--
-- This module can be loaded with `local init = require "astronvim.utils.status.init"`
--
-- @module astronvim.utils.status.init
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local env = require "astronvim.utils.status.env"
local provider = require "astronvim.utils.status.provider"
local status_utils = require "astronvim.utils.status.utils"
local utils = require "astronvim.utils"
local extend_tbl = utils.extend_tbl
--- An `init` function to build a set of children components for LSP breadcrumbs
---@param opts? table # options for configuring the breadcrumbs (default: `{ max_depth = 5, separator = "  ", icon = { enabled = true, hl = false }, padding = { left = 0, right = 0 } }`)
---@return function # The Heirline init function
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.breadcrumbs { padding = { left = 1 } } }
function M.breadcrumbs(opts)
opts = extend_tbl({
max_depth = 5,
separator = env.separators.breadcrumbs or "",
icon = { enabled = true, hl = env.icon_highlights.breadcrumbs },
padding = { left = 0, right = 0 },
}, opts)
return function(self)
local data = require("aerial").get_location(true) or {}
local children = {}
-- add prefix if needed, use the separator if true, or use the provided character
if opts.prefix and not vim.tbl_isempty(data) then
table.insert(children, { provider = opts.prefix == true and opts.separator or opts.prefix })
end
local start_idx = 0
if opts.max_depth and opts.max_depth > 0 then
start_idx = #data - opts.max_depth
if start_idx > 0 then
table.insert(children, { provider = require("astronvim.utils").get_icon "Ellipsis" .. opts.separator })
end
end
-- create a child for each level
for i, d in ipairs(data) do
if i > start_idx then
local child = {
{ provider = string.gsub(d.name, "%%", "%%%%"):gsub("%s*->%s*", "") }, -- add symbol name
on_click = { -- add on click function
minwid = status_utils.encode_pos(d.lnum, d.col, self.winnr),
callback = function(_, minwid)
local lnum, col, winnr = status_utils.decode_pos(minwid)
vim.api.nvim_win_set_cursor(vim.fn.win_getid(winnr), { lnum, col })
end,
name = "heirline_breadcrumbs",
},
}
if opts.icon.enabled then -- add icon and highlight if enabled
local hl = opts.icon.hl
if type(hl) == "function" then hl = hl(self) end
local hlgroup = string.format("Aerial%sIcon", d.kind)
table.insert(child, 1, {
provider = string.format("%s ", d.icon),
hl = (hl and vim.fn.hlexists(hlgroup) == 1) and hlgroup or nil,
})
end
if #data > 1 and i < #data then table.insert(child, { provider = opts.separator }) end -- add a separator only if needed
table.insert(children, child)
end
end
if opts.padding.left > 0 then -- add left padding
table.insert(children, 1, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
end
if opts.padding.right > 0 then -- add right padding
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
end
-- instantiate the new child
self[1] = self:new(children, 1)
end
end
--- An `init` function to build a set of children components for a separated path to file
---@param opts? table options for configuring the breadcrumbs (default: `{ max_depth = 3, path_func = provider.unique_path(), separator = "  ", suffix = true, padding = { left = 0, right = 0 } }`)
---@return function # The Heirline init function
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.separated_path { padding = { left = 1 } } }
function M.separated_path(opts)
opts = extend_tbl({
max_depth = 3,
path_func = provider.unique_path(),
separator = env.separators.path or "",
suffix = true,
padding = { left = 0, right = 0 },
}, opts)
if opts.suffix == true then opts.suffix = opts.separator end
return function(self)
local path = opts.path_func(self)
if path == "." then path = "" end -- if there is no path, just replace with empty string
local data = vim.fn.split(path, "/")
local children = {}
-- add prefix if needed, use the separator if true, or use the provided character
if opts.prefix and not vim.tbl_isempty(data) then
table.insert(children, { provider = opts.prefix == true and opts.separator or opts.prefix })
end
local start_idx = 0
if opts.max_depth and opts.max_depth > 0 then
start_idx = #data - opts.max_depth
if start_idx > 0 then
table.insert(children, { provider = require("astronvim.utils").get_icon "Ellipsis" .. opts.separator })
end
end
-- create a child for each level
for i, d in ipairs(data) do
if i > start_idx then
local child = { { provider = d } }
local separator = i < #data and opts.separtor or opts.suffix
if separator then table.insert(child, { provider = separator }) end
table.insert(children, child)
end
end
if opts.padding.left > 0 then -- add left padding
table.insert(children, 1, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
end
if opts.padding.right > 0 then -- add right padding
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
end
-- instantiate the new child
self[1] = self:new(children, 1)
end
end
--- An `init` function to build multiple update events which is not supported yet by Heirline's update field
---@param opts any[] an array like table of autocmd events as either just a string or a table with custom patterns and callbacks.
---@return function # The Heirline init function
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.update_events { "BufEnter", { "User", pattern = "LspProgressUpdate" } } }
function M.update_events(opts)
return function(self)
if not rawget(self, "once") then
local clear_cache = function() self._win_cache = nil end
for _, event in ipairs(opts) do
local event_opts = { callback = clear_cache }
if type(event) == "table" then
event_opts.pattern = event.pattern
event_opts.callback = event.callback or clear_cache
event.pattern = nil
event.callback = nil
end
vim.api.nvim_create_autocmd(event, event_opts)
end
self.once = true
end
end
end
return M

520
lua/astronvim/utils/status/provider.lua Normal file
View File

@@ -0,0 +1,520 @@
--- ### AstroNvim Status Providers
--
-- Statusline related provider functions for building statusline components
--
-- This module can be loaded with `local provider = require "astronvim.utils.status.provider"`
--
-- @module astronvim.utils.status.provider
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local condition = require "astronvim.utils.status.condition"
local env = require "astronvim.utils.status.env"
local status_utils = require "astronvim.utils.status.utils"
local utils = require "astronvim.utils"
local extend_tbl = utils.extend_tbl
local get_icon = utils.get_icon
--- A provider function for the fill string
---@return string # the statusline string for filling the empty space
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.fill }
function M.fill() return "%=" end
--- A provider function for the signcolumn string
---@param opts? table options passed to the stylize function
---@return string # the statuscolumn string for adding the signcolumn
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.signcolumn }
-- @see astronvim.utils.status.utils.stylize
function M.signcolumn(opts)
opts = extend_tbl({ escape = false }, opts)
return status_utils.stylize("%s", opts)
end
--- A provider function for the numbercolumn string
---@param opts? table options passed to the stylize function
---@return function # the statuscolumn string for adding the numbercolumn
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.numbercolumn }
-- @see astronvim.utils.status.utils.stylize
function M.numbercolumn(opts)
opts = extend_tbl({ thousands = false, culright = true, escape = false }, opts)
return function()
local lnum, rnum, virtnum = vim.v.lnum, vim.v.relnum, vim.v.virtnum
local num, relnum = vim.opt.number:get(), vim.opt.relativenumber:get()
local str
if not num and not relnum then
str = ""
elseif virtnum ~= 0 then
str = "%="
else
local cur = relnum and (rnum > 0 and rnum or (num and lnum or 0)) or lnum
if opts.thousands and cur > 999 then
cur = string.reverse(cur):gsub("%d%d%d", "%1" .. opts.thousands):reverse():gsub("^%" .. opts.thousands, "")
end
str = (rnum == 0 and not opts.culright and relnum) and cur .. "%=" or "%=" .. cur
end
return status_utils.stylize(str, opts)
end
end
--- A provider function for building a foldcolumn
---@param opts? table options passed to the stylize function
---@return function # a custom foldcolumn function for the statuscolumn that doesn't show the nest levels
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.foldcolumn }
-- @see astronvim.utils.status.utils.stylize
function M.foldcolumn(opts)
opts = extend_tbl({ escape = false }, opts)
local ffi = require "astronvim.utils.ffi" -- get AstroNvim C extensions
local fillchars = vim.opt.fillchars:get()
local foldopen = fillchars.foldopen or get_icon "FoldOpened"
local foldclosed = fillchars.foldclose or get_icon "FoldClosed"
local foldsep = fillchars.foldsep or get_icon "FoldSeparator"
return function() -- move to M.fold_indicator
local wp = ffi.C.find_window_by_handle(0, ffi.new "Error") -- get window handler
local width = ffi.C.compute_foldcolumn(wp, 0) -- get foldcolumn width
-- get fold info of current line
local foldinfo = width > 0 and ffi.C.fold_info(wp, vim.v.lnum) or { start = 0, level = 0, llevel = 0, lines = 0 }
local str = ""
if width ~= 0 then
str = vim.v.relnum > 0 and "%#FoldColumn#" or "%#CursorLineFold#"
if foldinfo.level == 0 then
str = str .. (" "):rep(width)
else
local closed = foldinfo.lines > 0
local first_level = foldinfo.level - width - (closed and 1 or 0) + 1
if first_level < 1 then first_level = 1 end
for col = 1, width do
str = str
.. (
(vim.v.virtnum ~= 0 and foldsep)
or ((closed and (col == foldinfo.level or col == width)) and foldclosed)
or ((foldinfo.start == vim.v.lnum and first_level + col > foldinfo.llevel) and foldopen)
or foldsep
)
if col == foldinfo.level then
str = str .. (" "):rep(width - col)
break
end
end
end
end
return status_utils.stylize(str .. "%*", opts)
end
end
--- A provider function for the current tab numbre
---@return function # the statusline function to return a string for a tab number
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.tabnr() }
function M.tabnr()
return function(self) return (self and self.tabnr) and "%" .. self.tabnr .. "T " .. self.tabnr .. " %T" or "" end
end
--- A provider function for showing if spellcheck is on
---@param opts? table options passed to the stylize function
---@return function # the function for outputting if spell is enabled
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.spell() }
-- @see astronvim.utils.status.utils.stylize
function M.spell(opts)
opts = extend_tbl({ str = "", icon = { kind = "Spellcheck" }, show_empty = true }, opts)
return function() return status_utils.stylize(vim.wo.spell and opts.str or nil, opts) end
end
--- A provider function for showing if paste is enabled
---@param opts? table options passed to the stylize function
---@return function # the function for outputting if paste is enabled
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.paste() }
-- @see astronvim.utils.status.utils.stylize
function M.paste(opts)
opts = extend_tbl({ str = "", icon = { kind = "Paste" }, show_empty = true }, opts)
local paste = vim.opt.paste
if type(paste) ~= "boolean" then paste = paste:get() end
return function() return status_utils.stylize(paste and opts.str or nil, opts) end
end
--- A provider function for displaying if a macro is currently being recorded
---@param opts? table a prefix before the recording register and options passed to the stylize function
---@return function # a function that returns a string of the current recording status
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.macro_recording() }
-- @see astronvim.utils.status.utils.stylize
function M.macro_recording(opts)
opts = extend_tbl({ prefix = "@" }, opts)
return function()
local register = vim.fn.reg_recording()
if register ~= "" then register = opts.prefix .. register end
return status_utils.stylize(register, opts)
end
end
--- A provider function for displaying the current command
---@param opts? table of options passed to the stylize function
---@return string # the statusline string for showing the current command
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.showcmd() }
-- @see astronvim.utils.status.utils.stylize
function M.showcmd(opts)
opts = extend_tbl({ minwid = 0, maxwid = 5, escape = false }, opts)
return status_utils.stylize(("%%%d.%d(%%S%%)"):format(opts.minwid, opts.maxwid), opts)
end
--- A provider function for displaying the current search count
---@param opts? table options for `vim.fn.searchcount` and options passed to the stylize function
---@return function # a function that returns a string of the current search location
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.search_count() }
-- @see astronvim.utils.status.utils.stylize
function M.search_count(opts)
local search_func = vim.tbl_isempty(opts or {}) and function() return vim.fn.searchcount() end
or function() return vim.fn.searchcount(opts) end
return function()
local search_ok, search = pcall(search_func)
if search_ok and type(search) == "table" and search.total then
return status_utils.stylize(
string.format(
"%s%d/%s%d",
search.current > search.maxcount and ">" or "",
math.min(search.current, search.maxcount),
search.incomplete == 2 and ">" or "",
math.min(search.total, search.maxcount)
),
opts
)
end
end
end
--- A provider function for showing the text of the current vim mode
---@param opts? table options for padding the text and options passed to the stylize function
---@return function # the function for displaying the text of the current vim mode
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.mode_text() }
-- @see astronvim.utils.status.utils.stylize
function M.mode_text(opts)
local max_length = math.max(unpack(vim.tbl_map(function(str) return #str[1] end, vim.tbl_values(env.modes))))
return function()
local text = env.modes[vim.fn.mode()][1]
if opts and opts.pad_text then
local padding = max_length - #text
if opts.pad_text == "right" then
text = string.rep(" ", padding) .. text
elseif opts.pad_text == "left" then
text = text .. string.rep(" ", padding)
elseif opts.pad_text == "center" then
text = string.rep(" ", math.floor(padding / 2)) .. text .. string.rep(" ", math.ceil(padding / 2))
end
end
return status_utils.stylize(text, opts)
end
end
--- A provider function for showing the percentage of the current location in a document
---@param opts? table options for Top/Bot text, fixed width, and options passed to the stylize function
---@return function # the statusline string for displaying the percentage of current document location
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.percentage() }
-- @see astronvim.utils.status.utils.stylize
function M.percentage(opts)
opts = extend_tbl({ escape = false, fixed_width = true, edge_text = true }, opts)
return function()
local text = "%" .. (opts.fixed_width and (opts.edge_text and "2" or "3") or "") .. "p%%"
if opts.edge_text then
local current_line = vim.fn.line "."
if current_line == 1 then
text = "Top"
elseif current_line == vim.fn.line "$" then
text = "Bot"
end
end
return status_utils.stylize(text, opts)
end
end
--- A provider function for showing the current line and character in a document
---@param opts? table options for padding the line and character locations and options passed to the stylize function
---@return function # the statusline string for showing location in document line_num:char_num
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.ruler({ pad_ruler = { line = 3, char = 2 } }) }
-- @see astronvim.utils.status.utils.stylize
function M.ruler(opts)
opts = extend_tbl({ pad_ruler = { line = 3, char = 2 } }, opts)
local padding_str = string.format("%%%dd:%%-%dd", opts.pad_ruler.line, opts.pad_ruler.char)
return function()
local line = vim.fn.line "."
local char = vim.fn.virtcol "."
return status_utils.stylize(string.format(padding_str, line, char), opts)
end
end
--- A provider function for showing the current location as a scrollbar
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the scrollbar
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.scrollbar() }
-- @see astronvim.utils.status.utils.stylize
function M.scrollbar(opts)
local sbar = { "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" }
return function()
local curr_line = vim.api.nvim_win_get_cursor(0)[1]
local lines = vim.api.nvim_buf_line_count(0)
local i = math.floor((curr_line - 1) / lines * #sbar) + 1
if sbar[i] then return status_utils.stylize(string.rep(sbar[i], 2), opts) end
end
end
--- A provider to simply show a close button icon
---@param opts? table options passed to the stylize function and the kind of icon to use
---@return string # the stylized icon
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.close_button() }
-- @see astronvim.utils.status.utils.stylize
function M.close_button(opts)
opts = extend_tbl({ kind = "BufferClose" }, opts)
return status_utils.stylize(get_icon(opts.kind), opts)
end
--- A provider function for showing the current filetype
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the filetype
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.filetype() }
-- @see astronvim.utils.status.utils.stylize
function M.filetype(opts)
return function(self)
local buffer = vim.bo[self and self.bufnr or 0]
return status_utils.stylize(string.lower(buffer.filetype), opts)
end
end
--- A provider function for showing the current filename
---@param opts? table options for argument to fnamemodify to format filename and options passed to the stylize function
---@return function # the function for outputting the filename
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.filename() }
-- @see astronvim.utils.status.utils.stylize
function M.filename(opts)
opts = extend_tbl({
fallback = "Empty",
fname = function(nr) return vim.api.nvim_buf_get_name(nr) end,
modify = ":t",
}, opts)
return function(self)
local filename = vim.fn.fnamemodify(opts.fname(self and self.bufnr or 0), opts.modify)
return status_utils.stylize((filename == "" and opts.fallback or filename), opts)
end
end
--- A provider function for showing the current file encoding
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the file encoding
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_encoding() }
-- @see astronvim.utils.status.utils.stylize
function M.file_encoding(opts)
return function(self)
local buf_enc = vim.bo[self and self.bufnr or 0].fenc
return status_utils.stylize(string.upper(buf_enc ~= "" and buf_enc or vim.o.enc), opts)
end
end
--- A provider function for showing the current file format
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the file format
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_format() }
-- @see astronvim.utils.status.utils.stylize
function M.file_format(opts)
return function(self)
local buf_format = vim.bo[self and self.bufnr or 0].fileformat
return status_utils.stylize(string.upper(buf_format ~= "" and buf_format or vim.o.fileformat), opts)
end
end
--- Get a unique filepath between all buffers
---@param opts? table options for function to get the buffer name, a buffer number, max length, and options passed to the stylize function
---@return function # path to file that uniquely identifies each buffer
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.unique_path() }
-- @see astronvim.utils.status.utils.stylize
function M.unique_path(opts)
opts = extend_tbl({
buf_name = function(bufnr) return vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr), ":t") end,
bufnr = 0,
max_length = 16,
}, opts)
local function path_parts(bufnr)
local parts = {}
for match in (vim.api.nvim_buf_get_name(bufnr) .. "/"):gmatch("(.-)" .. "/") do
table.insert(parts, match)
end
return parts
end
return function(self)
opts.bufnr = self and self.bufnr or opts.bufnr
local name = opts.buf_name(opts.bufnr)
local unique_path = ""
-- check for same buffer names under different dirs
local current
for _, value in ipairs(vim.t.bufs) do
if name == opts.buf_name(value) and value ~= opts.bufnr then
if not current then current = path_parts(opts.bufnr) end
local other = path_parts(value)
for i = #current - 1, 1, -1 do
if current[i] ~= other[i] then
unique_path = current[i] .. "/"
break
end
end
end
end
return status_utils.stylize(
(
opts.max_length > 0
and #unique_path > opts.max_length
and string.sub(unique_path, 1, opts.max_length - 2) .. get_icon "Ellipsis" .. "/"
) or unique_path,
opts
)
end
end
--- A provider function for showing if the current file is modifiable
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the indicator if the file is modified
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_modified() }
-- @see astronvim.utils.status.utils.stylize
function M.file_modified(opts)
opts = extend_tbl({ str = "", icon = { kind = "FileModified" }, show_empty = true }, opts)
return function(self)
return status_utils.stylize(condition.file_modified((self or {}).bufnr) and opts.str or nil, opts)
end
end
--- A provider function for showing if the current file is read-only
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the indicator if the file is read-only
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_read_only() }
-- @see astronvim.utils.status.utils.stylize
function M.file_read_only(opts)
opts = extend_tbl({ str = "", icon = { kind = "FileReadOnly" }, show_empty = true }, opts)
return function(self)
return status_utils.stylize(condition.file_read_only((self or {}).bufnr) and opts.str or nil, opts)
end
end
--- A provider function for showing the current filetype icon
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the filetype icon
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_icon() }
-- @see astronvim.utils.status.utils.stylize
function M.file_icon(opts)
return function(self)
local devicons_avail, devicons = pcall(require, "nvim-web-devicons")
if not devicons_avail then return "" end
local ft_icon, _ = devicons.get_icon(
vim.fn.fnamemodify(vim.api.nvim_buf_get_name(self and self.bufnr or 0), ":t"),
nil,
{ default = true }
)
return status_utils.stylize(ft_icon, opts)
end
end
--- A provider function for showing the current git branch
---@param opts table options passed to the stylize function
---@return function # the function for outputting the git branch
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.git_branch() }
-- @see astronvim.utils.status.utils.stylize
function M.git_branch(opts)
return function(self) return status_utils.stylize(vim.b[self and self.bufnr or 0].gitsigns_head or "", opts) end
end
--- A provider function for showing the current git diff count of a specific type
---@param opts? table options for type of git diff and options passed to the stylize function
---@return function|nil # the function for outputting the git diff
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.git_diff({ type = "added" }) }
-- @see astronvim.utils.status.utils.stylize
function M.git_diff(opts)
if not opts or not opts.type then return end
return function(self)
local status = vim.b[self and self.bufnr or 0].gitsigns_status_dict
return status_utils.stylize(
status and status[opts.type] and status[opts.type] > 0 and tostring(status[opts.type]) or "",
opts
)
end
end
--- A provider function for showing the current diagnostic count of a specific severity
---@param opts table options for severity of diagnostic and options passed to the stylize function
---@return function|nil # the function for outputting the diagnostic count
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.diagnostics({ severity = "ERROR" }) }
-- @see astronvim.utils.status.utils.stylize
function M.diagnostics(opts)
if not opts or not opts.severity then return end
return function(self)
local bufnr = self and self.bufnr or 0
local count = #vim.diagnostic.get(bufnr, opts.severity and { severity = vim.diagnostic.severity[opts.severity] })
return status_utils.stylize(count ~= 0 and tostring(count) or "", opts)
end
end
--- A provider function for showing the current progress of loading language servers
---@param opts? table options passed to the stylize function
---@return function # the function for outputting the LSP progress
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.lsp_progress() }
-- @see astronvim.utils.status.utils.stylize
function M.lsp_progress(opts)
local spinner = utils.get_spinner("LSPLoading", 1) or { "" }
return function()
local _, Lsp = next(astronvim.lsp.progress)
return status_utils.stylize(Lsp and (spinner[math.floor(vim.loop.hrtime() / 12e7) % #spinner + 1] .. table.concat({
Lsp.title or "",
Lsp.message or "",
Lsp.percentage and "(" .. Lsp.percentage .. "%)" or "",
}, " ")), opts)
end
end
--- A provider function for showing the connected LSP client names
---@param opts? table options for explanding null_ls clients, max width percentage, and options passed to the stylize function
---@return function # the function for outputting the LSP client names
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.lsp_client_names({ expand_null_ls = true, truncate = 0.25 }) }
-- @see astronvim.utils.status.utils.stylize
function M.lsp_client_names(opts)
opts = extend_tbl({ expand_null_ls = true, truncate = 0.25 }, opts)
return function(self)
local buf_client_names = {}
for _, client in pairs(vim.lsp.get_active_clients { bufnr = self and self.bufnr or 0 }) do
if client.name == "null-ls" and opts.expand_null_ls then
local null_ls_sources = {}
for _, type in ipairs { "FORMATTING", "DIAGNOSTICS" } do
for _, source in ipairs(status_utils.null_ls_sources(vim.bo.filetype, type)) do
null_ls_sources[source] = true
end
end
vim.list_extend(buf_client_names, vim.tbl_keys(null_ls_sources))
else
table.insert(buf_client_names, client.name)
end
end
local str = table.concat(buf_client_names, ", ")
if type(opts.truncate) == "number" then
local max_width = math.floor(status_utils.width() * opts.truncate)
if #str > max_width then str = string.sub(str, 0, max_width) .. "…" end
end
return status_utils.stylize(str, opts)
end
end
--- A provider function for showing if treesitter is connected
---@param opts? table options passed to the stylize function
---@return function # function for outputting TS if treesitter is connected
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.treesitter_status() }
-- @see astronvim.utils.status.utils.stylize
function M.treesitter_status(opts)
return function() return status_utils.stylize(require("nvim-treesitter.parser").has_parser() and "TS" or "", opts) end
end
--- A provider function for displaying a single string
---@param opts? table options passed to the stylize function
---@return string # the stylized statusline string
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.str({ str = "Hello" }) }
-- @see astronvim.utils.status.utils.stylize
function M.str(opts)
opts = extend_tbl({ str = " " }, opts)
return status_utils.stylize(opts.str, opts)
end
return M

202
lua/astronvim/utils/status/utils.lua Normal file
View File

@@ -0,0 +1,202 @@
--- ### AstroNvim Status Utilities
--
-- Statusline related uitility functions
--
-- This module can be loaded with `local status_utils = require "astronvim.utils.status.utils"`
--
-- @module astronvim.utils.status.utils
-- @copyright 2023
-- @license GNU General Public License v3.0
local M = {}
local env = require "astronvim.utils.status.env"
local utils = require "astronvim.utils"
local extend_tbl = utils.extend_tbl
local get_icon = utils.get_icon
--- Convert a component parameter table to a table that can be used with the component builder
---@param opts? table a table of provider options
---@param provider? function|string a provider in `M.providers`
---@return table|false # the provider table that can be used in `M.component.builder`
function M.build_provider(opts, provider, _)
return opts
and {
provider = provider,
opts = opts,
condition = opts.condition,
on_click = opts.on_click,
update = opts.update,
hl = opts.hl,
}
or false
end
--- Convert key/value table of options to an array of providers for the component builder
---@param opts table the table of options for the components
---@param providers string[] an ordered list like array of providers that are configured in the options table
---@param setup? function a function that takes provider options table, provider name, provider index and returns the setup provider table, optional, default is `M.build_provider`
---@return table # the fully setup options table with the appropriately ordered providers
function M.setup_providers(opts, providers, setup)
setup = setup or M.build_provider
for i, provider in ipairs(providers) do
opts[i] = setup(opts[provider], provider, i)
end
return opts
end
--- A utility function to get the width of the bar
---@param is_winbar? boolean true if you want the width of the winbar, false if you want the statusline width
---@return integer # the width of the specified bar
function M.width(is_winbar)
return vim.o.laststatus == 3 and not is_winbar and vim.o.columns or vim.api.nvim_win_get_width(0)
end
--- Add left and/or right padding to a string
---@param str string the string to add padding to
---@param padding table a table of the format `{ left = 0, right = 0}` that defines the number of spaces to include to the left and the right of the string
---@return string # the padded string
function M.pad_string(str, padding)
padding = padding or {}
return str and str ~= "" and string.rep(" ", padding.left or 0) .. str .. string.rep(" ", padding.right or 0) or ""
end
local function escape(str) return str:gsub("%%", "%%%%") end
--- A utility function to stylize a string with an icon from lspkind, separators, and left/right padding
---@param str? string the string to stylize
---@param opts? table options of `{ padding = { left = 0, right = 0 }, separator = { left = "|", right = "|" }, escape = true, show_empty = false, icon = { kind = "NONE", padding = { left = 0, right = 0 } } }`
---@return string # the stylized string
-- @usage local string = require("astronvim.utils.status").utils.stylize("Hello", { padding = { left = 1, right = 1 }, icon = { kind = "String" } })
function M.stylize(str, opts)
opts = extend_tbl({
padding = { left = 0, right = 0 },
separator = { left = "", right = "" },
show_empty = false,
escape = true,
icon = { kind = "NONE", padding = { left = 0, right = 0 } },
}, opts)
local icon = M.pad_string(get_icon(opts.icon.kind), opts.icon.padding)
return str
and (str ~= "" or opts.show_empty)
and opts.separator.left .. M.pad_string(icon .. (opts.escape and escape(str) or str), opts.padding) .. opts.separator.right
or ""
end
--- Surround component with separator and color adjustment
---@param separator string|string[] the separator index to use in `env.separators`
---@param color function|string|table the color to use as the separator foreground/component background
---@param component table the component to surround
---@param condition boolean|function the condition for displaying the surrounded component
---@return table # the new surrounded component
function M.surround(separator, color, component, condition)
local function surround_color(self)
local colors = type(color) == "function" and color(self) or color
return type(colors) == "string" and { main = colors } or colors
end
separator = type(separator) == "string" and env.separators[separator] or separator
local surrounded = { condition = condition }
if separator[1] ~= "" then
table.insert(surrounded, {
provider = separator[1],
hl = function(self)
local s_color = surround_color(self)
if s_color then return { fg = s_color.main, bg = s_color.left } end
end,
})
end
table.insert(surrounded, {
hl = function(self)
local s_color = surround_color(self)
if s_color then return { bg = s_color.main } end
end,
extend_tbl(component, {}),
})
if separator[2] ~= "" then
table.insert(surrounded, {
provider = separator[2],
hl = function(self)
local s_color = surround_color(self)
if s_color then return { fg = s_color.main, bg = s_color.right } end
end,
})
end
return surrounded
end
--- Encode a position to a single value that can be decoded later
---@param line integer line number of position
---@param col integer column number of position
---@param winnr integer a window number
---@return integer the encoded position
function M.encode_pos(line, col, winnr) return bit.bor(bit.lshift(line, 16), bit.lshift(col, 6), winnr) end
--- Decode a previously encoded position to it's sub parts
---@param c integer the encoded position
---@return integer line, integer column, integer window
function M.decode_pos(c) return bit.rshift(c, 16), bit.band(bit.rshift(c, 6), 1023), bit.band(c, 63) end
--- Get a list of registered null-ls providers for a given filetype
---@param filetype string the filetype to search null-ls for
---@return table # a table of null-ls sources
function M.null_ls_providers(filetype)
local registered = {}
-- try to load null-ls
local sources_avail, sources = pcall(require, "null-ls.sources")
if sources_avail then
-- get the available sources of a given filetype
for _, source in ipairs(sources.get_available(filetype)) do
-- get each source name
for method in pairs(source.methods) do
registered[method] = registered[method] or {}
table.insert(registered[method], source.name)
end
end
end
-- return the found null-ls sources
return registered
end
--- Get the null-ls sources for a given null-ls method
---@param filetype string the filetype to search null-ls for
---@param method string the null-ls method (check null-ls documentation for available methods)
---@return string[] # the available sources for the given filetype and method
function M.null_ls_sources(filetype, method)
local methods_avail, methods = pcall(require, "null-ls.methods")
return methods_avail and M.null_ls_providers(filetype)[methods.internal[method]] or {}
end
--- A helper function for decoding statuscolumn click events with mouse click pressed, modifier keys, as well as which signcolumn sign was clicked if any
---@param self any the self parameter from Heirline component on_click.callback function call
---@param minwid any the minwid parameter from Heirline component on_click.callback function call
---@param clicks any the clicks parameter from Heirline component on_click.callback function call
---@param button any the button parameter from Heirline component on_click.callback function call
---@param mods any the button parameter from Heirline component on_click.callback function call
---@return table # the argument table with the decoded mouse information and signcolumn signs information
-- @usage local heirline_component = { on_click = { callback = function(...) local args = require("astronvim.utils.status").utils.statuscolumn_clickargs(...) end } }
function M.statuscolumn_clickargs(self, minwid, clicks, button, mods)
local args = {
minwid = minwid,
clicks = clicks,
button = button,
mods = mods,
mousepos = vim.fn.getmousepos(),
}
if not self.signs then self.signs = {} end
args.char = vim.fn.screenstring(args.mousepos.screenrow, args.mousepos.screencol)
if args.char == " " then args.char = vim.fn.screenstring(args.mousepos.screenrow, args.mousepos.screencol - 1) end
args.sign = self.signs[args.char]
if not args.sign then -- update signs if not found on first click
for _, sign_def in ipairs(vim.fn.sign_getdefined()) do
if sign_def.text then self.signs[sign_def.text:gsub("%s", "")] = sign_def end
end
args.sign = self.signs[args.char]
end
vim.api.nvim_set_current_win(args.mousepos.winid)
vim.api.nvim_win_set_cursor(0, { args.mousepos.line, 0 })
return args
end
return M

230
lua/astronvim/utils/ui.lua Normal file
View File

@@ -0,0 +1,230 @@
--- ### AstroNvim UI Options
--
-- Utility functions for easy UI toggles.
--
-- This module can be loaded with `local ui = require("astronvim.utils.ui")`
--
-- @module astronvim.utils.ui
-- @see astronvim.utils
-- @copyright 2022
-- @license GNU General Public License v3.0
local M = {}
local notify = require("astronvim.utils").notify
local function bool2str(bool) return bool and "on" or "off" end
--- Toggle notifications for UI toggles
function M.toggle_ui_notifications() -- TODO: rename to toggle_notifications in AstroNvim v4
vim.g.ui_notifications_enabled = not vim.g.ui_notifications_enabled
notify(string.format("Notifications %s", bool2str(vim.g.ui_notifications_enabled)))
end
--- Toggle autopairs
function M.toggle_autopairs()
local ok, autopairs = pcall(require, "nvim-autopairs")
if ok then
if autopairs.state.disabled then
autopairs.enable()
else
autopairs.disable()
end
vim.g.autopairs_enabled = autopairs.state.disabled
notify(string.format("autopairs %s", bool2str(not autopairs.state.disabled)))
else
notify "autopairs not available"
end
end
--- Toggle diagnostics
function M.toggle_diagnostics()
vim.g.diagnostics_mode = (vim.g.diagnostics_mode - 1) % 4
vim.diagnostic.config(require("astronvim.utils.lsp").diagnostics[vim.g.diagnostics_mode])
if vim.g.diagnostics_mode == 0 then
notify "diagnostics off"
elseif vim.g.diagnostics_mode == 1 then
notify "only status diagnostics"
elseif vim.g.diagnostics_mode == 2 then
notify "virtual text off"
else
notify "all diagnostics on"
end
end
--- Toggle background="dark"|"light"
function M.toggle_background()
vim.go.background = vim.go.background == "light" and "dark" or "light"
notify(string.format("background=%s", vim.go.background))
end
--- Toggle cmp entrirely
function M.toggle_cmp()
vim.g.cmp_enabled = not vim.g.cmp_enabled
local ok, _ = pcall(require, "cmp")
notify(ok and string.format("completion %s", bool2str(vim.g.cmp_enabled)) or "completion not available")
end
--- Toggle auto format
function M.toggle_autoformat()
vim.g.autoformat_enabled = not vim.g.autoformat_enabled
notify(string.format("Global autoformatting %s", bool2str(vim.g.autoformat_enabled)))
end
--- Toggle buffer local auto format
function M.toggle_buffer_autoformat()
local old_val = vim.b.autoformat_enabled
if old_val == nil then old_val = vim.g.autoformat_enabled end
vim.b.autoformat_enabled = not old_val
notify(string.format("Buffer autoformatting %s", bool2str(vim.b.autoformat_enabled)))
end
--- Toggle buffer semantic token highlighting for all language servers that support it
---@param bufnr? number the buffer to toggle the clients on
function M.toggle_buffer_semantic_tokens(bufnr)
vim.b.semantic_tokens_enabled = not vim.b.semantic_tokens_enabled
for _, client in ipairs(vim.lsp.get_active_clients()) do
if client.server_capabilities.semanticTokensProvider then
vim.lsp.semantic_tokens[vim.b.semantic_tokens_enabled and "start" or "stop"](bufnr or 0, client.id)
notify(string.format("Buffer lsp semantic highlighting %s", bool2str(vim.b.semantic_tokens_enabled)))
end
end
end
--- Toggle buffer LSP inlay hints
---@param bufnr? number the buffer to toggle the clients on
function M.toggle_buffer_inlay_hints(bufnr)
vim.b.inlay_hints_enabled = not vim.b.inlay_hints_enabled
-- TODO: remove check after dropping support for Neovim v0.9
if vim.lsp.buf.inlay_hint then
vim.lsp.buf.inlay_hint(bufnr or 0, vim.b.inlay_hints_enabled)
notify(string.format("Inlay hints %s", bool2str(vim.b.inlay_hints_enabled)))
end
end
--- Toggle codelens
function M.toggle_codelens()
vim.g.codelens_enabled = not vim.g.codelens_enabled
if not vim.g.codelens_enabled then vim.lsp.codelens.clear() end
notify(string.format("CodeLens %s", bool2str(vim.g.codelens_enabled)))
end
--- Toggle showtabline=2|0
function M.toggle_tabline()
vim.opt.showtabline = vim.opt.showtabline:get() == 0 and 2 or 0
notify(string.format("tabline %s", bool2str(vim.opt.showtabline:get() == 2)))
end
--- Toggle conceal=2|0
function M.toggle_conceal()
vim.opt.conceallevel = vim.opt.conceallevel:get() == 0 and 2 or 0
notify(string.format("conceal %s", bool2str(vim.opt.conceallevel:get() == 2)))
end
--- Toggle laststatus=3|2|0
function M.toggle_statusline()
local laststatus = vim.opt.laststatus:get()
local status
if laststatus == 0 then
vim.opt.laststatus = 2
status = "local"
elseif laststatus == 2 then
vim.opt.laststatus = 3
status = "global"
elseif laststatus == 3 then
vim.opt.laststatus = 0
status = "off"
end
notify(string.format("statusline %s", status))
end
--- Toggle signcolumn="auto"|"no"
function M.toggle_signcolumn()
if vim.wo.signcolumn == "no" then
vim.wo.signcolumn = "yes"
elseif vim.wo.signcolumn == "yes" then
vim.wo.signcolumn = "auto"
else
vim.wo.signcolumn = "no"
end
notify(string.format("signcolumn=%s", vim.wo.signcolumn))
end
--- Set the indent and tab related numbers
function M.set_indent()
local input_avail, input = pcall(vim.fn.input, "Set indent value (>0 expandtab, <=0 noexpandtab): ")
if input_avail then
local indent = tonumber(input)
if not indent or indent == 0 then return end
vim.bo.expandtab = (indent > 0) -- local to buffer
indent = math.abs(indent)
vim.bo.tabstop = indent -- local to buffer
vim.bo.softtabstop = indent -- local to buffer
vim.bo.shiftwidth = indent -- local to buffer
notify(string.format("indent=%d %s", indent, vim.bo.expandtab and "expandtab" or "noexpandtab"))
end
end
--- Change the number display modes
function M.change_number()
local number = vim.wo.number -- local to window
local relativenumber = vim.wo.relativenumber -- local to window
if not number and not relativenumber then
vim.wo.number = true
elseif number and not relativenumber then
vim.wo.relativenumber = true
elseif number and relativenumber then
vim.wo.number = false
else -- not number and relativenumber
vim.wo.relativenumber = false
end
notify(string.format("number %s, relativenumber %s", bool2str(vim.wo.number), bool2str(vim.wo.relativenumber)))
end
--- Toggle spell
function M.toggle_spell()
vim.wo.spell = not vim.wo.spell -- local to window
notify(string.format("spell %s", bool2str(vim.wo.spell)))
end
--- Toggle paste
function M.toggle_paste()
vim.opt.paste = not vim.opt.paste:get() -- local to window
notify(string.format("paste %s", bool2str(vim.opt.paste:get())))
end
--- Toggle wrap
function M.toggle_wrap()
vim.wo.wrap = not vim.wo.wrap -- local to window
notify(string.format("wrap %s", bool2str(vim.wo.wrap)))
end
--- Toggle syntax highlighting and treesitter
function M.toggle_syntax()
local ts_avail, parsers = pcall(require, "nvim-treesitter.parsers")
if vim.g.syntax_on then -- global var for on//off
if ts_avail and parsers.has_parser() then vim.cmd.TSBufDisable "highlight" end
vim.cmd.syntax "off" -- set vim.g.syntax_on = false
else
if ts_avail and parsers.has_parser() then vim.cmd.TSBufEnable "highlight" end
vim.cmd.syntax "on" -- set vim.g.syntax_on = true
end
notify(string.format("syntax %s", bool2str(vim.g.syntax_on)))
end
--- Toggle URL/URI syntax highlighting rules
function M.toggle_url_match()
vim.g.highlighturl_enabled = not vim.g.highlighturl_enabled
require("astronvim.utils").set_url_match()
end
local last_active_foldcolumn
--- Toggle foldcolumn=0|1
function M.toggle_foldcolumn()
local curr_foldcolumn = vim.wo.foldcolumn
if curr_foldcolumn ~= "0" then last_active_foldcolumn = curr_foldcolumn end
vim.wo.foldcolumn = curr_foldcolumn == "0" and (last_active_foldcolumn or "1") or "0"
notify(string.format("foldcolumn=%s", vim.wo.foldcolumn))
end
return M

339
lua/astronvim/utils/updater.lua Normal file
View File

@@ -0,0 +1,339 @@
--- ### AstroNvim Updater
--
-- AstroNvim Updater utilities to use within AstroNvim and user configurations.
--
-- This module can also loaded with `local updater = require("astronvim.utils.updater")`
--
-- @module astronvim.utils.updater
-- @see astronvim.utils
-- @copyright 2022
-- @license GNU General Public License v3.0
local git = require "astronvim.utils.git"
local M = {}
local utils = require "astronvim.utils"
local notify = utils.notify
local function echo(messages)
-- if no parameter provided, echo a new line
messages = messages or { { "\n" } }
if type(messages) == "table" then vim.api.nvim_echo(messages, false, {}) end
end
local function confirm_prompt(messages, type)
return vim.fn.confirm(messages, "&Yes\n&No", (type == "Error" or type == "Warning") and 2 or 1, type or "Question")
== 1
end
--- Helper function to generate AstroNvim snapshots (For internal use only)
---@param write? boolean Whether or not to write to the snapshot file (default: false)
---@return table # The plugin specification table of the snapshot
function M.generate_snapshot(write)
local file
local prev_snapshot = require(astronvim.updater.snapshot.module)
for _, plugin in ipairs(prev_snapshot) do
prev_snapshot[plugin[1]] = plugin
end
local plugins = assert(require("lazy").plugins())
local function git_commit(dir)
local commit = assert(utils.cmd({ "git", "-C", dir, "rev-parse", "HEAD" }, false))
if commit then return vim.trim(commit) end
end
if write == true then
file = assert(io.open(astronvim.updater.snapshot.path, "w"))
file:write "return {\n"
end
local snapshot = vim.tbl_map(function(plugin)
if not plugin[1] and plugin.name == "lazy.nvim" then plugin[1] = "folke/lazy.nvim" end
plugin = { plugin[1], commit = git_commit(plugin.dir), version = plugin.version }
if prev_snapshot[plugin[1]] and prev_snapshot[plugin[1]].version then
plugin.version = prev_snapshot[plugin[1]].version
end
if file then
file:write((" { %q, "):format(plugin[1]))
if plugin.version then
file:write(("version = %q"):format(plugin.version))
else
file:write(("commit = %q"):format(plugin.commit))
end
file:write ", optional = true },\n"
end
return plugin
end, plugins)
if file then
file:write "}"
file:close()
end
return snapshot
end
--- Get the current AstroNvim version
---@param quiet? boolean Whether to quietly execute or send a notification
---@return string # The current AstroNvim version string
function M.version(quiet)
local version = astronvim.install.version or git.current_version(false) or "unknown"
if astronvim.updater.options.channel ~= "stable" then version = ("nightly (%s)"):format(version) end
if version and not quiet then notify("Version: " .. version) end
return version
end
--- Get the full AstroNvim changelog
---@param quiet? boolean Whether to quietly execute or display the changelog
---@return table # The current AstroNvim changelog table of commit messages
function M.changelog(quiet)
local summary = {}
vim.list_extend(summary, git.pretty_changelog(git.get_commit_range()))
if not quiet then echo(summary) end
return summary
end
--- Attempt an update of AstroNvim
---@param target string The target if checking out a specific tag or commit or nil if just pulling
local function attempt_update(target, opts)
-- if updating to a new stable version or a specific commit checkout the provided target
if opts.channel == "stable" or opts.commit then
return git.checkout(target, false)
-- if no target, pull the latest
else
return git.pull(false)
end
end
--- Cancelled update message
local cancelled_message = { { "Update cancelled", "WarningMsg" } }
--- Sync Packer and then update Mason
function M.update_packages()
require("lazy").sync { wait = true }
require("astronvim.utils.mason").update_all()
end
--- Create a table of options for the currently installed AstroNvim version
---@param write? boolean Whether or not to write to the rollback file (default: false)
---@return table # The table of updater options
function M.create_rollback(write)
local snapshot = { branch = git.current_branch(), commit = git.local_head() }
if snapshot.branch == "HEAD" then snapshot.branch = "main" end
snapshot.remote = git.branch_remote(snapshot.branch, false) or "origin"
snapshot.remotes = { [snapshot.remote] = git.remote_url(snapshot.remote) }
if write == true then
local file = assert(io.open(astronvim.updater.rollback_file, "w"))
file:write("return " .. vim.inspect(snapshot, { newline = " ", indent = "" }))
file:close()
end
return snapshot
end
--- AstroNvim's rollback to saved previous version function
function M.rollback()
local rollback_avail, rollback_opts = pcall(dofile, astronvim.updater.rollback_file)
if not rollback_avail then
notify("No rollback file available", vim.log.levels.ERROR)
return
end
M.update(rollback_opts)
end
--- Check if an update is available
---@param opts? table the settings to use for checking for an update
---@return table|boolean? # The information of an available update (`{ source = string, target = string }`), false if no update is available, or nil if there is an error
function M.update_available(opts)
if not opts then opts = astronvim.updater.options end
opts = require("astronvim.utils").extend_tbl({ remote = "origin" }, opts)
-- if the git command is not available, then throw an error
if not git.available() then
notify(
"git command is not available, please verify it is accessible in a command line. This may be an issue with your PATH",
vim.log.levels.ERROR
)
return
end
-- if installed with an external package manager, disable the internal updater
if not git.is_repo() then
notify("Updater not available for non-git installations", vim.log.levels.ERROR)
return
end
-- set up any remotes defined by the user if they do not exist
for remote, entry in pairs(opts.remotes and opts.remotes or {}) do
local url = git.parse_remote_url(entry)
local current_url = git.remote_url(remote, false)
local check_needed = false
if not current_url then
git.remote_add(remote, url)
check_needed = true
elseif
current_url ~= url
and confirm_prompt(
("Remote %s is currently: %s\n" .. "Would you like us to set it to %s ?"):format(remote, current_url, url)
)
then
git.remote_update(remote, url)
check_needed = true
end
if check_needed and git.remote_url(remote, false) ~= url then
vim.api.nvim_err_writeln("Error setting up remote " .. remote .. " to " .. url)
return
end
end
local is_stable = opts.channel == "stable"
if is_stable then
opts.branch = "main"
elseif not opts.branch then
opts.branch = "nightly"
end
-- setup branch if missing
if not git.ref_verify(opts.remote .. "/" .. opts.branch, false) then
git.remote_set_branches(opts.remote, opts.branch, false)
end
-- fetch the latest remote
if not git.fetch(opts.remote) then
vim.api.nvim_err_writeln("Error fetching remote: " .. opts.remote)
return
end
-- switch to the necessary branch only if not on the stable channel
if not is_stable then
local local_branch = (opts.remote == "origin" and "" or (opts.remote .. "_")) .. opts.branch
if git.current_branch() ~= local_branch then
echo {
{ "Switching to branch: " },
{ opts.remote .. "/" .. opts.branch .. "\n\n", "String" },
}
if not git.checkout(local_branch, false) then
git.checkout("-b " .. local_branch .. " " .. opts.remote .. "/" .. opts.branch, false)
end
end
-- check if the branch was switched to successfully
if git.current_branch() ~= local_branch then
vim.api.nvim_err_writeln("Error checking out branch: " .. opts.remote .. "/" .. opts.branch)
return
end
end
local update = { source = git.local_head() }
if is_stable then -- if stable get tag commit
local version_search = opts.version or "latest"
update.version = git.latest_version(git.get_versions(version_search))
if not update.version then -- continue only if stable version is found
vim.api.nvim_err_writeln("Error finding version: " .. version_search)
return
end
update.target = git.tag_commit(update.version)
elseif opts.commit then -- if commit specified use it
update.target = git.branch_contains(opts.remote, opts.branch, opts.commit) and opts.commit or nil
else -- get most recent commit
update.target = git.remote_head(opts.remote, opts.branch)
end
if not update.source or not update.target then -- continue if current and target commits were found
vim.api.nvim_err_writeln "Error checking for updates"
return
elseif update.source ~= update.target then
-- update available
return update
else
return false
end
end
--- AstroNvim's updater function
---@param opts? table the settings to use for the update
function M.update(opts)
if not opts then opts = astronvim.updater.options end
opts = require("astronvim.utils").extend_tbl(
{ remote = "origin", show_changelog = true, sync_plugins = true, auto_quit = false },
opts
)
local available_update = M.update_available(opts)
if available_update == nil then
return
elseif not available_update then -- continue if current and target commits were found
notify "No updates available"
elseif -- prompt user if they want to accept update
not opts.skip_prompts
and not confirm_prompt(
("Update available to %s\nUpdating requires a restart, continue?"):format(
available_update.version or available_update.target
)
)
then
echo(cancelled_message)
return
else -- perform update
local source, target = available_update.source, available_update.target
M.create_rollback(true) -- create rollback file before updating
-- calculate and print the changelog
local changelog = git.get_commit_range(source, target)
local breaking = git.breaking_changes(changelog)
if
#breaking > 0
and not opts.skip_prompts
and not confirm_prompt(
("Update contains the following breaking changes:\n%s\nWould you like to continue?"):format(
table.concat(breaking, "\n")
),
"Warning"
)
then
echo(cancelled_message)
return
end
-- attempt an update
local updated = attempt_update(target, opts)
-- check for local file conflicts and prompt user to continue or abort
if
not updated
and not opts.skip_prompts
and not confirm_prompt(
"Unable to pull due to local modifications to base files.\nReset local files and continue?",
"Error"
)
then
echo(cancelled_message)
return
-- if continued and there were errors reset the base config and attempt another update
elseif not updated then
git.hard_reset(source)
updated = attempt_update(target, opts)
end
-- if update was unsuccessful throw an error
if not updated then
vim.api.nvim_err_writeln "Error occurred performing update"
return
end
-- print a summary of the update with the changelog
local summary = {
{ "AstroNvim updated successfully to ", "Title" },
{ git.current_version(), "String" },
{ "!\n", "Title" },
{
opts.auto_quit and "AstroNvim will now update plugins and quit.\n\n"
or "After plugins update, please restart.\n\n",
"WarningMsg",
},
}
if opts.show_changelog and #changelog > 0 then
vim.list_extend(summary, { { "Changelog:\n", "Title" } })
vim.list_extend(summary, git.pretty_changelog(changelog))
end
echo(summary)
-- if the user wants to auto quit, create an autocommand to quit AstroNvim on the update completing
if opts.auto_quit then
vim.api.nvim_create_autocmd("User", {
desc = "Auto quit AstroNvim after update completes",
pattern = "AstroUpdateComplete",
command = "quitall",
})
end
require("lazy.core.plugin").load() -- force immediate reload of lazy
if opts.sync_plugins then require("lazy").sync { wait = true } end
utils.event "UpdateComplete"
end
end
return M

54
lua/lazy_snapshot.lua Normal file
View File

@@ -0,0 +1,54 @@
return {
{ "AstroNvim/astrotheme", version = "^1.1", optional = true },
{ "JoosepAlviste/nvim-ts-context-commentstring", commit = "0bf8fbc2ca8f8cdb6efbd0a9e32740d7a991e4c3", optional = true },
{ "L3MON4D3/LuaSnip", version = "^1", optional = true },
{ "MunifTanjim/nui.nvim", version = "^0.1", optional = true },
{ "NMAC427/guess-indent.nvim", commit = "b8ae749fce17aa4c267eec80a6984130b94f80b2", optional = true },
{ "NvChad/nvim-colorizer.lua", commit = "dde3084106a70b9a79d48f426f6d6fec6fd203f7", optional = true },
{ "Shatur/neovim-session-manager", commit = "fd92e73506601a48adb843cdc0a15f2e63513754", optional = true },
{ "akinsho/toggleterm.nvim", version = "^2", optional = true },
{ "b0o/SchemaStore.nvim", commit = "4f96b7bb1a0d5973a249e654f02adf2973422dcc", optional = true },
{ "famiu/bufdelete.nvim", commit = "8d15a0a3189b02ac7ad9dd6dc089cc62edf095c6", optional = true },
{ "folke/lazy.nvim", version = "^9", optional = true },
{ "folke/neoconf.nvim", version = "^1", optional = true },
{ "folke/neodev.nvim", version = "^2", optional = true },
{ "folke/which-key.nvim", version = "^1", optional = true },
{ "goolord/alpha-nvim", commit = "9e33db324b8bb7a147bce9ea5496686ee859461d", optional = true },
{ "hrsh7th/cmp-buffer", commit = "3022dbc9166796b644a841a02de8dd1cc1d311fa", optional = true },
{ "hrsh7th/cmp-nvim-lsp", commit = "0e6b2ed705ddcff9738ec4ea838141654f12eeef", optional = true },
{ "hrsh7th/cmp-path", commit = "91ff86cd9c29299a64f968ebb45846c485725f23", optional = true },
{ "hrsh7th/nvim-cmp", commit = "8a1694ff330ed58ed29716686fcef79c28090354", optional = true },
{ "jay-babu/mason-null-ls.nvim", version = "^2", optional = true },
{ "jay-babu/mason-nvim-dap.nvim", version = "^2", optional = true },
{ "jose-elias-alvarez/null-ls.nvim", commit = "bbaf5a96913aa92281f154b08732be2f57021c45", optional = true },
{ "kevinhwang91/nvim-ufo", version = "^1", optional = true },
{ "kevinhwang91/promise-async", version = "^1", optional = true },
{ "lewis6991/gitsigns.nvim", version = "^0.6", optional = true },
{ "lukas-reineke/indent-blankline.nvim", version = "^2", optional = true },
{ "max397574/better-escape.nvim", commit = "7031dc734add47bb71c010e0551829fa5799375f", optional = true },
{ "mfussenegger/nvim-dap", version = "^0.6", optional = true },
{ "mrjones2014/smart-splits.nvim", version = "^1", optional = true },
{ "neovim/nvim-lspconfig", commit = "11a1be0e5f180b57079db56de10a20b4323111ae", optional = true },
{ "numToStr/Comment.nvim", version = "^0.8", optional = true },
{ "nvim-lua/plenary.nvim", version = "^0.1", optional = true },
{ "nvim-neo-tree/neo-tree.nvim", version = "^2", optional = true },
{ "nvim-telescope/telescope-fzf-native.nvim", commit = "9bc8237565ded606e6c366a71c64c0af25cd7a50", optional = true },
{ "nvim-telescope/telescope.nvim", version = "^0.1", optional = true },
{ "nvim-tree/nvim-web-devicons", commit = "14b3a5ba63b82b60cde98d0a40319d80f25e8301", optional = true },
{ "nvim-treesitter/nvim-treesitter", commit = "cbd54ebb8d633fb84b5592741cd3e22765d90fc0", optional = true },
{ "nvim-treesitter/nvim-treesitter-textobjects", commit = "83c59ed1eeae70a55605990993cf4d208948fdf7", optional = true },
{ "onsails/lspkind.nvim", commit = "57610d5ab560c073c465d6faf0c19f200cb67e6e", optional = true },
{ "rafamadriz/friendly-snippets", commit = "5749f093759c29e3694053d048ceb940fe12c3d3", optional = true },
{ "rcarriga/cmp-dap", commit = "d16f14a210cd28988b97ca8339d504533b7e09a4", optional = true },
{ "rcarriga/nvim-dap-ui", version = "^3", optional = true },
{ "rcarriga/nvim-notify", version = "^3", optional = true },
{ "rebelot/heirline.nvim", commit = "2a151df2dc870e79b138a59ebaaaddf3d1b0d703", optional = true },
{ "s1n7ax/nvim-window-picker", version = "^2", optional = true },
{ "saadparwaiz1/cmp_luasnip", commit = "18095520391186d634a0045dacaa346291096566", optional = true },
{ "stevearc/aerial.nvim", commit = "c30fb2c9bd09592351eed676f4c20e7a6411020e", optional = true },
{ "stevearc/dressing.nvim", commit = "5fb5cce0cbfcedeadbcee43e5674e8c9a9f28d4a", optional = true },
{ "williamboman/mason-lspconfig.nvim", version = "^1.1", optional = true },
{ "williamboman/mason.nvim", version = "^1", optional = true },
{ "windwp/nvim-autopairs", commit = "e8f7dd7a72de3e7b6626c050a802000e69d53ff0", optional = true },
{ "windwp/nvim-ts-autotag", commit = "6be1192965df35f94b8ea6d323354f7dc7a557e4", optional = true },
}

38
lua/plugins/alpha.lua Normal file
View File

@@ -0,0 +1,38 @@
return {
"goolord/alpha-nvim",
cmd = "Alpha",
opts = function()
local dashboard = require "alpha.themes.dashboard"
dashboard.section.header.val = {
" █████ ███████ ████████ ██████ ██████",
"██ ██ ██ ██ ██ ██ ██ ██",
"███████ ███████ ██ ██████ ██ ██",
"██ ██ ██ ██ ██ ██ ██ ██",
"██ ██ ███████ ██ ██ ██ ██████",
" ",
" ███ ██ ██ ██ ██ ███ ███",
" ████ ██ ██ ██ ██ ████ ████",
" ██ ██ ██ ██ ██ ██ ██ ████ ██",
" ██ ██ ██ ██ ██ ██ ██ ██ ██",
" ██ ████ ████ ██ ██ ██",
}
dashboard.section.header.opts.hl = "DashboardHeader"
local button = require("astronvim.utils").alpha_button
local get_icon = require("astronvim.utils").get_icon
dashboard.section.buttons.val = {
button("LDR n ", get_icon("FileNew", 2, true) .. "New File "),
button("LDR f f", get_icon("Search", 2, true) .. "Find File "),
button("LDR f o", get_icon("DefaultFile", 2, true) .. "Recents "),
button("LDR f w", get_icon("WordFile", 2, true) .. "Find Word "),
button("LDR f '", get_icon("Bookmarks", 2, true) .. "Bookmarks "),
button("LDR S l", get_icon("Refresh", 2, true) .. "Last Session "),
}
dashboard.config.layout[1].val = vim.fn.max { 2, vim.fn.floor(vim.fn.winheight(0) * 0.2) }
dashboard.config.layout[3].val = 5
dashboard.config.opts.noautocmd = true
return dashboard
end,
config = require "plugins.configs.alpha",
}

112
lua/plugins/cmp.lua Normal file
View File

@@ -0,0 +1,112 @@
return {
{
"L3MON4D3/LuaSnip",
build = vim.fn.has "win32" ~= 0
and "echo 'NOTE: jsregexp is optional, so not a big deal if it fails to build\n'; make install_jsregexp"
or nil,
dependencies = { "rafamadriz/friendly-snippets" },
opts = { store_selection_keys = "<C-x>" },
config = require "plugins.configs.luasnip",
},
{
"hrsh7th/nvim-cmp",
dependencies = {
"saadparwaiz1/cmp_luasnip",
"hrsh7th/cmp-buffer",
"hrsh7th/cmp-path",
"hrsh7th/cmp-nvim-lsp",
},
event = "InsertEnter",
opts = function()
local cmp = require "cmp"
local snip_status_ok, luasnip = pcall(require, "luasnip")
local lspkind_status_ok, lspkind = pcall(require, "lspkind")
local utils = require "astronvim.utils"
if not snip_status_ok then return end
local border_opts = {
border = "single",
winhighlight = "Normal:Normal,FloatBorder:FloatBorder,CursorLine:Visual,Search:None",
}
local function has_words_before()
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match "%s" == nil
end
return {
enabled = function()
local dap_prompt = utils.is_available "cmp-dap" -- add interoperability with cmp-dap
and vim.tbl_contains(
{ "dap-repl", "dapui_watches", "dapui_hover" },
vim.api.nvim_get_option_value("filetype", { buf = 0 })
)
if vim.api.nvim_get_option_value("buftype", { buf = 0 }) == "prompt" and not dap_prompt then return false end
return vim.g.cmp_enabled
end,
preselect = cmp.PreselectMode.None,
formatting = {
fields = { "kind", "abbr", "menu" },
format = lspkind_status_ok and lspkind.cmp_format(utils.plugin_opts "lspkind.nvim") or nil,
},
snippet = {
expand = function(args) luasnip.lsp_expand(args.body) end,
},
duplicates = {
nvim_lsp = 1,
luasnip = 1,
cmp_tabnine = 1,
buffer = 1,
path = 1,
},
confirm_opts = {
behavior = cmp.ConfirmBehavior.Replace,
select = false,
},
window = {
completion = cmp.config.window.bordered(border_opts),
documentation = cmp.config.window.bordered(border_opts),
},
mapping = {
["<Up>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Select },
["<Down>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Select },
["<C-p>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Insert },
["<C-n>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Insert },
["<C-k>"] = cmp.mapping.select_prev_item { behavior = cmp.SelectBehavior.Insert },
["<C-j>"] = cmp.mapping.select_next_item { behavior = cmp.SelectBehavior.Insert },
["<C-u>"] = cmp.mapping(cmp.mapping.scroll_docs(-4), { "i", "c" }),
["<C-d>"] = cmp.mapping(cmp.mapping.scroll_docs(4), { "i", "c" }),
["<C-Space>"] = cmp.mapping(cmp.mapping.complete(), { "i", "c" }),
["<C-y>"] = cmp.config.disable,
["<C-e>"] = cmp.mapping { i = cmp.mapping.abort(), c = cmp.mapping.close() },
["<CR>"] = cmp.mapping.confirm { select = false },
["<Tab>"] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.expand_or_jumpable() then
luasnip.expand_or_jump()
elseif has_words_before() then
cmp.complete()
else
fallback()
end
end, { "i", "s" }),
["<S-Tab>"] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
elseif luasnip.jumpable(-1) then
luasnip.jump(-1)
else
fallback()
end
end, { "i", "s" }),
},
sources = cmp.config.sources {
{ name = "nvim_lsp", priority = 1000 },
{ name = "luasnip", priority = 750 },
{ name = "buffer", priority = 500 },
{ name = "path", priority = 250 },
},
}
end,
},
}

17
lua/plugins/configs/alpha.lua Normal file
View File

@@ -0,0 +1,17 @@
return function(_, opts)
require("alpha").setup(opts.config)
vim.api.nvim_create_autocmd("User", {
pattern = "LazyVimStarted",
desc = "Add Alpha dashboard footer",
once = true,
callback = function()
local stats = require("lazy").stats()
local ms = math.floor(stats.startuptime * 100 + 0.5) / 100
opts.section.footer.val =
{ " ", " ", " ", "AstroNvim loaded " .. stats.count .. " plugins  in " .. ms .. "ms" }
opts.section.footer.opts.hl = "DashboardFooter"
pcall(vim.cmd.AlphaRedraw)
end,
})
end

7
lua/plugins/configs/cmp-dap.lua Normal file
View File

@@ -0,0 +1,7 @@
return function()
require("cmp").setup.filetype({ "dap-repl", "dapui_watches", "dapui_hover" }, {
sources = {
{ name = "dap" },
},
})
end

4
lua/plugins/configs/guess-indent.lua Normal file
View File

@@ -0,0 +1,4 @@
return function(_, opts)
require("guess-indent").setup(opts)
vim.cmd.lua { args = { "require('guess-indent').set_from_buffer('auto_cmd')" }, mods = { silent = true } }
end

119
lua/plugins/configs/heirline.lua Normal file
View File

@@ -0,0 +1,119 @@
return function(_, opts)
local heirline = require "heirline"
local hl = require "astronvim.utils.status.hl"
local C = require("astronvim.utils.status.env").fallback_colors
local get_hlgroup = require("astronvim.utils").get_hlgroup
local function setup_colors()
local Normal = get_hlgroup("Normal", { fg = C.fg, bg = C.bg })
local Comment = get_hlgroup("Comment", { fg = C.bright_grey, bg = C.bg })
local Error = get_hlgroup("Error", { fg = C.red, bg = C.bg })
local StatusLine = get_hlgroup("StatusLine", { fg = C.fg, bg = C.dark_bg })
local TabLine = get_hlgroup("TabLine", { fg = C.grey, bg = C.none })
local TabLineFill = get_hlgroup("TabLineFill", { fg = C.fg, bg = C.dark_bg })
local TabLineSel = get_hlgroup("TabLineSel", { fg = C.fg, bg = C.none })
local WinBar = get_hlgroup("WinBar", { fg = C.bright_grey, bg = C.bg })
local WinBarNC = get_hlgroup("WinBarNC", { fg = C.grey, bg = C.bg })
local Conditional = get_hlgroup("Conditional", { fg = C.bright_purple, bg = C.dark_bg })
local String = get_hlgroup("String", { fg = C.green, bg = C.dark_bg })
local TypeDef = get_hlgroup("TypeDef", { fg = C.yellow, bg = C.dark_bg })
local GitSignsAdd = get_hlgroup("GitSignsAdd", { fg = C.green, bg = C.dark_bg })
local GitSignsChange = get_hlgroup("GitSignsChange", { fg = C.orange, bg = C.dark_bg })
local GitSignsDelete = get_hlgroup("GitSignsDelete", { fg = C.bright_red, bg = C.dark_bg })
local DiagnosticError = get_hlgroup("DiagnosticError", { fg = C.bright_red, bg = C.dark_bg })
local DiagnosticWarn = get_hlgroup("DiagnosticWarn", { fg = C.orange, bg = C.dark_bg })
local DiagnosticInfo = get_hlgroup("DiagnosticInfo", { fg = C.white, bg = C.dark_bg })
local DiagnosticHint = get_hlgroup("DiagnosticHint", { fg = C.bright_yellow, bg = C.dark_bg })
local HeirlineInactive = get_hlgroup("HeirlineInactive", { bg = nil }).bg
or hl.lualine_mode("inactive", C.dark_grey)
local HeirlineNormal = get_hlgroup("HeirlineNormal", { bg = nil }).bg or hl.lualine_mode("normal", C.blue)
local HeirlineInsert = get_hlgroup("HeirlineInsert", { bg = nil }).bg or hl.lualine_mode("insert", C.green)
local HeirlineVisual = get_hlgroup("HeirlineVisual", { bg = nil }).bg or hl.lualine_mode("visual", C.purple)
local HeirlineReplace = get_hlgroup("HeirlineReplace", { bg = nil }).bg or hl.lualine_mode("replace", C.bright_red)
local HeirlineCommand = get_hlgroup("HeirlineCommand", { bg = nil }).bg
or hl.lualine_mode("command", C.bright_yellow)
local HeirlineTerminal = get_hlgroup("HeirlineTerminal", { bg = nil }).bg
or hl.lualine_mode("insert", HeirlineInsert)
local colors = astronvim.user_opts("heirline.colors", {
close_fg = Error.fg,
fg = StatusLine.fg,
bg = StatusLine.bg,
section_fg = StatusLine.fg,
section_bg = StatusLine.bg,
git_branch_fg = Conditional.fg,
mode_fg = StatusLine.bg,
treesitter_fg = String.fg,
scrollbar = TypeDef.fg,
git_added = GitSignsAdd.fg,
git_changed = GitSignsChange.fg,
git_removed = GitSignsDelete.fg,
diag_ERROR = DiagnosticError.fg,
diag_WARN = DiagnosticWarn.fg,
diag_INFO = DiagnosticInfo.fg,
diag_HINT = DiagnosticHint.fg,
winbar_fg = WinBar.fg,
winbar_bg = WinBar.bg,
winbarnc_fg = WinBarNC.fg,
winbarnc_bg = WinBarNC.bg,
tabline_bg = TabLineFill.bg,
tabline_fg = TabLineFill.bg,
buffer_fg = Comment.fg,
buffer_path_fg = WinBarNC.fg,
buffer_close_fg = Comment.fg,
buffer_bg = TabLineFill.bg,
buffer_active_fg = Normal.fg,
buffer_active_path_fg = WinBarNC.fg,
buffer_active_close_fg = Error.fg,
buffer_active_bg = Normal.bg,
buffer_visible_fg = Normal.fg,
buffer_visible_path_fg = WinBarNC.fg,
buffer_visible_close_fg = Error.fg,
buffer_visible_bg = Normal.bg,
buffer_overflow_fg = Comment.fg,
buffer_overflow_bg = TabLineFill.bg,
buffer_picker_fg = Error.fg,
tab_close_fg = Error.fg,
tab_close_bg = TabLineFill.bg,
tab_fg = TabLine.fg,
tab_bg = TabLine.bg,
tab_active_fg = TabLineSel.fg,
tab_active_bg = TabLineSel.bg,
inactive = HeirlineInactive,
normal = HeirlineNormal,
insert = HeirlineInsert,
visual = HeirlineVisual,
replace = HeirlineReplace,
command = HeirlineCommand,
terminal = HeirlineTerminal,
})
for _, section in ipairs {
"git_branch",
"file_info",
"git_diff",
"diagnostics",
"lsp",
"macro_recording",
"mode",
"cmd_info",
"treesitter",
"nav",
} do
if not colors[section .. "_bg"] then colors[section .. "_bg"] = colors["section_bg"] end
if not colors[section .. "_fg"] then colors[section .. "_fg"] = colors["section_fg"] end
end
return colors
end
heirline.load_colors(setup_colors())
heirline.setup(opts)
local augroup = vim.api.nvim_create_augroup("Heirline", { clear = true })
vim.api.nvim_create_autocmd("User", {
pattern = "AstroColorScheme",
group = augroup,
desc = "Refresh heirline colors",
callback = function() require("heirline.utils").on_colorscheme(setup_colors()) end,
})
end

56
lua/plugins/configs/lspconfig.lua Normal file
View File

@@ -0,0 +1,56 @@
return function(_, _)
local lsp = require "astronvim.utils.lsp"
local utils = require "astronvim.utils"
local get_icon = utils.get_icon
local signs = {
{ name = "DiagnosticSignError", text = get_icon "DiagnosticError", texthl = "DiagnosticSignError" },
{ name = "DiagnosticSignWarn", text = get_icon "DiagnosticWarn", texthl = "DiagnosticSignWarn" },
{ name = "DiagnosticSignHint", text = get_icon "DiagnosticHint", texthl = "DiagnosticSignHint" },
{ name = "DiagnosticSignInfo", text = get_icon "DiagnosticInfo", texthl = "DiagnosticSignInfo" },
{ name = "DapStopped", text = get_icon "DapStopped", texthl = "DiagnosticWarn" },
{ name = "DapBreakpoint", text = get_icon "DapBreakpoint", texthl = "DiagnosticInfo" },
{ name = "DapBreakpointRejected", text = get_icon "DapBreakpointRejected", texthl = "DiagnosticError" },
{ name = "DapBreakpointCondition", text = get_icon "DapBreakpointCondition", texthl = "DiagnosticInfo" },
{ name = "DapLogPoint", text = get_icon "DapLogPoint", texthl = "DiagnosticInfo" },
}
for _, sign in ipairs(signs) do
vim.fn.sign_define(sign.name, sign)
end
lsp.setup_diagnostics(signs)
local orig_handler = vim.lsp.handlers["$/progress"]
vim.lsp.handlers["$/progress"] = function(_, msg, info)
local progress, id = astronvim.lsp.progress, ("%s.%s"):format(info.client_id, msg.token)
progress[id] = progress[id] and utils.extend_tbl(progress[id], msg.value) or msg.value
if progress[id].kind == "end" then
vim.defer_fn(function()
progress[id] = nil
utils.event "LspProgress"
end, 100)
end
utils.event "LspProgress"
orig_handler(_, msg, info)
end
if vim.g.lsp_handlers_enabled then
vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded", silent = true })
vim.lsp.handlers["textDocument/signatureHelp"] =
vim.lsp.with(vim.lsp.handlers.signature_help, { border = "rounded", silent = true })
end
local setup_servers = function()
vim.tbl_map(require("astronvim.utils.lsp").setup, astronvim.user_opts "lsp.servers")
vim.api.nvim_exec_autocmds("FileType", {})
require("astronvim.utils").event "LspSetup"
end
if require("astronvim.utils").is_available "mason-lspconfig.nvim" then
vim.api.nvim_create_autocmd("User", {
desc = "set up LSP servers after mason-lspconfig",
pattern = "AstroMasonLspSetup",
once = true,
callback = setup_servers,
})
else
setup_servers()
end
end

1
lua/plugins/configs/lspkind.lua Normal file
View File

@@ -0,0 +1 @@
return function(_, opts) require("lspkind").init(opts) end

4
lua/plugins/configs/luasnip.lua Normal file
View File

@@ -0,0 +1,4 @@
return function(_, opts)
if opts then require("luasnip").config.setup(opts) end
vim.tbl_map(function(type) require("luasnip.loaders.from_" .. type).lazy_load() end, { "vscode", "snipmate", "lua" })
end

4
lua/plugins/configs/mason-lspconfig.lua Normal file
View File

@@ -0,0 +1,4 @@
return function(_, opts)
require("mason-lspconfig").setup(opts)
require("astronvim.utils").event "MasonLspSetup"
end

5
lua/plugins/configs/mason-null-ls.lua Normal file
View File

@@ -0,0 +1,5 @@
-- TODO: REMOVE THIS UNNECESSARY FILE
return function(_, opts)
local mason_null_ls = require "mason-null-ls"
mason_null_ls.setup(opts)
end

5
lua/plugins/configs/mason-nvim-dap.lua Normal file
View File

@@ -0,0 +1,5 @@
-- TODO: remove unnecessary file in AstroNvim v4
return function(_, opts)
local mason_nvim_dap = require "mason-nvim-dap"
mason_nvim_dap.setup(opts)
end

26
lua/plugins/configs/mason.lua Normal file
View File

@@ -0,0 +1,26 @@
return function(_, opts)
require("mason").setup(opts)
-- TODO: AstroNvim v4: change these auto command names to not conflict with core Mason commands
local cmd = vim.api.nvim_create_user_command
cmd("MasonUpdate", function(options) require("astronvim.utils.mason").update(options.fargs) end, {
nargs = "*",
desc = "Update Mason Package",
complete = function(arg_lead)
local _ = require "mason-core.functional"
return _.sort_by(
_.identity,
_.filter(_.starts_with(arg_lead), require("mason-registry").get_installed_package_names())
)
end,
})
cmd(
"MasonUpdateAll",
function() require("astronvim.utils.mason").update_all() end,
{ desc = "Update Mason Packages" }
)
for _, plugin in ipairs { "mason-lspconfig", "mason-null-ls", "mason-nvim-dap" } do
pcall(require, plugin)
end
end

5
lua/plugins/configs/notify.lua Normal file
View File

@@ -0,0 +1,5 @@
return function(_, opts)
local notify = require "notify"
notify.setup(opts)
vim.notify = notify
end

10
lua/plugins/configs/nvim-autopairs.lua Normal file
View File

@@ -0,0 +1,10 @@
return function(_, opts)
local npairs = require "nvim-autopairs"
npairs.setup(opts)
if not vim.g.autopairs_enabled then npairs.disable() end
local cmp_status_ok, cmp = pcall(require, "cmp")
if cmp_status_ok then
cmp.event:on("confirm_done", require("nvim-autopairs.completion.cmp").on_confirm_done { tex = false })
end
end

7
lua/plugins/configs/nvim-dap-ui.lua Normal file
View File

@@ -0,0 +1,7 @@
return function(_, opts)
local dap, dapui = require "dap", require "dapui"
dap.listeners.after.event_initialized["dapui_config"] = function() dapui.open() end
dap.listeners.before.event_terminated["dapui_config"] = function() dapui.close() end
dap.listeners.before.event_exited["dapui_config"] = function() dapui.close() end
dapui.setup(opts)
end

1
lua/plugins/configs/nvim-treesitter.lua Normal file
View File

@@ -0,0 +1 @@
return function(_, opts) require("nvim-treesitter.configs").setup(opts) end

5
lua/plugins/configs/nvim-web-devicons.lua Normal file
View File

@@ -0,0 +1,5 @@
-- TODO: remove unnecessary file in AstroNvim v4
return function(_, opts)
require("nvim-web-devicons").set_default_icon(require("astronvim.utils").get_icon "DefaultFile", "#6d8086", "66")
require("nvim-web-devicons").set_icon(opts)
end

9
lua/plugins/configs/telescope.lua Normal file
View File

@@ -0,0 +1,9 @@
return function(_, opts)
local telescope = require "telescope"
telescope.setup(opts)
local utils = require "astronvim.utils"
local conditional_func = utils.conditional_func
conditional_func(telescope.load_extension, pcall(require, "notify"), "notify")
conditional_func(telescope.load_extension, pcall(require, "aerial"), "aerial")
conditional_func(telescope.load_extension, utils.is_available "telescope-fzf-native.nvim", "fzf")
end

4
lua/plugins/configs/which-key.lua Normal file
View File

@@ -0,0 +1,4 @@
return function(_, opts)
require("which-key").setup(opts)
require("astronvim.utils").which_key_register()
end

127
lua/plugins/core.lua Normal file
View File

@@ -0,0 +1,127 @@
return {
"nvim-lua/plenary.nvim",
{ "AstroNvim/astrotheme", opts = { plugins = { ["dashboard-nvim"] = true } } },
{ "famiu/bufdelete.nvim", cmd = { "Bdelete", "Bwipeout" } },
{ "max397574/better-escape.nvim", event = "InsertCharPre", opts = { timeout = 300 } },
{ "NMAC427/guess-indent.nvim", event = "User AstroFile", config = require "plugins.configs.guess-indent" },
{ -- TODO: REMOVE neovim-session-manager with AstroNvim v4
"Shatur/neovim-session-manager",
event = "BufWritePost",
cmd = "SessionManager",
enabled = vim.g.resession_enabled ~= true,
},
{
"stevearc/resession.nvim",
enabled = vim.g.resession_enabled == true,
opts = {
buf_filter = function(bufnr) return require("astronvim.utils.buffer").is_restorable(bufnr) end,
tab_buf_filter = function(tabpage, bufnr) return vim.tbl_contains(vim.t[tabpage].bufs, bufnr) end,
extensions = { astronvim = {} },
},
},
{
"s1n7ax/nvim-window-picker",
name = "window-picker",
opts = {
picker_config = {
statusline_winbar_picker = {
use_winbar = "smart",
},
},
},
},
{
"mrjones2014/smart-splits.nvim",
opts = { ignored_filetypes = { "nofile", "quickfix", "qf", "prompt" }, ignored_buftypes = { "nofile" } },
},
{
"windwp/nvim-autopairs",
event = "InsertEnter",
opts = {
check_ts = true,
ts_config = { java = false },
fast_wrap = {
map = "<M-e>",
chars = { "{", "[", "(", '"', "'" },
pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
offset = 0,
end_key = "$",
keys = "qwertyuiopzxcvbnmasdfghjkl",
check_comma = true,
highlight = "PmenuSel",
highlight_grey = "LineNr",
},
},
config = require "plugins.configs.nvim-autopairs",
},
{
"folke/which-key.nvim",
event = "VeryLazy",
opts = {
icons = { group = vim.g.icons_enabled and "" or "+", separator = "" },
disable = { filetypes = { "TelescopePrompt" } },
},
config = require "plugins.configs.which-key",
},
{
"kevinhwang91/nvim-ufo",
event = { "User AstroFile", "InsertEnter" },
dependencies = { "kevinhwang91/promise-async" },
opts = {
preview = {
mappings = {
scrollB = "<C-b>",
scrollF = "<C-f>",
scrollU = "<C-u>",
scrollD = "<C-d>",
},
},
provider_selector = function(_, filetype, buftype)
local function handleFallbackException(bufnr, err, providerName)
if type(err) == "string" and err:match "UfoFallbackException" then
return require("ufo").getFolds(bufnr, providerName)
else
return require("promise").reject(err)
end
end
return (filetype == "" or buftype == "nofile") and "indent" -- only use indent until a file is opened
or function(bufnr)
return require("ufo")
.getFolds(bufnr, "lsp")
:catch(function(err) return handleFallbackException(bufnr, err, "treesitter") end)
:catch(function(err) return handleFallbackException(bufnr, err, "indent") end)
end
end,
},
},
{
"numToStr/Comment.nvim",
keys = {
{ "gc", mode = { "n", "v" }, desc = "Comment toggle linewise" },
{ "gb", mode = { "n", "v" }, desc = "Comment toggle blockwise" },
},
opts = function()
local commentstring_avail, commentstring = pcall(require, "ts_context_commentstring.integrations.comment_nvim")
return commentstring_avail and commentstring and { pre_hook = commentstring.create_pre_hook() } or {}
end,
},
{
"akinsho/toggleterm.nvim",
cmd = { "ToggleTerm", "TermExec" },
opts = {
size = 10,
on_create = function()
vim.opt.foldcolumn = "0"
vim.opt.signcolumn = "no"
end,
open_mapping = [[<F7>]],
shading_factor = 2,
direction = "float",
float_opts = {
border = "curved",
highlights = { border = "Normal", background = "Normal" },
},
},
},
}

23
lua/plugins/dap.lua Normal file
View File

@@ -0,0 +1,23 @@
return {
"mfussenegger/nvim-dap",
enabled = vim.fn.has "win32" == 0,
dependencies = {
{
"jay-babu/mason-nvim-dap.nvim",
dependencies = { "nvim-dap" },
cmd = { "DapInstall", "DapUninstall" },
opts = { handlers = {} },
},
{
"rcarriga/nvim-dap-ui",
opts = { floating = { border = "rounded" } },
config = require "plugins.configs.nvim-dap-ui",
},
{
"rcarriga/cmp-dap",
dependencies = { "nvim-cmp" },
config = require "plugins.configs.cmp-dap",
},
},
event = "User AstroFile",
}

16
lua/plugins/git.lua Normal file
View File

@@ -0,0 +1,16 @@
local get_icon = require("astronvim.utils").get_icon
return {
"lewis6991/gitsigns.nvim",
enabled = vim.fn.executable "git" == 1,
event = "User AstroGitFile",
opts = {
signs = {
add = { text = get_icon "GitSign" },
change = { text = get_icon "GitSign" },
delete = { text = get_icon "GitSign" },
topdelete = { text = get_icon "GitSign" },
changedelete = { text = get_icon "GitSign" },
untracked = { text = get_icon "GitSign" },
},
},
}

87
lua/plugins/heirline.lua Normal file
View File

@@ -0,0 +1,87 @@
return {
"rebelot/heirline.nvim",
event = "BufEnter",
opts = function()
local status = require "astronvim.utils.status"
return {
opts = {
disable_winbar_cb = function(args)
return not require("astronvim.utils.buffer").is_valid(args.buf)
or status.condition.buffer_matches({
buftype = { "terminal", "prompt", "nofile", "help", "quickfix" },
filetype = { "NvimTree", "neo%-tree", "dashboard", "Outline", "aerial" },
}, args.buf)
end,
},
statusline = { -- statusline
hl = { fg = "fg", bg = "bg" },
status.component.mode(),
status.component.git_branch(),
status.component.file_info { filetype = {}, filename = false, file_modified = false },
status.component.git_diff(),
status.component.diagnostics(),
status.component.fill(),
status.component.cmd_info(),
status.component.fill(),
status.component.lsp(),
status.component.treesitter(),
status.component.nav(),
status.component.mode { surround = { separator = "right" } },
},
winbar = { -- winbar
init = function(self) self.bufnr = vim.api.nvim_get_current_buf() end,
fallthrough = false,
{
condition = function() return not status.condition.is_active() end,
status.component.separated_path(),
status.component.file_info {
file_icon = { hl = status.hl.file_icon "winbar", padding = { left = 0 } },
file_modified = false,
file_read_only = false,
hl = status.hl.get_attributes("winbarnc", true),
surround = false,
update = "BufEnter",
},
},
status.component.breadcrumbs { hl = status.hl.get_attributes("winbar", true) },
},
tabline = { -- bufferline
{ -- file tree padding
condition = function(self)
self.winid = vim.api.nvim_tabpage_list_wins(0)[1]
return status.condition.buffer_matches(
{ filetype = { "aerial", "dapui_.", "neo%-tree", "NvimTree" } },
vim.api.nvim_win_get_buf(self.winid)
)
end,
provider = function(self) return string.rep(" ", vim.api.nvim_win_get_width(self.winid) + 1) end,
hl = { bg = "tabline_bg" },
},
status.heirline.make_buflist(status.component.tabline_file_info()), -- component for each buffer tab
status.component.fill { hl = { bg = "tabline_bg" } }, -- fill the rest of the tabline with background color
{ -- tab list
condition = function() return #vim.api.nvim_list_tabpages() >= 2 end, -- only show tabs if there are more than one
status.heirline.make_tablist { -- component for each tab
provider = status.provider.tabnr(),
hl = function(self) return status.hl.get_attributes(status.heirline.tab_type(self, "tab"), true) end,
},
{ -- close button for current tab
provider = status.provider.close_button { kind = "TabClose", padding = { left = 1, right = 1 } },
hl = status.hl.get_attributes("tab_close", true),
on_click = {
callback = function() require("astronvim.utils.buffer").close_tab() end,
name = "heirline_tabline_close_tab_callback",
},
},
},
},
statuscolumn = vim.fn.has "nvim-0.9" == 1 and {
status.component.foldcolumn(),
status.component.fill(),
status.component.numbercolumn(),
status.component.signcolumn(),
} or nil,
}
end,
config = require "plugins.configs.heirline",
}

93
lua/plugins/lsp.lua Normal file
View File

@@ -0,0 +1,93 @@
return {
"b0o/SchemaStore.nvim",
{
"folke/neodev.nvim",
opts = {
override = function(root_dir, library)
for _, astronvim_config in ipairs(astronvim.supported_configs) do
if root_dir:match(astronvim_config) then
library.plugins = true
break
end
end
vim.b.neodev_enabled = library.enabled
end,
},
},
{
"neovim/nvim-lspconfig",
dependencies = {
{
"folke/neoconf.nvim",
cmd = "Neoconf",
opts = function()
local global_settings, file_found
local _, depth = vim.fn.stdpath("config"):gsub("/", "")
for _, dir in ipairs(astronvim.supported_configs) do
dir = dir .. "/lua/user"
if vim.fn.isdirectory(dir) == 1 then
local path = dir .. "/neoconf.json"
if vim.fn.filereadable(path) == 1 then
file_found = true
global_settings = path
elseif not file_found then
global_settings = path
end
end
end
return { global_settings = global_settings and string.rep("../", depth):sub(1, -2) .. global_settings }
end,
},
{
"williamboman/mason-lspconfig.nvim",
cmd = { "LspInstall", "LspUninstall" },
opts = function(_, opts)
if not opts.handlers then opts.handlers = {} end
opts.handlers[1] = function(server) require("astronvim.utils.lsp").setup(server) end
end,
config = require "plugins.configs.mason-lspconfig",
},
},
event = "User AstroFile",
config = require "plugins.configs.lspconfig",
},
{
"jose-elias-alvarez/null-ls.nvim",
dependencies = {
{
"jay-babu/mason-null-ls.nvim",
cmd = { "NullLsInstall", "NullLsUninstall" },
opts = { handlers = {} },
},
},
event = "User AstroFile",
opts = function() return { on_attach = require("astronvim.utils.lsp").on_attach } end,
},
{
"stevearc/aerial.nvim",
event = "User AstroFile",
opts = {
attach_mode = "global",
backends = { "lsp", "treesitter", "markdown", "man" },
layout = { min_width = 28 },
show_guides = true,
filter_kind = false,
guides = {
mid_item = "├ ",
last_item = "└ ",
nested_top = "│ ",
whitespace = " ",
},
keymaps = {
["[y"] = "actions.prev",
["]y"] = "actions.next",
["[Y"] = "actions.prev_up",
["]Y"] = "actions.next_up",
["{"] = false,
["}"] = false,
["[["] = false,
["]]"] = false,
},
},
},
}

25
lua/plugins/mason.lua Normal file
View File

@@ -0,0 +1,25 @@
return {
{
"williamboman/mason.nvim",
cmd = {
"Mason",
"MasonInstall",
"MasonUninstall",
"MasonUninstallAll",
"MasonLog",
"MasonUpdate", -- AstroNvim extension here as well
"MasonUpdateAll", -- AstroNvim specific
},
opts = {
ui = {
icons = {
package_installed = "✓",
package_uninstalled = "✗",
package_pending = "⟳",
},
},
},
build = ":MasonUpdate",
config = require "plugins.configs.mason",
},
}

128
lua/plugins/neo-tree.lua Normal file
View File

@@ -0,0 +1,128 @@
local get_icon = require("astronvim.utils").get_icon
return {
"nvim-neo-tree/neo-tree.nvim",
dependencies = { "MunifTanjim/nui.nvim" },
cmd = "Neotree",
init = function() vim.g.neo_tree_remove_legacy_commands = true end,
opts = {
auto_clean_after_session_restore = true,
close_if_last_window = true,
sources = { "filesystem", "buffers", "git_status" },
source_selector = {
winbar = true,
content_layout = "center",
sources = {
{ source = "filesystem", display_name = get_icon("FolderClosed", 1, true) .. "File" },
{ source = "buffers", display_name = get_icon("DefaultFile", 1, true) .. "Bufs" },
{ source = "git_status", display_name = get_icon("Git", 1, true) .. "Git" },
{ source = "diagnostics", display_name = get_icon("Diagnostic", 1, true) .. "Diagnostic" },
},
},
default_component_configs = {
indent = { padding = 0 },
icon = {
folder_closed = get_icon "FolderClosed",
folder_open = get_icon "FolderOpen",
folder_empty = get_icon "FolderEmpty",
folder_empty_open = get_icon "FolderEmpty",
default = get_icon "DefaultFile",
},
modified = { symbol = get_icon "FileModified" },
git_status = {
symbols = {
added = get_icon "GitAdd",
deleted = get_icon "GitDelete",
modified = get_icon "GitChange",
renamed = get_icon "GitRenamed",
untracked = get_icon "GitUntracked",
ignored = get_icon "GitIgnored",
unstaged = get_icon "GitUnstaged",
staged = get_icon "GitStaged",
conflict = get_icon "GitConflict",
},
},
},
commands = {
system_open = function(state) require("astronvim.utils").system_open(state.tree:get_node():get_id()) end,
parent_or_close = function(state)
local node = state.tree:get_node()
if (node.type == "directory" or node:has_children()) and node:is_expanded() then
state.commands.toggle_node(state)
else
require("neo-tree.ui.renderer").focus_node(state, node:get_parent_id())
end
end,
child_or_open = function(state)
local node = state.tree:get_node()
if node.type == "directory" or node:has_children() then
if not node:is_expanded() then -- if unexpanded, expand
state.commands.toggle_node(state)
else -- if expanded and has children, seleect the next child
require("neo-tree.ui.renderer").focus_node(state, node:get_child_ids()[1])
end
else -- if not a directory just open it
state.commands.open(state)
end
end,
copy_selector = function(state)
local node = state.tree:get_node()
local filepath = node:get_id()
local filename = node.name
local modify = vim.fn.fnamemodify
local results = {
e = { val = modify(filename, ":e"), msg = "Extension only" },
f = { val = filename, msg = "Filename" },
F = { val = modify(filename, ":r"), msg = "Filename w/o extension" },
h = { val = modify(filepath, ":~"), msg = "Path relative to Home" },
p = { val = modify(filepath, ":."), msg = "Path relative to CWD" },
P = { val = filepath, msg = "Absolute path" },
}
local messages = {
{ "\nChoose to copy to clipboard:\n", "Normal" },
}
for i, result in pairs(results) do
if result.val and result.val ~= "" then
vim.list_extend(messages, {
{ ("%s."):format(i), "Identifier" },
{ (" %s: "):format(result.msg) },
{ result.val, "String" },
{ "\n" },
})
end
end
vim.api.nvim_echo(messages, false, {})
local result = results[vim.fn.getcharstr()]
if result and result.val and result.val ~= "" then
vim.notify("Copied: " .. result.val)
vim.fn.setreg("+", result.val)
end
end,
},
window = {
width = 30,
mappings = {
["<space>"] = false, -- disable space until we figure out which-key disabling
["[b"] = "prev_source",
["]b"] = "next_source",
o = "open",
O = "system_open",
h = "parent_or_close",
l = "child_or_open",
Y = "copy_selector",
},
},
filesystem = {
follow_current_file = true,
hijack_netrw_behavior = "open_current",
use_libuv_file_watcher = true,
},
event_handlers = {
{
event = "neo_tree_buffer_enter",
handler = function(_) vim.opt_local.signcolumn = "auto" end,
},
},
},
}

36
lua/plugins/telescope.lua Normal file
View File

@@ -0,0 +1,36 @@
return {
"nvim-telescope/telescope.nvim",
dependencies = {
{ "nvim-telescope/telescope-fzf-native.nvim", enabled = vim.fn.executable "make" == 1, build = "make" },
},
cmd = "Telescope",
opts = function()
local actions = require "telescope.actions"
local get_icon = require("astronvim.utils").get_icon
return {
defaults = {
prompt_prefix = get_icon("Selected", 1),
selection_caret = get_icon("Selected", 1),
path_display = { "truncate" },
sorting_strategy = "ascending",
layout_config = {
horizontal = { prompt_position = "top", preview_width = 0.55 },
vertical = { mirror = false },
width = 0.87,
height = 0.80,
preview_cutoff = 120,
},
mappings = {
i = {
["<C-n>"] = actions.cycle_history_next,
["<C-p>"] = actions.cycle_history_prev,
["<C-j>"] = actions.move_selection_next,
["<C-k>"] = actions.move_selection_previous,
},
n = { q = actions.close },
},
},
}
end,
config = require "plugins.configs.telescope",
}

97
lua/plugins/treesitter.lua Normal file
View File

@@ -0,0 +1,97 @@
return {
"nvim-treesitter/nvim-treesitter",
dependencies = {
"JoosepAlviste/nvim-ts-context-commentstring",
"nvim-treesitter/nvim-treesitter-textobjects",
"windwp/nvim-ts-autotag",
},
event = "User AstroFile",
cmd = {
"TSBufDisable",
"TSBufEnable",
"TSBufToggle",
"TSDisable",
"TSEnable",
"TSToggle",
"TSInstall",
"TSInstallInfo",
"TSInstallSync",
"TSModuleInfo",
"TSUninstall",
"TSUpdate",
"TSUpdateSync",
},
build = ":TSUpdate",
opts = {
autotag = { enable = true },
context_commentstring = { enable = true, enable_autocmd = false },
highlight = {
enable = true,
disable = function(_, bufnr) return vim.api.nvim_buf_line_count(bufnr) > 10000 end,
},
incremental_selection = { enable = true },
indent = { enable = true },
textobjects = {
select = {
enable = true,
lookahead = true,
keymaps = {
["ak"] = "@block.outer",
["ik"] = "@block.inner",
["ac"] = "@class.outer",
["ic"] = "@class.inner",
["a?"] = "@conditional.outer",
["i?"] = "@conditional.inner",
["af"] = "@function.outer",
["if"] = "@function.inner",
["al"] = "@loop.outer",
["il"] = "@loop.inner",
["aa"] = "@parameter.outer",
["ia"] = "@parameter.inner",
},
},
move = {
enable = true,
set_jumps = true,
goto_next_start = {
["]k"] = { query = "@block.outer", desc = "Next block start" },
["]c"] = { query = "@class.outer", desc = "Next class start" },
["]f"] = { query = "@function.outer", desc = "Next function start" },
["]a"] = { query = "@parameter.outer", desc = "Next parameter start" },
},
goto_next_end = {
["]k"] = { query = "@block.outer", desc = "Next block end" },
["]c"] = { query = "@class.outer", desc = "Next class end" },
["]f"] = { query = "@function.outer", desc = "Next function end" },
["]a"] = { query = "@parameter.outer", desc = "Next parameter end" },
},
goto_previous_start = {
["[k"] = { query = "@block.outer", desc = "Previous block start" },
["[c"] = { query = "@class.outer", desc = "Previous class start" },
["[f"] = { query = "@function.outer", desc = "Previous function start" },
["[a"] = { query = "@parameter.outer", desc = "Previous parameter start" },
},
goto_previous_end = {
["[K"] = { query = "@block.outer", desc = "Previous block end" },
["[C"] = { query = "@class.outer", desc = "Previous class end" },
["[F"] = { query = "@function.outer", desc = "Previous function end" },
["[A"] = { query = "@parameter.outer", desc = "Previous parameter end" },
},
},
swap = {
enable = true,
swap_next = {
[">k"] = { query = "@block.outer", desc = "Swap next block" },
[">f"] = { query = "@function.outer", desc = "Swap next function" },
[">a"] = { query = "@parameter.inner", desc = "Swap next parameter" },
},
swap_previous = {
["<k"] = { query = "@block.outer", desc = "Swap previous block" },
["<f"] = { query = "@function.outer", desc = "Swap previous function" },
["<a"] = { query = "@parameter.inner", desc = "Swap previous parameter" },
},
},
},
},
config = require "plugins.configs.nvim-treesitter",
}

131
lua/plugins/ui.lua Normal file
View File

@@ -0,0 +1,131 @@
return {
{
"nvim-tree/nvim-web-devicons",
enabled = vim.g.icons_enabled,
opts = {
override = {
default_icon = { icon = require("astronvim.utils").get_icon "DefaultFile" },
deb = { icon = "", name = "Deb" },
lock = { icon = "󰌾", name = "Lock" },
mp3 = { icon = "󰎆", name = "Mp3" },
mp4 = { icon = "", name = "Mp4" },
out = { icon = "", name = "Out" },
["robots.txt"] = { icon = "󰚩", name = "Robots" },
ttf = { icon = "", name = "TrueTypeFont" },
rpm = { icon = "", name = "Rpm" },
woff = { icon = "", name = "WebOpenFontFormat" },
woff2 = { icon = "", name = "WebOpenFontFormat2" },
xz = { icon = "", name = "Xz" },
zip = { icon = "", name = "Zip" },
},
},
},
{
"onsails/lspkind.nvim",
opts = {
mode = "symbol",
symbol_map = {
Array = "󰅪",
Boolean = "⊨",
Class = "󰌗",
Constructor = "",
Key = "󰌆",
Namespace = "󰅪",
Null = "NULL",
Number = "#",
Object = "󰀚",
Package = "󰏗",
Property = "",
Reference = "",
Snippet = "",
String = "󰀬",
TypeParameter = "󰊄",
Unit = "",
},
menu = {},
},
enabled = vim.g.icons_enabled,
config = require "plugins.configs.lspkind",
},
{
"rcarriga/nvim-notify",
init = function() require("astronvim.utils").load_plugin_with_func("nvim-notify", vim, "notify") end,
opts = {
on_open = function(win)
vim.api.nvim_win_set_config(win, { zindex = 1000 })
-- close notification immediately if notifications disabled
if not vim.g.ui_notifications_enabled then vim.api.nvim_win_close(win, true) end
end,
},
config = require "plugins.configs.notify",
},
{
"stevearc/dressing.nvim",
init = function() require("astronvim.utils").load_plugin_with_func("dressing.nvim", vim.ui, { "input", "select" }) end,
opts = {
input = {
default_prompt = "➤ ",
win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" },
},
select = {
backend = { "telescope", "builtin" },
builtin = { win_options = { winhighlight = "Normal:Normal,NormalNC:Normal" } },
},
},
},
{
"NvChad/nvim-colorizer.lua",
event = "User AstroFile",
cmd = { "ColorizerToggle", "ColorizerAttachToBuffer", "ColorizerDetachFromBuffer", "ColorizerReloadAllBuffers" },
opts = { user_default_options = { names = false } },
},
{
"lukas-reineke/indent-blankline.nvim",
event = "User AstroFile",
opts = {
buftype_exclude = {
"nofile",
"terminal",
},
filetype_exclude = {
"help",
"startify",
"aerial",
"alpha",
"dashboard",
"lazy",
"neogitstatus",
"NvimTree",
"neo-tree",
"Trouble",
},
context_patterns = {
"class",
"return",
"function",
"method",
"^if",
"^while",
"jsx_element",
"^for",
"^object",
"^table",
"block",
"arguments",
"if_statement",
"else_clause",
"jsx_element",
"jsx_self_closing_element",
"try_statement",
"catch_clause",
"import_statement",
"operation_type",
},
show_trailing_blankline_indent = false,
use_treesitter = true,
char = "▏",
context_char = "▏",
show_current_context = true,
},
},
}

33
lua/resession/extensions/astronvim.lua Normal file
View File

@@ -0,0 +1,33 @@
local M = {}
M.on_save = function()
-- initiate astronvim data
local data = { last_bufnr = vim.fn.bufnr(), bufnrs = {}, tabs = {} }
-- save tab scoped buffers and buffer numbers from buffer name
for new_tabpage, tabpage in ipairs(vim.api.nvim_list_tabpages()) do
data.tabs[new_tabpage] = vim.t[tabpage].bufs
for _, bufnr in ipairs(data.tabs[new_tabpage]) do
data.bufnrs[vim.api.nvim_buf_get_name(bufnr)] = bufnr
end
end
return data
end
M.on_load = function(data)
-- create map from old buffer numbers to new buffer numbers
local new_bufnrs = {}
for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
local bufname = vim.api.nvim_buf_get_name(bufnr)
if bufname and data.bufnrs[bufname] then new_bufnrs[data.bufnrs[bufname]] = bufnr end
end
-- build new tab scoped buffer lists
for tabpage, tabs in pairs(data.tabs) do
vim.t[tabpage].bufs = vim.tbl_map(function(bufnr) return new_bufnrs[bufnr] end, tabs)
end
require("astronvim.utils").event "BufsUpdated"
if vim.fn.bufnr() ~= new_bufnrs[data.last_bufnr] then vim.cmd.b(new_bufnrs[data.last_bufnr]) end
end
return M

36
lua/user/.github/README.md vendored Normal file
View File

@@ -0,0 +1,36 @@
# AstroNvim User Configuration Example
A user configuration template for [AstroNvim](https://github.com/AstroNvim/AstroNvim)
## 🛠️ Installation
#### Make a backup of your current nvim and shared folder
```shell
mv ~/.config/nvim ~/.config/nvim.bak
mv ~/.local/share/nvim ~/.local/share/nvim.bak
```
#### Clone AstroNvim
```shell
git clone https://github.com/AstroNvim/AstroNvim ~/.config/nvim
```
#### Create a new user repository from this template
Press the "Use this template" button above to create a new repository to store your user configuration.
You can also just clone this repository directly if you do not want to track your user configuration in GitHub.
#### Clone the repository
```shell
git clone https://github.com/<your_user>/<your_repository> ~/.config/nvim/lua/user
```
#### Start Neovim
```shell
nvim
```

7
lua/user/.stylua.toml Normal file
View File

@@ -0,0 +1,7 @@
column_width = 120
line_endings = "Unix"
indent_type = "Spaces"
indent_width = 2
quote_style = "AutoPreferDouble"
call_parentheses = "None"
collapse_simple_statement = "Always"

3
lua/user/highlights/duskfox.lua Normal file
View File

@@ -0,0 +1,3 @@
return { -- a table of overrides/changes to the duskfox theme
Normal = { bg = "#000000" },
}

3
lua/user/highlights/init.lua Normal file
View File

@@ -0,0 +1,3 @@
return { -- this table overrides highlights in all themes
-- Normal = { bg = "#000000" },
}

84
lua/user/init.lua Normal file
View File

@@ -0,0 +1,84 @@
return {
-- Configure AstroNvim updates
updater = {
remote = "origin", -- remote to use
channel = "stable", -- "stable" or "nightly"
version = "latest", -- "latest", tag name, or regex search like "v1.*" to only do updates before v2 (STABLE ONLY)
branch = "nightly", -- branch name (NIGHTLY ONLY)
commit = nil, -- commit hash (NIGHTLY ONLY)
pin_plugins = nil, -- nil, true, false (nil will pin plugins on stable only)
skip_prompts = false, -- skip prompts about breaking changes
show_changelog = true, -- show the changelog after performing an update
auto_quit = false, -- automatically quit the current session after a successful update
remotes = { -- easily add new remotes to track
-- ["remote_name"] = "https://remote_url.come/repo.git", -- full remote url
-- ["remote2"] = "github_user/repo", -- GitHub user/repo shortcut,
-- ["remote3"] = "github_user", -- GitHub user assume AstroNvim fork
},
},
-- Set colorscheme to use
colorscheme = "catppuccin",
-- Diagnostics configuration (for vim.diagnostics.config({...})) when diagnostics are on
diagnostics = {
virtual_text = true,
underline = true,
},
lsp = {
-- customize lsp formatting options
formatting = {
-- control auto formatting on save
format_on_save = {
enabled = true, -- enable or disable format on save globally
allow_filetypes = { -- enable format on save for specified filetypes only
-- "go",
},
ignore_filetypes = { -- disable format on save for specified filetypes
-- "python",
},
},
disabled = { -- disable formatting capabilities for the listed language servers
-- "sumneko_lua",
},
timeout_ms = 1000, -- default format timeout
-- filter = function(client) -- fully override the default formatting function
-- return true
-- end
},
-- enable servers that you already have installed without mason
servers = {
-- "pyright"
},
},
-- Configure require("lazy").setup() options
lazy = {
defaults = { lazy = true },
performance = {
rtp = {
-- customize default disabled vim plugins
disabled_plugins = { "tohtml", "gzip", "matchit", "zipPlugin", "netrwPlugin", "tarPlugin" },
},
},
},
-- This function is run last and is a good place to configuring
-- augroups/autocommands and custom filetypes also this just pure lua so
-- anything that doesn't fit in the normal config locations above can go here
polish = function()
-- Set up custom filetypes
-- vim.filetype.add {
-- extension = {
-- foo = "fooscript",
-- },
-- filename = {
-- ["Foofile"] = "fooscript",
-- },
-- pattern = {
-- ["~/%.config/foo/.*"] = "fooscript",
-- },
-- }
end,
}

38
lua/user/mappings.lua Normal file
View File

@@ -0,0 +1,38 @@
-- Mapping data with "desc" stored directly by vim.keymap.set().
--
-- Please use this mappings table to set keyboard mapping since this is the
-- lower level configuration and more robust one. (which-key will
-- automatically pick-up stored data by this setting.)
local time_format = '%Y-%m-%d %a %H:%M'
return {
-- first key is the mode
n = {
-- second key is the lefthand side of the map
-- mappings seen under group name "Buffer"
["<leader>bn"] = { "<cmd>tabnew<cr>", desc = "New tab" },
["<leader>bD"] = {
function()
require("astronvim.utils.status").heirline.buffer_picker(function(bufnr)
require("astronvim.utils.buffer").close(
bufnr)
end)
end,
desc = "Pick to close",
},
-- tables with the `name` key will be registered with which-key if it's installed
-- this is useful for naming menus
["<leader>b"] = { name = "Buffers" },
-- Insert current time
["<F3>"] = { 'i<C-R>=strftime("' .. time_format .. '")<CR><Esc>' }
},
t = {
-- setting a mapping to false will disable it
-- ["<esc>"] = false,
},
i = {
["<F3>"] = { '<C-R>=strftime("' .. time_format .. '")<CR><Esc>' }
},
}

29
lua/user/options.lua Normal file
View File

@@ -0,0 +1,29 @@
-- set vim options here (vim.<first_key>.<second_key> = value)
return {
opt = {
-- set to true or false etc.
relativenumber = true, -- sets vim.opt.relativenumber
number = true, -- sets vim.opt.number
spell = false, -- sets vim.opt.spell
signcolumn = "auto", -- sets vim.opt.signcolumn to auto
wrap = false, -- sets vim.opt.wrap
},
g = {
mapleader = " ", -- sets vim.g.mapleader
autoformat_enabled = true, -- enable or disable auto formatting at start (lsp.formatting.format_on_save must be enabled)
cmp_enabled = true, -- enable completion at start
autopairs_enabled = true, -- enable autopairs at start
diagnostics_mode = 3, -- set the visibility of diagnostics in the UI (0=off, 1=only show in status line, 2=virtual text off, 3=all on)
icons_enabled = true, -- disable icons in the UI (disable if no nerd font is available, requires :PackerSync after changing)
ui_notifications_enabled = true, -- disable notifications when toggling UI elements
},
}
-- If you need more control, you can use the function()...end notation
-- return function(local_vim)
-- local_vim.opt.relativenumber = true
-- local_vim.g.mapleader = " "
-- local_vim.opt.whichwrap = vim.opt.whichwrap - { 'b', 's' } -- removing option from list
-- local_vim.opt.shortmess = vim.opt.shortmess + { I = true } -- add to option list
--
-- return local_vim
-- end

7
lua/user/plugins/catppuccin.lua Normal file
View File

@@ -0,0 +1,7 @@
return {
"catppuccin/nvim",
name = "catppuccin",
opts = {
flavour = "macchiato",
},
}

9
lua/user/plugins/community.lua Normal file
View File

@@ -0,0 +1,9 @@
return {
-- Add the community repository of plugin specifications
"AstroNvim/astrocommunity",
-- example of imporing a plugin, comment out to use it or add your own
-- available plugins can be found at https://github.com/AstroNvim/astrocommunity
-- { import = "astrocommunity.colorscheme.catppuccin" },
-- { import = "astrocommunity.completion.copilot-lua-cmp" },
}

77
lua/user/plugins/core.lua Normal file
View File

@@ -0,0 +1,77 @@
return {
-- customize alpha options
{
"goolord/alpha-nvim",
opts = function(_, opts)
-- customize the dashboard header
opts.section.header.val = {
" █████ ███████ ████████ ██████ ██████",
"██ ██ ██ ██ ██ ██ ██ ██",
"███████ ███████ ██ ██████ ██ ██",
"██ ██ ██ ██ ██ ██ ██ ██",
"██ ██ ███████ ██ ██ ██ ██████",
" ",
" ███  ██ ██  ██ ██ ███  ███",
" ████  ██ ██  ██ ██ ████  ████",
" ██ ██  ██ ██  ██ ██ ██ ████ ██",
" ██  ██ ██  ██  ██  ██ ██  ██  ██",
" ██   ████   ████   ██ ██      ██",
}
return opts
end,
},
-- You can disable default plugins as follows:
-- { "max397574/better-escape.nvim", enabled = false },
--
-- You can also easily customize additional setup of plugins that is outside of the plugin's setup call
-- {
-- "L3MON4D3/LuaSnip",
-- config = function(plugin, opts)
-- require "plugins.configs.luasnip"(plugin, opts) -- include the default astronvim config that calls the setup call
-- -- add more custom luasnip configuration such as filetype extend or custom snippets
-- local luasnip = require "luasnip"
-- luasnip.filetype_extend("javascript", { "javascriptreact" })
-- end,
-- },
-- {
-- "windwp/nvim-autopairs",
-- config = function(plugin, opts)
-- require "plugins.configs.nvim-autopairs"(plugin, opts) -- include the default astronvim config that calls the setup call
-- -- add more custom autopairs configuration such as custom rules
-- local npairs = require "nvim-autopairs"
-- local Rule = require "nvim-autopairs.rule"
-- local cond = require "nvim-autopairs.conds"
-- npairs.add_rules(
-- {
-- Rule("$", "$", { "tex", "latex" })
-- -- don't add a pair if the next character is %
-- :with_pair(cond.not_after_regex "%%")
-- -- don't add a pair if the previous character is xxx
-- :with_pair(
-- cond.not_before_regex("xxx", 3)
-- )
-- -- don't move right when repeat character
-- :with_move(cond.none())
-- -- don't delete if the next character is xx
-- :with_del(cond.not_after_regex "xx")
-- -- disable adding a newline when you press <cr>
-- :with_cr(cond.none()),
-- },
-- -- disable for .vim files, but it work for another filetypes
-- Rule("a", "a", "-vim")
-- )
-- end,
-- },
-- By adding to the which-key config and using our helper function you can add more which-key registered bindings
-- {
-- "folke/which-key.nvim",
-- config = function(plugin, opts)
-- require "plugins.configs.which-key"(plugin, opts) -- include the default astronvim config that calls the setup call
-- -- Add bindings which show up as group name
-- local wk = require "which-key"
-- wk.register({
-- b = { name = "Buffer" },
-- }, { mode = "n", prefix = "<leader>" })
-- end,
-- },
}

26
lua/user/plugins/mason.lua Normal file
View File

@@ -0,0 +1,26 @@
-- customize mason plugins
return {
-- use mason-lspconfig to configure LSP installations
{
"williamboman/mason-lspconfig.nvim",
-- overrides `require("mason-lspconfig").setup(...)`
opts = {
-- ensure_installed = { "lua_ls" },
},
},
-- use mason-null-ls to configure Formatters/Linter installation for null-ls sources
{
"jay-babu/mason-null-ls.nvim",
-- overrides `require("mason-null-ls").setup(...)`
opts = {
-- ensure_installed = { "prettier", "stylua" },
},
},
{
"jay-babu/mason-nvim-dap.nvim",
-- overrides `require("mason-nvim-dap").setup(...)`
opts = {
-- ensure_installed = { "python" },
},
},
}

17
lua/user/plugins/null-ls.lua Normal file
View File

@@ -0,0 +1,17 @@
return {
"jose-elias-alvarez/null-ls.nvim",
opts = function(_, config)
-- config variable is the default configuration table for the setup function call
-- local null_ls = require "null-ls"
-- Check supported formatters and linters
-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/formatting
-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/diagnostics
config.sources = {
-- Set a formatter
-- null_ls.builtins.formatting.stylua,
-- null_ls.builtins.formatting.prettier,
}
return config -- return final config table
end,
}

6
lua/user/plugins/treesitter.lua Normal file
View File

@@ -0,0 +1,6 @@
return {
"nvim-treesitter/nvim-treesitter",
opts = {
-- ensure_installed = { "lua" },
},
}

12
lua/user/plugins/user.lua Normal file
View File

@@ -0,0 +1,12 @@
return {
-- You can also add new plugins here as well:
-- Add plugins, the lazy syntax
-- "andweeb/presence.nvim",
-- {
-- "ray-x/lsp_signature.nvim",
-- event = "BufRead",
-- config = function()
-- require("lsp_signature").setup()
-- end,
-- },
}