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

Squashed 'users/daniel/configs/system/nvim/nvim/' content from commit f10b473

Browse Source 
git-subtree-dir: users/daniel/configs/system/nvim/nvim
git-subtree-split: f10b4730176b567e15911b3c1a7c5a31c82c8b8e
This commit is contained in:
Daniel Patterson
2023-05-27 20:02:13 +01:00
commit 5c48075076
74 changed files with 7172 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,264 @@
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>", { 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
local group_name = augroup("alpha_settings", { clear = true })
autocmd({ "User", "BufEnter" }, {
desc = "Disable status and tablines for alpha",
group = group_name,
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 = group_name,
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(event)
local filetype = vim.api.nvim_get_option_value("filetype", { buf = event.buf })
if not vim.tbl_contains({ "gitcommit", "gitrebase" }, filetype) then
local save = require("resession").save
save "Last Session"
save(vim.fn.getcwd(), { dir = "dirsession", notify = false })
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)" })

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

@@ -0,0 +1,131 @@
--- ### 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_module = 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_module = module_path end
end
-- if we found a readable lua file, try to load it
if found_module 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
found_module = loaded_module
-- if unsuccessful, throw an error
else
vim.api.nvim_err_writeln("Error loading file: " .. found_module .. "\n\n" .. loaded_module)
end
end
-- return the loaded module or nil if no file found
return found_module
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? table The default settings 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", {}) }
--- the default colorscheme to apply on startup
astronvim.default_colorscheme = astronvim.user_opts("colorscheme", "astrotheme", false)

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

@@ -0,0 +1,60 @@
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" },
{
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
if type(program.cmd) == "string" then program.cmd = { program.cmd } end
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
found = true
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 = "",
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",
}

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

@@ -0,0 +1,45 @@
local lazypath = vim.fn.stdpath "data" .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
local output = vim.fn.system { "git", "clone", "https://github.com/folke/lazy.nvim.git", "--branch=stable", 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",
}))

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

@@ -0,0 +1,435 @@
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" },
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" }
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 = "Delete 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 = "Sort by extension (buffers)" }
maps.n["<leader>bsr"] =
{ function() require("astronvim.utils.buffer").sort "unique_path" end, desc = "Sort by relative path (buffers)" }
maps.n["<leader>bsp"] =
{ function() require("astronvim.utils.buffer").sort "full_path" end, desc = "Sort by full path (buffers)" }
maps.n["<leader>bsi"] =
{ function() require("astronvim.utils.buffer").sort "bufnr" end, desc = "Sort by buffer number (buffers)" }
maps.n["<leader>bsm"] =
{ function() require("astronvim.utils.buffer").sort "modified" end, desc = "Sort by modification (buffers)" }
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 = "Comment line",
}
maps.v["<leader>/"] =
{ "<esc><cmd>lua require('Comment.api').toggle.linewise(vim.fn.visualmode())<cr>", desc = "Toggle comment line" }
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>lD"] = { function() require("telescope.builtin").diagnostics() end, desc = "Search diagnostics" }
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 UI 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))

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

@@ -0,0 +1,70 @@
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 = {
highlighturl_enabled = true, -- highlight URLs by default
mapleader = " ", -- set leader key
autoformat_enabled = true, -- enable or disable auto formatting at start (lsp.formatting.format_on_save must be enabled)
codelens_enabled = true, -- enable or disable automatic codelens refreshing for lsp that support it
lsp_handlers_enabled = true, -- enable or disable default vim.lsp.handlers (hover and signatureHelp)
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)
ui_notifications_enabled = true, -- disable notifications when toggling UI elements
},
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

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

@@ -0,0 +1,178 @@
--- ### 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 = {}
--- 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
--- 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

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

