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

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