@@ -0,0 +1,180 @@
--- ### 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 the git arguments
---@return string|nil # The result of the command or nil if unsuccessful
function git.cmd(args, ...)
return require("astronvim.utils").cmd("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 if the AstroNvim home is a git repo
---@return string|nil # ~he 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 %s '%s'"):format(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 = ""
if start_hash and end_hash then range = start_hash .. ".." .. end_hash end
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, astronvim.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

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

@@ -0,0 +1,295 @@
--- ### 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 `lspkind` if it is available and return it
---@param kind string The kind of icon in `lspkind` 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 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 }) 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
--- 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
local 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", url_matcher, 15) end
end
--- Run a shell command and capture the output and if the command succeeded or failed
---@param cmd 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)
local wind32_cmd
if vim.fn.has "win32" == 1 then wind32_cmd = { "cmd.exe", "/C", cmd } end
local result = vim.fn.system(wind32_cmd or 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: " .. cmd .. "\nError message:\n" .. result)
end
return success and result:gsub("[\27\155][][()#;?%d]*[A-PRZcf-ntqry=><~]", "") or nil
end
return M

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

@@ -0,0 +1,419 @@
--- ### 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)
local clients = vim.lsp.get_active_clients(filter)
return not tbl_isempty(vim.tbl_map(function(client) return client.server_capabilities[capability] end, clients))
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 capabilities = client.server_capabilities
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 "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 capabilities.codeActionProvider 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 capabilities.codeLensProvider then
add_buffer_autocmd("lsp_codelens_refresh", bufnr, {
events = { "InsertLeave", "BufEnter" },
desc = "Refresh codelens",
callback = function()
if not M.has_capability("codeLensProvider", { 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 capabilities.declarationProvider then
lsp_mappings.n["gD"] = {
function() vim.lsp.buf.declaration() end,
desc = "Declaration of current symbol",
}
end
if capabilities.definitionProvider then
lsp_mappings.n["gd"] = {
function() vim.lsp.buf.definition() end,
desc = "Show the definition of current symbol",
}
end
if capabilities.documentFormattingProvider 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("documentFormattingProvider", { 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 capabilities.documentHighlightProvider then
add_buffer_autocmd("lsp_document_highlight", bufnr, {
{
events = { "CursorHold", "CursorHoldI" },
desc = "highlight references when cursor holds",
callback = function()
if not M.has_capability("documentHighlightProvider", { 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 capabilities.hoverProvider then
lsp_mappings.n["K"] = {
function() vim.lsp.buf.hover() end,
desc = "Hover symbol details",
}
end
if capabilities.implementationProvider then
lsp_mappings.n["gI"] = {
function() vim.lsp.buf.implementation() end,
desc = "Implementation of current symbol",
}
end
if capabilities.referencesProvider 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 capabilities.renameProvider then
lsp_mappings.n["<leader>lr"] = {
function() vim.lsp.buf.rename() end,
desc = "Rename current symbol",
}
end
if capabilities.signatureHelpProvider then
lsp_mappings.n["<leader>lh"] = {
function() vim.lsp.buf.signature_help() end,
desc = "Signature help",
}
end
if capabilities.typeDefinitionProvider then
lsp_mappings.n["gT"] = {
function() vim.lsp.buf.type_definition() end,
desc = "Definition of current type",
}
end
if capabilities.workspaceSymbolProvider then
lsp_mappings.n["<leader>lG"] = { function() vim.lsp.buf.workspace_symbol() end, desc = "Search workspace symbols" }
end
if capabilities.semanticTokensProvider and vim.lsp.semantic_tokens then
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 })
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

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

File diff suppressed because it is too large Load Diff

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

@@ -0,0 +1,222 @@
--- ### 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 function bool2str(bool) return bool and "on" or "off" end
local function ui_notify(str)
if vim.g.ui_notifications_enabled then require("astronvim.utils").notify(str) end
end
--- Toggle notifications for UI toggles
function M.toggle_ui_notifications()
vim.g.ui_notifications_enabled = not vim.g.ui_notifications_enabled
ui_notify(string.format("ui 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
ui_notify(string.format("autopairs %s", bool2str(not autopairs.state.disabled)))
else
ui_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
ui_notify "diagnostics off"
elseif vim.g.diagnostics_mode == 1 then
ui_notify "only status diagnostics"
elseif vim.g.diagnostics_mode == 2 then
ui_notify "virtual text off"
else
ui_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"
ui_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")
ui_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
ui_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
ui_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 = vim.b.semantic_tokens_enabled == false
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)
ui_notify(string.format("Buffer lsp semantic highlighting %s", bool2str(vim.b.semantic_tokens_enabled)))
end
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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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
ui_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"
ui_notify(string.format("foldcolumn=%s", vim.wo.foldcolumn))
end
return M

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

@@ -0,0 +1,322 @@
--- ### 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)
if messages then echo(messages) end
local confirmed = string.lower(vim.fn.input("(y/n)" .. utils.get_icon("DapStopped", 1))) == "y"
echo()
echo()
return confirmed
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
--- 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, auto_quit = false }, 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 " },
{ remote, "Title" },
{ " is currently set to " },
{ current_url, "WarningMsg" },
{ "\nWould you like us to set it to " },
{ url, "String" },
{ "?" },
}
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 source = git.local_head() -- calculate current commit
local target -- calculate target commit
if is_stable then -- if stable get tag commit
local version_search = opts.version or "latest"
opts.version = git.latest_version(git.get_versions(version_search))
if not opts.version then -- continue only if stable version is found
vim.api.nvim_err_writeln("Error finding version: " .. version_search)
return
end
target = git.tag_commit(opts.version)
elseif opts.commit then -- if commit specified use it
target = git.branch_contains(opts.remote, opts.branch, opts.commit) and opts.commit or nil
else -- get most recent commit
target = git.remote_head(opts.remote, opts.branch)
end
if not source or not target then -- continue if current and target commits were found
vim.api.nvim_err_writeln "Error checking for updates"
return
elseif source == target then
echo { { "No updates available", "String" } }
return
elseif -- prompt user if they want to accept update
not opts.skip_prompts
and not confirm_prompt {
{ "Update available to ", "Title" },
{ is_stable and opts.version or target, "String" },
{ "\nUpdating requires a restart, continue?" },
}
then
echo(cancelled_message)
return
else -- perform update
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)
local breaking_prompt = { { "Update contains the following breaking changes:\n", "WarningMsg" } }
vim.list_extend(breaking_prompt, git.pretty_changelog(breaking))
vim.list_extend(breaking_prompt, { { "\nWould you like to continue?" } })
if #breaking > 0 and not opts.skip_prompts and not confirm_prompt(breaking_prompt) 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.\n", "ErrorMsg" },
{ "Reset local files and continue?" },
}
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
require("lazy").sync { wait = true } -- sync new plugin spec changes
utils.event "UpdateComplete"
end
end
return M

52
lua/lazy_snapshot.lua Normal file
View File

@@ -0,0 +1,52 @@
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", commit = "698e75814cd7c56b0dd8af4936bcef2d13807f3c", 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 = "2efaef942ce43c7f0cf61cf11b4791fcea01ce19", optional = true },
{ "famiu/bufdelete.nvim", commit = "8933abc09df6c381d47dc271b1ee5d266541448e", optional = true },
{ "folke/lazy.nvim", version = "^9", optional = true },
{ "folke/neodev.nvim", version = "^2", optional = true },
{ "folke/which-key.nvim", version = "^1", optional = true },
{ "goolord/alpha-nvim", commit = "1838ae926e8d49fe5330d1498ee8289ae2c340bc", 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 = "8a3d2dd7641f75c1b6291311f56454adba79a196", 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 = "77e53bc3bac34cc273be8ed9eb9ab78bcf67fa48", 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 = "570aae82f8c6bc15fb6e559ed7d5a3fd85374329", 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 = "e283ab937e0197b37ec5d8013e49495193407324", optional = true },
{ "nvim-treesitter/nvim-treesitter", commit = "dae928b3bbbcdd3890c61549bdc4c50e1e0d3094", optional = true },
{ "onsails/lspkind.nvim", commit = "57610d5ab560c073c465d6faf0c19f200cb67e6e", optional = true },
{ "rafamadriz/friendly-snippets", commit = "ef6547d2f586e08e071efeebac835e545f3015cc", 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 = "^1", optional = true },
{ "saadparwaiz1/cmp_luasnip", commit = "18095520391186d634a0045dacaa346291096566", optional = true },
{ "stevearc/aerial.nvim", commit = "189bf4cce7f029ca8b3684441dd9d8ca5e6925a4", optional = true },
{ "stevearc/dressing.nvim", commit = "f19cbd56f7f8cad212c58a7285d09c5d9c273896", optional = true },
{ "williamboman/mason-lspconfig.nvim", version = "^1.1", optional = true },
{ "williamboman/mason.nvim", version = "^1", optional = true },
{ "windwp/nvim-autopairs", commit = "7747bbae60074acf0b9e3a4c13950be7a2dff444", optional = true },
{ "windwp/nvim-ts-autotag", commit = "40615e96075c743ef47aaf9de966dc348bec6459", 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",
}

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

@@ -0,0 +1,110 @@
return {
{
"L3MON4D3/LuaSnip",
build = vim.fn.has "win32" ~= 0
and "echo -e 'NOTE: jsregexp is optional, so not a big deal if it fails to build\n'; make install_jsregexp"
or nil,
dependencies = { "rafamadriz/friendly-snippets" },
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")
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 = require("astronvim.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(astronvim.lspkind) 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 status = require "astronvim.utils.status"
local C = 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 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 status.hl.lualine_mode("inactive", C.dark_grey)
local HeirlineNormal = get_hlgroup("HeirlineNormal", { bg = nil }).bg or status.hl.lualine_mode("normal", C.blue)
local HeirlineInsert = get_hlgroup("HeirlineInsert", { bg = nil }).bg or status.hl.lualine_mode("insert", C.green)
local HeirlineVisual = get_hlgroup("HeirlineVisual", { bg = nil }).bg or status.hl.lualine_mode("visual", C.purple)
local HeirlineReplace = get_hlgroup("HeirlineReplace", { bg = nil }).bg
or status.hl.lualine_mode("replace", C.bright_red)
local HeirlineCommand = get_hlgroup("HeirlineCommand", { bg = nil }).bg
or status.hl.lualine_mode("command", C.bright_yellow)
local HeirlineTerminal = get_hlgroup("HeirlineTerminal", { bg = nil }).bg
or status.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 = StatusLine.bg,
tabline_fg = StatusLine.bg,
buffer_fg = Comment.fg,
buffer_path_fg = WinBarNC.fg,
buffer_close_fg = Comment.fg,
buffer_bg = StatusLine.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 = StatusLine.bg,
buffer_picker_fg = Error.fg,
tab_close_fg = Error.fg,
tab_close_bg = StatusLine.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

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

@@ -0,0 +1,41 @@
return function(_, _)
local lsp = require "astronvim.utils.lsp"
local get_icon = require("astronvim.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)
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

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

@@ -0,0 +1,4 @@
return function(_, opts)
astronvim.lspkind = 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

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

@@ -0,0 +1,20 @@
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 = "custom,v:lua.mason_completion.available_package_completion",
})
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

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

@@ -0,0 +1,117 @@
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_valid(bufnr) end,
tab_buf_filter = function(tabpage, bufnr) return vim.tbl_contains(vim.t[tabpage].bufs, bufnr) end,
extensions = { astronvim = {} },
},
},
{ "s1n7ax/nvim-window-picker", opts = { 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" },
},
},
}

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

@@ -0,0 +1,86 @@
return {
"rebelot/heirline.nvim",
event = "BufEnter",
opts = function()
local status = require "astronvim.utils.status"
return {
opts = {
disable_winbar_cb = function(args)
return 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",
}

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

@@ -0,0 +1,72 @@
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 = {
{
"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",
},
}

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

@@ -0,0 +1,127 @@
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, indent_size = 1 },
icon = {
folder_closed = get_icon "FolderClosed",
folder_open = get_icon "FolderOpen",
folder_empty = 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,
},
},
},
}

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

@@ -0,0 +1,50 @@
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
local 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 },
}
-- HACK: remove after Telescope mode issue is resolved: https://github.com/nvim-telescope/telescope.nvim/issues/2501
if vim.fn.has "nvim-0.10" == 1 then
for _, key in ipairs { "<CR>", "<C-x>", "<C-v>", "<C-t>", "<C-q>", "<M-q>" } do
mappings.i[key] = function()
vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Esc>" .. key, true, false, true), "i", false)
end
end
end
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 = mappings,
},
}
end,
config = require "plugins.configs.telescope",
}

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

@@ -0,0 +1,32 @@
return {
"nvim-treesitter/nvim-treesitter",
dependencies = { "windwp/nvim-ts-autotag", "JoosepAlviste/nvim-ts-context-commentstring" },
event = "User AstroFile",
cmd = {
"TSBufDisable",
"TSBufEnable",
"TSBufToggle",
"TSDisable",
"TSEnable",
"TSToggle",
"TSInstall",
"TSInstallInfo",
"TSInstallSync",
"TSModuleInfo",
"TSUninstall",
"TSUpdate",
"TSUpdateSync",
},
build = ":TSUpdate",
opts = {
highlight = {
enable = true,
disable = function(_, bufnr) return vim.api.nvim_buf_line_count(bufnr) > 10000 end,
},
incremental_selection = { enable = true },
indent = { enable = true },
autotag = { enable = true },
context_commentstring = { enable = true, enable_autocmd = false },
},
config = require "plugins.configs.nvim-treesitter",
}

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

@@ -0,0 +1,124 @@
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 = "",
},
},
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 }) 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,
},
},
}

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

@@ -0,0 +1,31 @@
local M = {}
M.on_save = function()
-- initiate astronvim data
local data = { bufnrs = {}, tabs = {} }
-- save tab scoped buffers and buffer numbers from buffer name
for _, tabpage in ipairs(vim.api.nvim_list_tabpages()) do
data.tabs[tabpage] = vim.t[tabpage].bufs
for _, bufnr in ipairs(data.tabs[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 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
end
return M