Squashed 'users/configs/system/nvim/nvim/' content from commit e088bce2
git-subtree-dir: users/configs/system/nvim/nvim git-subtree-split: e088bce2bd90c0b5c35d13a8615a55455b96294d
This commit is contained in:
228
lua/astronvim/utils/buffer.lua
Normal file
228
lua/astronvim/utils/buffer.lua
Normal file
@@ -0,0 +1,228 @@
|
||||
--- ### AstroNvim Buffer Utilities
|
||||
--
|
||||
-- Buffer management related utility functions
|
||||
--
|
||||
-- This module can be loaded with `local buffer_utils = require "astronvim.utils.buffer"`
|
||||
--
|
||||
-- @module astronvim.utils.buffer
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
-- TODO: Add user configuration table for this once resession is default
|
||||
--- Configuration table for controlling session options
|
||||
M.sessions = {
|
||||
autosave = {
|
||||
last = true, -- auto save last session
|
||||
cwd = true, -- auto save session for each working directory
|
||||
},
|
||||
ignore = {
|
||||
dirs = {}, -- working directories to ignore sessions in
|
||||
filetypes = { "gitcommit", "gitrebase" }, -- filetypes to ignore sessions
|
||||
buftypes = {}, -- buffer types to ignore sessions
|
||||
},
|
||||
}
|
||||
|
||||
--- Check if a buffer is valid
|
||||
---@param bufnr number The buffer to check
|
||||
---@return boolean # Whether the buffer is valid or not
|
||||
function M.is_valid(bufnr)
|
||||
if not bufnr or bufnr < 1 then return false end
|
||||
return vim.api.nvim_buf_is_valid(bufnr) and vim.bo[bufnr].buflisted
|
||||
end
|
||||
|
||||
--- Check if a buffer can be restored
|
||||
---@param bufnr number The buffer to check
|
||||
---@return boolean # Whether the buffer is restorable or not
|
||||
function M.is_restorable(bufnr)
|
||||
if not M.is_valid(bufnr) or vim.api.nvim_get_option_value("bufhidden", { buf = bufnr }) ~= "" then return false end
|
||||
|
||||
local buftype = vim.api.nvim_get_option_value("buftype", { buf = bufnr })
|
||||
if buftype == "" then
|
||||
-- Normal buffer, check if it listed.
|
||||
if not vim.api.nvim_get_option_value("buflisted", { buf = bufnr }) then return false end
|
||||
-- Check if it has a filename.
|
||||
if vim.api.nvim_buf_get_name(bufnr) == "" then return false end
|
||||
end
|
||||
|
||||
if
|
||||
vim.tbl_contains(M.sessions.ignore.filetypes, vim.api.nvim_get_option_value("filetype", { buf = bufnr }))
|
||||
or vim.tbl_contains(M.sessions.ignore.buftypes, vim.api.nvim_get_option_value("buftype", { buf = bufnr }))
|
||||
then
|
||||
return false
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
--- Check if the current buffers form a valid session
|
||||
---@return boolean # Whether the current session of buffers is a valid session
|
||||
function M.is_valid_session()
|
||||
local cwd = vim.fn.getcwd()
|
||||
for _, dir in ipairs(M.sessions.ignore.dirs) do
|
||||
if vim.fn.expand(dir) == cwd then return false end
|
||||
end
|
||||
for _, bufnr in ipairs(vim.api.nvim_list_bufs()) do
|
||||
if M.is_restorable(bufnr) then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
--- Move the current buffer tab n places in the bufferline
|
||||
---@param n number The number of tabs to move the current buffer over by (positive = right, negative = left)
|
||||
function M.move(n)
|
||||
if n == 0 then return end -- if n = 0 then no shifts are needed
|
||||
local bufs = vim.t.bufs -- make temp variable
|
||||
for i, bufnr in ipairs(bufs) do -- loop to find current buffer
|
||||
if bufnr == vim.api.nvim_get_current_buf() then -- found index of current buffer
|
||||
for _ = 0, (n % #bufs) - 1 do -- calculate number of right shifts
|
||||
local new_i = i + 1 -- get next i
|
||||
if i == #bufs then -- if at end, cycle to beginning
|
||||
new_i = 1 -- next i is actually 1 if at the end
|
||||
local val = bufs[i] -- save value
|
||||
table.remove(bufs, i) -- remove from end
|
||||
table.insert(bufs, new_i, val) -- insert at beginning
|
||||
else -- if not at the end,then just do an in place swap
|
||||
bufs[i], bufs[new_i] = bufs[new_i], bufs[i]
|
||||
end
|
||||
i = new_i -- iterate i to next value
|
||||
end
|
||||
break
|
||||
end
|
||||
end
|
||||
vim.t.bufs = bufs -- set buffers
|
||||
require("astronvim.utils").event "BufsUpdated"
|
||||
vim.cmd.redrawtabline() -- redraw tabline
|
||||
end
|
||||
|
||||
--- Navigate left and right by n places in the bufferline
|
||||
-- @param n number The number of tabs to navigate to (positive = right, negative = left)
|
||||
function M.nav(n)
|
||||
local current = vim.api.nvim_get_current_buf()
|
||||
for i, v in ipairs(vim.t.bufs) do
|
||||
if current == v then
|
||||
vim.cmd.b(vim.t.bufs[(i + n - 1) % #vim.t.bufs + 1])
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- Navigate to a specific buffer by its position in the bufferline
|
||||
---@param tabnr number The position of the buffer to navigate to
|
||||
function M.nav_to(tabnr) vim.cmd.b(vim.t.bufs[tabnr]) end
|
||||
|
||||
--- Close a given buffer
|
||||
---@param bufnr? number The buffer to close or the current buffer if not provided
|
||||
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
|
||||
function M.close(bufnr, force)
|
||||
if force == nil then force = false end
|
||||
if require("astronvim.utils").is_available "bufdelete.nvim" then
|
||||
require("bufdelete").bufdelete(bufnr, force)
|
||||
else
|
||||
vim.cmd((force and "bd!" or "confirm bd") .. (bufnr == nil and "" or bufnr))
|
||||
end
|
||||
end
|
||||
|
||||
--- Close all buffers
|
||||
---@param keep_current? boolean Whether or not to keep the current buffer (default: false)
|
||||
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
|
||||
function M.close_all(keep_current, force)
|
||||
if keep_current == nil then keep_current = false end
|
||||
local current = vim.api.nvim_get_current_buf()
|
||||
for _, bufnr in ipairs(vim.t.bufs) do
|
||||
if not keep_current or bufnr ~= current then M.close(bufnr, force) end
|
||||
end
|
||||
end
|
||||
|
||||
--- Close buffers to the left of the current buffer
|
||||
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
|
||||
function M.close_left(force)
|
||||
local current = vim.api.nvim_get_current_buf()
|
||||
for _, bufnr in ipairs(vim.t.bufs) do
|
||||
if bufnr == current then break end
|
||||
M.close(bufnr, force)
|
||||
end
|
||||
end
|
||||
|
||||
--- Close buffers to the right of the current buffer
|
||||
---@param force? boolean Whether or not to foce close the buffers or confirm changes (default: false)
|
||||
function M.close_right(force)
|
||||
local current = vim.api.nvim_get_current_buf()
|
||||
local after_current = false
|
||||
for _, bufnr in ipairs(vim.t.bufs) do
|
||||
if after_current then M.close(bufnr, force) end
|
||||
if bufnr == current then after_current = true end
|
||||
end
|
||||
end
|
||||
|
||||
--- Sort a the buffers in the current tab based on some comparator
|
||||
---@param compare_func string|function a string of a comparator defined in require("astronvim.utils.buffer").comparator or a custom comparator function
|
||||
---@param skip_autocmd boolean|nil whether or not to skip triggering AstroBufsUpdated autocmd event
|
||||
---@return boolean # Whether or not the buffers were sorted
|
||||
function M.sort(compare_func, skip_autocmd)
|
||||
if type(compare_func) == "string" then compare_func = M.comparator[compare_func] end
|
||||
if type(compare_func) == "function" then
|
||||
local bufs = vim.t.bufs
|
||||
table.sort(bufs, compare_func)
|
||||
vim.t.bufs = bufs
|
||||
if not skip_autocmd then require("astronvim.utils").event "BufsUpdated" end
|
||||
vim.cmd.redrawtabline()
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
--- Close the current tab
|
||||
function M.close_tab()
|
||||
if #vim.api.nvim_list_tabpages() > 1 then
|
||||
vim.t.bufs = nil
|
||||
require("astronvim.utils").event "BufsUpdated"
|
||||
vim.cmd.tabclose()
|
||||
end
|
||||
end
|
||||
|
||||
--- A table of buffer comparator functions
|
||||
M.comparator = {}
|
||||
|
||||
local fnamemodify = vim.fn.fnamemodify
|
||||
local function bufinfo(bufnr) return vim.fn.getbufinfo(bufnr)[1] end
|
||||
local function unique_path(bufnr)
|
||||
return require("astronvim.utils.status.provider").unique_path() { bufnr = bufnr }
|
||||
.. fnamemodify(bufinfo(bufnr).name, ":t")
|
||||
end
|
||||
|
||||
--- Comparator of two buffer numbers
|
||||
---@param bufnr_a integer buffer number A
|
||||
---@param bufnr_b integer buffer number B
|
||||
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
|
||||
function M.comparator.bufnr(bufnr_a, bufnr_b) return bufnr_a < bufnr_b end
|
||||
|
||||
--- Comparator of two buffer numbers based on the file extensions
|
||||
---@param bufnr_a integer buffer number A
|
||||
---@param bufnr_b integer buffer number B
|
||||
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
|
||||
function M.comparator.extension(bufnr_a, bufnr_b)
|
||||
return fnamemodify(bufinfo(bufnr_a).name, ":e") < fnamemodify(bufinfo(bufnr_b).name, ":e")
|
||||
end
|
||||
|
||||
--- Comparator of two buffer numbers based on the full path
|
||||
---@param bufnr_a integer buffer number A
|
||||
---@param bufnr_b integer buffer number B
|
||||
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
|
||||
function M.comparator.full_path(bufnr_a, bufnr_b)
|
||||
return fnamemodify(bufinfo(bufnr_a).name, ":p") < fnamemodify(bufinfo(bufnr_b).name, ":p")
|
||||
end
|
||||
|
||||
--- Comparator of two buffers based on their unique path
|
||||
---@param bufnr_a integer buffer number A
|
||||
---@param bufnr_b integer buffer number B
|
||||
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
|
||||
function M.comparator.unique_path(bufnr_a, bufnr_b) return unique_path(bufnr_a) < unique_path(bufnr_b) end
|
||||
|
||||
--- Comparator of two buffers based on modification date
|
||||
---@param bufnr_a integer buffer number A
|
||||
---@param bufnr_b integer buffer number B
|
||||
---@return boolean comparison true if A is sorted before B, false if B should be sorted before A
|
||||
function M.comparator.modified(bufnr_a, bufnr_b) return bufinfo(bufnr_a).lastused > bufinfo(bufnr_b).lastused end
|
||||
|
||||
return M
|
||||
20
lua/astronvim/utils/ffi.lua
Normal file
20
lua/astronvim/utils/ffi.lua
Normal file
@@ -0,0 +1,20 @@
|
||||
-- ### AstroNvim C Extensions
|
||||
|
||||
local ffi = require "ffi"
|
||||
|
||||
-- Custom C extension to get direct fold information from Neovim
|
||||
ffi.cdef [[
|
||||
typedef struct {} Error;
|
||||
typedef struct {} win_T;
|
||||
typedef struct {
|
||||
int start; // line number where deepest fold starts
|
||||
int level; // fold level, when zero other fields are N/A
|
||||
int llevel; // lowest level that starts in v:lnum
|
||||
int lines; // number of lines from v:lnum to end of closed fold
|
||||
} foldinfo_T;
|
||||
foldinfo_T fold_info(win_T* wp, int lnum);
|
||||
win_T *find_window_by_handle(int Window, Error *err);
|
||||
int compute_foldcolumn(win_T *wp, int col);
|
||||
]]
|
||||
|
||||
return ffi
|
||||
189
lua/astronvim/utils/git.lua
Normal file
189
lua/astronvim/utils/git.lua
Normal file
@@ -0,0 +1,189 @@
|
||||
--- ### Git LUA API
|
||||
--
|
||||
-- This module can be loaded with `local git = require "astronvim.utils.git"`
|
||||
--
|
||||
-- @module astronvim.utils.git
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local git = { url = "https://github.com/" }
|
||||
|
||||
local function trim_or_nil(str) return type(str) == "string" and vim.trim(str) or nil end
|
||||
|
||||
--- Run a git command from the AstroNvim installation directory
|
||||
---@param args string|string[] the git arguments
|
||||
---@return string|nil # The result of the command or nil if unsuccessful
|
||||
function git.cmd(args, ...)
|
||||
if type(args) == "string" then args = { args } end
|
||||
return require("astronvim.utils").cmd(vim.list_extend({ "git", "-C", astronvim.install.home }, args), ...)
|
||||
end
|
||||
|
||||
--- Check if the AstroNvim is able to reach the `git` command
|
||||
---@return boolean # The result of running `git --help`
|
||||
function git.available() return vim.fn.executable "git" == 1 end
|
||||
|
||||
--- Check the git client version number
|
||||
---@return table|nil # A table with version information or nil if there is an error
|
||||
function git.git_version()
|
||||
local output = git.cmd({ "--version" }, false)
|
||||
if output then
|
||||
local version_str = output:match "%d+%.%d+%.%d"
|
||||
local major, min, patch = unpack(vim.tbl_map(tonumber, vim.split(version_str, "%.")))
|
||||
return { major = major, min = min, patch = patch, str = version_str }
|
||||
end
|
||||
end
|
||||
|
||||
--- Check if the AstroNvim home is a git repo
|
||||
---@return string|nil # The result of the command
|
||||
function git.is_repo() return git.cmd({ "rev-parse", "--is-inside-work-tree" }, false) end
|
||||
|
||||
--- Fetch git remote
|
||||
---@param remote string the remote to fetch
|
||||
---@return string|nil # The result of the command
|
||||
function git.fetch(remote, ...) return git.cmd({ "fetch", remote }, ...) end
|
||||
|
||||
--- Pull the git repo
|
||||
---@return string|nil # The result of the command
|
||||
function git.pull(...) return git.cmd({ "pull", "--rebase" }, ...) end
|
||||
|
||||
--- Checkout git target
|
||||
---@param dest string the target to checkout
|
||||
---@return string|nil # The result of the command
|
||||
function git.checkout(dest, ...) return git.cmd({ "checkout", dest }, ...) end
|
||||
|
||||
--- Hard reset to a git target
|
||||
-- @param dest the target to hard reset to
|
||||
---@return string|nil # The result of the command
|
||||
function git.hard_reset(dest, ...) return git.cmd({ "reset", "--hard", dest }, ...) end
|
||||
|
||||
--- Check if a branch contains a commit
|
||||
---@param remote string the git remote to check
|
||||
---@param branch string the git branch to check
|
||||
---@param commit string the git commit to check for
|
||||
---@return boolean # The result of the command
|
||||
function git.branch_contains(remote, branch, commit, ...)
|
||||
return git.cmd({ "merge-base", "--is-ancestor", commit, remote .. "/" .. branch }, ...) ~= nil
|
||||
end
|
||||
|
||||
--- Get the remote name for a given branch
|
||||
---@param branch string the git branch to check
|
||||
---@return string|nil # The name of the remote for the given branch
|
||||
function git.branch_remote(branch, ...) return trim_or_nil(git.cmd({ "config", "branch." .. branch .. ".remote" }, ...)) end
|
||||
|
||||
--- Add a git remote
|
||||
---@param remote string the remote to add
|
||||
---@param url string the url of the remote
|
||||
---@return string|nil # The result of the command
|
||||
function git.remote_add(remote, url, ...) return git.cmd({ "remote", "add", remote, url }, ...) end
|
||||
|
||||
--- Update a git remote URL
|
||||
---@param remote string the remote to update
|
||||
---@param url string the new URL of the remote
|
||||
---@return string|nil # The result of the command
|
||||
function git.remote_update(remote, url, ...) return git.cmd({ "remote", "set-url", remote, url }, ...) end
|
||||
|
||||
--- Get the URL of a given git remote
|
||||
---@param remote string the remote to get the URL of
|
||||
---@return string|nil # The url of the remote
|
||||
function git.remote_url(remote, ...) return trim_or_nil(git.cmd({ "remote", "get-url", remote }, ...)) end
|
||||
|
||||
--- Get branches from a git remote
|
||||
---@param remote string the remote to setup branches for
|
||||
---@param branch string the branch to setup
|
||||
---@return string|nil # The result of the command
|
||||
function git.remote_set_branches(remote, branch, ...) return git.cmd({ "remote", "set-branches", remote, branch }, ...) end
|
||||
|
||||
--- Get the current version with git describe including tags
|
||||
---@return string|nil # The current git describe string
|
||||
function git.current_version(...) return trim_or_nil(git.cmd({ "describe", "--tags" }, ...)) end
|
||||
|
||||
--- Get the current branch
|
||||
---@return string|nil # The branch of the AstroNvim installation
|
||||
function git.current_branch(...) return trim_or_nil(git.cmd({ "rev-parse", "--abbrev-ref", "HEAD" }, ...)) end
|
||||
|
||||
--- Verify a reference
|
||||
---@return string|nil # The referenced commit
|
||||
function git.ref_verify(ref, ...) return trim_or_nil(git.cmd({ "rev-parse", "--verify", ref }, ...)) end
|
||||
|
||||
--- Get the current head of the git repo
|
||||
---@return string|nil # the head string
|
||||
function git.local_head(...) return trim_or_nil(git.cmd({ "rev-parse", "HEAD" }, ...)) end
|
||||
|
||||
--- Get the current head of a git remote
|
||||
---@param remote string the remote to check
|
||||
---@param branch string the branch to check
|
||||
---@return string|nil # The head string of the remote branch
|
||||
function git.remote_head(remote, branch, ...)
|
||||
return trim_or_nil(git.cmd({ "rev-list", "-n", "1", remote .. "/" .. branch }, ...))
|
||||
end
|
||||
|
||||
--- Get the commit hash of a given tag
|
||||
---@param tag string the tag to resolve
|
||||
---@return string|nil # The commit hash of a git tag
|
||||
function git.tag_commit(tag, ...) return trim_or_nil(git.cmd({ "rev-list", "-n", "1", tag }, ...)) end
|
||||
|
||||
--- Get the commit log between two commit hashes
|
||||
---@param start_hash? string the start commit hash
|
||||
---@param end_hash? string the end commit hash
|
||||
---@return string[] # An array like table of commit messages
|
||||
function git.get_commit_range(start_hash, end_hash, ...)
|
||||
local range = start_hash and end_hash and start_hash .. ".." .. end_hash or nil
|
||||
local log = git.cmd({ "log", "--no-merges", '--pretty="format:[%h] %s"', range }, ...)
|
||||
return log and vim.fn.split(log, "\n") or {}
|
||||
end
|
||||
|
||||
--- Get a list of all tags with a regex filter
|
||||
---@param search? string a regex to search the tags with (defaults to "v*" for version tags)
|
||||
---@return string[] # An array like table of tags that match the search
|
||||
function git.get_versions(search, ...)
|
||||
local tags = git.cmd({ "tag", "-l", "--sort=version:refname", search == "latest" and "v*" or search }, ...)
|
||||
return tags and vim.fn.split(tags, "\n") or {}
|
||||
end
|
||||
|
||||
--- Get the latest version of a list of versions
|
||||
---@param versions? table a list of versions to search (defaults to all versions available)
|
||||
---@return string|nil # The latest version from the array
|
||||
function git.latest_version(versions, ...)
|
||||
if not versions then versions = git.get_versions(...) end
|
||||
return versions[#versions]
|
||||
end
|
||||
|
||||
--- Parse a remote url
|
||||
---@param str string the remote to parse to a full git url
|
||||
---@return string # The full git url for the given remote string
|
||||
function git.parse_remote_url(str)
|
||||
return vim.fn.match(str, require("astronvim.utils").url_matcher) == -1
|
||||
and git.url .. str .. (vim.fn.match(str, "/") == -1 and "/AstroNvim.git" or ".git")
|
||||
or str
|
||||
end
|
||||
|
||||
--- Check if a Conventional Commit commit message is breaking or not
|
||||
---@param commit string a commit message
|
||||
---@return boolean true if the message is breaking, false if the commit message is not breaking
|
||||
function git.is_breaking(commit) return vim.fn.match(commit, "\\[.*\\]\\s\\+\\w\\+\\((\\w\\+)\\)\\?!:") ~= -1 end
|
||||
|
||||
--- Get a list of breaking commits from commit messages using Conventional Commit standard
|
||||
---@param commits string[] an array like table of commit messages
|
||||
---@return string[] # An array like table of commits that are breaking
|
||||
function git.breaking_changes(commits) return vim.tbl_filter(git.is_breaking, commits) end
|
||||
|
||||
--- Generate a table of commit messages for neovim's echo API with highlighting
|
||||
---@param commits string[] an array like table of commit messages
|
||||
---@return string[][] # An array like table of echo messages to provide to nvim_echo or astronvim.echo
|
||||
function git.pretty_changelog(commits)
|
||||
local changelog = {}
|
||||
for _, commit in ipairs(commits) do
|
||||
local hash, type, msg = commit:match "(%[.*%])(.*:)(.*)"
|
||||
if hash and type and msg then
|
||||
vim.list_extend(changelog, {
|
||||
{ hash, "DiffText" },
|
||||
{ type, git.is_breaking(commit) and "DiffDelete" or "DiffChange" },
|
||||
{ msg },
|
||||
{ "\n" },
|
||||
})
|
||||
end
|
||||
end
|
||||
return changelog
|
||||
end
|
||||
|
||||
return git
|
||||
321
lua/astronvim/utils/init.lua
Normal file
321
lua/astronvim/utils/init.lua
Normal file
@@ -0,0 +1,321 @@
|
||||
--- ### AstroNvim Utilities
|
||||
--
|
||||
-- Various utility functions to use within AstroNvim and user configurations.
|
||||
--
|
||||
-- This module can be loaded with `local utils = require "astronvim.utils"`
|
||||
--
|
||||
-- @module astronvim.utils
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
--- Merge extended options with a default table of options
|
||||
---@param default? table The default table that you want to merge into
|
||||
---@param opts? table The new options that should be merged with the default table
|
||||
---@return table # The merged table
|
||||
function M.extend_tbl(default, opts)
|
||||
opts = opts or {}
|
||||
return default and vim.tbl_deep_extend("force", default, opts) or opts
|
||||
end
|
||||
|
||||
--- Partially reload AstroNvim user settings. Includes core vim options, mappings, and highlights. This is an experimental feature and may lead to instabilities until restart.
|
||||
---@param quiet? boolean Whether or not to notify on completion of reloading
|
||||
---@return boolean # True if the reload was successful, False otherwise
|
||||
function M.reload(quiet)
|
||||
local core_modules = { "astronvim.bootstrap", "astronvim.options", "astronvim.mappings" }
|
||||
local modules = vim.tbl_filter(function(module) return module:find "^user%." end, vim.tbl_keys(package.loaded))
|
||||
|
||||
vim.tbl_map(require("plenary.reload").reload_module, vim.list_extend(modules, core_modules))
|
||||
|
||||
local success = true
|
||||
for _, module in ipairs(core_modules) do
|
||||
local status_ok, fault = pcall(require, module)
|
||||
if not status_ok then
|
||||
vim.api.nvim_err_writeln("Failed to load " .. module .. "\n\n" .. fault)
|
||||
success = false
|
||||
end
|
||||
end
|
||||
if not quiet then -- if not quiet, then notify of result
|
||||
if success then
|
||||
M.notify("AstroNvim successfully reloaded", vim.log.levels.INFO)
|
||||
else
|
||||
M.notify("Error reloading AstroNvim...", vim.log.levels.ERROR)
|
||||
end
|
||||
end
|
||||
vim.cmd.doautocmd "ColorScheme"
|
||||
return success
|
||||
end
|
||||
|
||||
--- Insert one or more values into a list like table and maintain that you do not insert non-unique values (THIS MODIFIES `lst`)
|
||||
---@param lst any[]|nil The list like table that you want to insert into
|
||||
---@param vals any|any[] Either a list like table of values to be inserted or a single value to be inserted
|
||||
---@return any[] # The modified list like table
|
||||
function M.list_insert_unique(lst, vals)
|
||||
if not lst then lst = {} end
|
||||
assert(vim.tbl_islist(lst), "Provided table is not a list like table")
|
||||
if not vim.tbl_islist(vals) then vals = { vals } end
|
||||
local added = {}
|
||||
vim.tbl_map(function(v) added[v] = true end, lst)
|
||||
for _, val in ipairs(vals) do
|
||||
if not added[val] then
|
||||
table.insert(lst, val)
|
||||
added[val] = true
|
||||
end
|
||||
end
|
||||
return lst
|
||||
end
|
||||
|
||||
--- Call function if a condition is met
|
||||
---@param func function The function to run
|
||||
---@param condition boolean # Whether to run the function or not
|
||||
---@return any|nil result # the result of the function running or nil
|
||||
function M.conditional_func(func, condition, ...)
|
||||
-- if the condition is true or no condition is provided, evaluate the function with the rest of the parameters and return the result
|
||||
if condition and type(func) == "function" then return func(...) end
|
||||
end
|
||||
|
||||
--- Get an icon from the AstroNvim internal icons if it is available and return it
|
||||
---@param kind string The kind of icon in astronvim.icons to retrieve
|
||||
---@param padding? integer Padding to add to the end of the icon
|
||||
---@param no_fallback? boolean Whether or not to disable fallback to text icon
|
||||
---@return string icon
|
||||
function M.get_icon(kind, padding, no_fallback)
|
||||
if not vim.g.icons_enabled and no_fallback then return "" end
|
||||
local icon_pack = vim.g.icons_enabled and "icons" or "text_icons"
|
||||
if not M[icon_pack] then
|
||||
M.icons = astronvim.user_opts("icons", require "astronvim.icons.nerd_font")
|
||||
M.text_icons = astronvim.user_opts("text_icons", require "astronvim.icons.text")
|
||||
end
|
||||
local icon = M[icon_pack] and M[icon_pack][kind]
|
||||
return icon and icon .. string.rep(" ", padding or 0) or ""
|
||||
end
|
||||
|
||||
--- Get a icon spinner table if it is available in the AstroNvim icons. Icons in format `kind1`,`kind2`, `kind3`, ...
|
||||
---@param kind string The kind of icon to check for sequential entries of
|
||||
---@return string[]|nil spinners # A collected table of spinning icons in sequential order or nil if none exist
|
||||
function M.get_spinner(kind, ...)
|
||||
local spinner = {}
|
||||
repeat
|
||||
local icon = M.get_icon(("%s%d"):format(kind, #spinner + 1), ...)
|
||||
if icon ~= "" then table.insert(spinner, icon) end
|
||||
until not icon or icon == ""
|
||||
if #spinner > 0 then return spinner end
|
||||
end
|
||||
|
||||
--- Get highlight properties for a given highlight name
|
||||
---@param name string The highlight group name
|
||||
---@param fallback? table The fallback highlight properties
|
||||
---@return table properties # the highlight group properties
|
||||
function M.get_hlgroup(name, fallback)
|
||||
if vim.fn.hlexists(name) == 1 then
|
||||
local hl
|
||||
if vim.api.nvim_get_hl then -- check for new neovim 0.9 API
|
||||
hl = vim.api.nvim_get_hl(0, { name = name, link = false })
|
||||
if not hl.fg then hl.fg = "NONE" end
|
||||
if not hl.bg then hl.bg = "NONE" end
|
||||
else
|
||||
hl = vim.api.nvim_get_hl_by_name(name, vim.o.termguicolors)
|
||||
if not hl.foreground then hl.foreground = "NONE" end
|
||||
if not hl.background then hl.background = "NONE" end
|
||||
hl.fg, hl.bg = hl.foreground, hl.background
|
||||
hl.ctermfg, hl.ctermbg = hl.fg, hl.bg
|
||||
hl.sp = hl.special
|
||||
end
|
||||
return hl
|
||||
end
|
||||
return fallback or {}
|
||||
end
|
||||
|
||||
--- Serve a notification with a title of AstroNvim
|
||||
---@param msg string The notification body
|
||||
---@param type number|nil The type of the notification (:help vim.log.levels)
|
||||
---@param opts? table The nvim-notify options to use (:help notify-options)
|
||||
function M.notify(msg, type, opts)
|
||||
vim.schedule(function() vim.notify(msg, type, M.extend_tbl({ title = "AstroNvim" }, opts)) end)
|
||||
end
|
||||
|
||||
--- Trigger an AstroNvim user event
|
||||
---@param event string The event name to be appended to Astro
|
||||
function M.event(event)
|
||||
vim.schedule(function() vim.api.nvim_exec_autocmds("User", { pattern = "Astro" .. event, modeline = false }) end)
|
||||
end
|
||||
|
||||
--- Open a URL under the cursor with the current operating system
|
||||
---@param path string The path of the file to open with the system opener
|
||||
function M.system_open(path)
|
||||
local cmd
|
||||
if vim.fn.has "win32" == 1 and vim.fn.executable "explorer" == 1 then
|
||||
cmd = { "cmd.exe", "/K", "explorer" }
|
||||
elseif vim.fn.has "unix" == 1 and vim.fn.executable "xdg-open" == 1 then
|
||||
cmd = { "xdg-open" }
|
||||
elseif (vim.fn.has "mac" == 1 or vim.fn.has "unix" == 1) and vim.fn.executable "open" == 1 then
|
||||
cmd = { "open" }
|
||||
end
|
||||
if not cmd then M.notify("Available system opening tool not found!", vim.log.levels.ERROR) end
|
||||
vim.fn.jobstart(vim.fn.extend(cmd, { path or vim.fn.expand "<cfile>" }), { detach = true })
|
||||
end
|
||||
|
||||
--- Toggle a user terminal if it exists, if not then create a new one and save it
|
||||
---@param opts string|table A terminal command string or a table of options for Terminal:new() (Check toggleterm.nvim documentation for table format)
|
||||
function M.toggle_term_cmd(opts)
|
||||
local terms = astronvim.user_terminals
|
||||
-- if a command string is provided, create a basic table for Terminal:new() options
|
||||
if type(opts) == "string" then opts = { cmd = opts, hidden = true } end
|
||||
local num = vim.v.count > 0 and vim.v.count or 1
|
||||
-- if terminal doesn't exist yet, create it
|
||||
if not terms[opts.cmd] then terms[opts.cmd] = {} end
|
||||
if not terms[opts.cmd][num] then
|
||||
if not opts.count then opts.count = vim.tbl_count(terms) * 100 + num end
|
||||
if not opts.on_exit then opts.on_exit = function() terms[opts.cmd][num] = nil end end
|
||||
terms[opts.cmd][num] = require("toggleterm.terminal").Terminal:new(opts)
|
||||
end
|
||||
-- toggle the terminal
|
||||
terms[opts.cmd][num]:toggle()
|
||||
end
|
||||
|
||||
--- Create a button entity to use with the alpha dashboard
|
||||
---@param sc string The keybinding string to convert to a button
|
||||
---@param txt string The explanation text of what the keybinding does
|
||||
---@return table # A button entity table for an alpha configuration
|
||||
function M.alpha_button(sc, txt)
|
||||
-- replace <leader> in shortcut text with LDR for nicer printing
|
||||
local sc_ = sc:gsub("%s", ""):gsub("LDR", "<leader>")
|
||||
-- if the leader is set, replace the text with the actual leader key for nicer printing
|
||||
if vim.g.mapleader then sc = sc:gsub("LDR", vim.g.mapleader == " " and "SPC" or vim.g.mapleader) end
|
||||
-- return the button entity to display the correct text and send the correct keybinding on press
|
||||
return {
|
||||
type = "button",
|
||||
val = txt,
|
||||
on_press = function()
|
||||
local key = vim.api.nvim_replace_termcodes(sc_, true, false, true)
|
||||
vim.api.nvim_feedkeys(key, "normal", false)
|
||||
end,
|
||||
opts = {
|
||||
position = "center",
|
||||
text = txt,
|
||||
shortcut = sc,
|
||||
cursor = 5,
|
||||
width = 36,
|
||||
align_shortcut = "right",
|
||||
hl = "DashboardCenter",
|
||||
hl_shortcut = "DashboardShortcut",
|
||||
},
|
||||
}
|
||||
end
|
||||
|
||||
--- Check if a plugin is defined in lazy. Useful with lazy loading when a plugin is not necessarily loaded yet
|
||||
---@param plugin string The plugin to search for
|
||||
---@return boolean available # Whether the plugin is available
|
||||
function M.is_available(plugin)
|
||||
local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
|
||||
return lazy_config_avail and lazy_config.plugins[plugin] ~= nil
|
||||
end
|
||||
|
||||
--- Resolve the options table for a given plugin with lazy
|
||||
---@param plugin string The plugin to search for
|
||||
---@return table opts # The plugin options
|
||||
function M.plugin_opts(plugin)
|
||||
local lazy_config_avail, lazy_config = pcall(require, "lazy.core.config")
|
||||
local lazy_plugin_avail, lazy_plugin = pcall(require, "lazy.core.plugin")
|
||||
local opts = {}
|
||||
if lazy_config_avail and lazy_plugin_avail then
|
||||
local spec = lazy_config.spec.plugins[plugin]
|
||||
if spec then opts = lazy_plugin.values(spec, "opts") end
|
||||
end
|
||||
return opts
|
||||
end
|
||||
|
||||
--- A helper function to wrap a module function to require a plugin before running
|
||||
---@param plugin string The plugin to call `require("lazy").load` with
|
||||
---@param module table The system module where the functions live (e.g. `vim.ui`)
|
||||
---@param func_names string|string[] The functions to wrap in the given module (e.g. `{ "ui", "select }`)
|
||||
function M.load_plugin_with_func(plugin, module, func_names)
|
||||
if type(func_names) == "string" then func_names = { func_names } end
|
||||
for _, func in ipairs(func_names) do
|
||||
local old_func = module[func]
|
||||
module[func] = function(...)
|
||||
module[func] = old_func
|
||||
require("lazy").load { plugins = { plugin } }
|
||||
module[func](...)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- Register queued which-key mappings
|
||||
function M.which_key_register()
|
||||
if M.which_key_queue then
|
||||
local wk_avail, wk = pcall(require, "which-key")
|
||||
if wk_avail then
|
||||
for mode, registration in pairs(M.which_key_queue) do
|
||||
wk.register(registration, { mode = mode })
|
||||
end
|
||||
M.which_key_queue = nil
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- Table based API for setting keybindings
|
||||
---@param map_table table A nested table where the first key is the vim mode, the second key is the key to map, and the value is the function to set the mapping to
|
||||
---@param base? table A base set of options to set on every keybinding
|
||||
function M.set_mappings(map_table, base)
|
||||
-- iterate over the first keys for each mode
|
||||
base = base or {}
|
||||
for mode, maps in pairs(map_table) do
|
||||
-- iterate over each keybinding set in the current mode
|
||||
for keymap, options in pairs(maps) do
|
||||
-- build the options for the command accordingly
|
||||
if options then
|
||||
local cmd = options
|
||||
local keymap_opts = base
|
||||
if type(options) == "table" then
|
||||
cmd = options[1]
|
||||
keymap_opts = vim.tbl_deep_extend("force", keymap_opts, options)
|
||||
keymap_opts[1] = nil
|
||||
end
|
||||
if not cmd or keymap_opts.name then -- if which-key mapping, queue it
|
||||
if not M.which_key_queue then M.which_key_queue = {} end
|
||||
if not M.which_key_queue[mode] then M.which_key_queue[mode] = {} end
|
||||
M.which_key_queue[mode][keymap] = keymap_opts
|
||||
else -- if not which-key mapping, set it
|
||||
vim.keymap.set(mode, keymap, cmd, keymap_opts)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if package.loaded["which-key"] then M.which_key_register() end -- if which-key is loaded already, register
|
||||
end
|
||||
|
||||
--- regex used for matching a valid URL/URI string
|
||||
M.url_matcher =
|
||||
"\\v\\c%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)%([&:#*@~%_\\-=?!+;/0-9a-z]+%(%([.;/?]|[.][.]+)[&:#*@~%_\\-=?!+/0-9a-z]+|:\\d+|,%(%(%(h?ttps?|ftp|file|ssh|git)://|[a-z]+[@][a-z]+[.][a-z]+:)@![0-9a-z]+))*|\\([&:#*@~%_\\-=?!+;/.0-9a-z]*\\)|\\[[&:#*@~%_\\-=?!+;/.0-9a-z]*\\]|\\{%([&:#*@~%_\\-=?!+;/.0-9a-z]*|\\{[&:#*@~%_\\-=?!+;/.0-9a-z]*})\\})+"
|
||||
|
||||
--- Delete the syntax matching rules for URLs/URIs if set
|
||||
function M.delete_url_match()
|
||||
for _, match in ipairs(vim.fn.getmatches()) do
|
||||
if match.group == "HighlightURL" then vim.fn.matchdelete(match.id) end
|
||||
end
|
||||
end
|
||||
|
||||
--- Add syntax matching rules for highlighting URLs/URIs
|
||||
function M.set_url_match()
|
||||
M.delete_url_match()
|
||||
if vim.g.highlighturl_enabled then vim.fn.matchadd("HighlightURL", M.url_matcher, 15) end
|
||||
end
|
||||
|
||||
--- Run a shell command and capture the output and if the command succeeded or failed
|
||||
---@param cmd string|string[] The terminal command to execute
|
||||
---@param show_error? boolean Whether or not to show an unsuccessful command as an error to the user
|
||||
---@return string|nil # The result of a successfully executed command or nil
|
||||
function M.cmd(cmd, show_error)
|
||||
if type(cmd) == "string" then cmd = { cmd } end
|
||||
if vim.fn.has "win32" == 1 then cmd = vim.list_extend({ "cmd.exe", "/C" }, cmd) end
|
||||
local result = vim.fn.system(cmd)
|
||||
local success = vim.api.nvim_get_vvar "shell_error" == 0
|
||||
if not success and (show_error == nil or show_error) then
|
||||
vim.api.nvim_err_writeln(("Error running command %s\nError message:\n%s"):format(table.concat(cmd, " "), result))
|
||||
end
|
||||
return success and result:gsub("[\27\155][][()#;?%d]*[A-PRZcf-ntqry=><~]", "") or nil
|
||||
end
|
||||
|
||||
return M
|
||||
448
lua/astronvim/utils/lsp.lua
Normal file
448
lua/astronvim/utils/lsp.lua
Normal file
@@ -0,0 +1,448 @@
|
||||
--- ### AstroNvim LSP Utils
|
||||
--
|
||||
-- LSP related utility functions to use within AstroNvim and user configurations.
|
||||
--
|
||||
-- This module can be loaded with `local lsp_utils = require("astronvim.utils.lsp")`
|
||||
--
|
||||
-- @module astronvim.utils.lsp
|
||||
-- @see astronvim.utils
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
local tbl_contains = vim.tbl_contains
|
||||
local tbl_isempty = vim.tbl_isempty
|
||||
local user_opts = astronvim.user_opts
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local conditional_func = utils.conditional_func
|
||||
local is_available = utils.is_available
|
||||
local extend_tbl = utils.extend_tbl
|
||||
|
||||
local server_config = "lsp.config."
|
||||
local setup_handlers = user_opts("lsp.setup_handlers", {
|
||||
function(server, opts) require("lspconfig")[server].setup(opts) end,
|
||||
})
|
||||
|
||||
M.diagnostics = { [0] = {}, {}, {}, {} }
|
||||
|
||||
M.setup_diagnostics = function(signs)
|
||||
local default_diagnostics = astronvim.user_opts("diagnostics", {
|
||||
virtual_text = true,
|
||||
signs = { active = signs },
|
||||
update_in_insert = true,
|
||||
underline = true,
|
||||
severity_sort = true,
|
||||
float = {
|
||||
focused = false,
|
||||
style = "minimal",
|
||||
border = "rounded",
|
||||
source = "always",
|
||||
header = "",
|
||||
prefix = "",
|
||||
},
|
||||
})
|
||||
M.diagnostics = {
|
||||
-- diagnostics off
|
||||
[0] = extend_tbl(
|
||||
default_diagnostics,
|
||||
{ underline = false, virtual_text = false, signs = false, update_in_insert = false }
|
||||
),
|
||||
-- status only
|
||||
extend_tbl(default_diagnostics, { virtual_text = false, signs = false }),
|
||||
-- virtual text off, signs on
|
||||
extend_tbl(default_diagnostics, { virtual_text = false }),
|
||||
-- all diagnostics on
|
||||
default_diagnostics,
|
||||
}
|
||||
|
||||
vim.diagnostic.config(M.diagnostics[vim.g.diagnostics_mode])
|
||||
end
|
||||
|
||||
M.formatting = user_opts("lsp.formatting", { format_on_save = { enabled = true }, disabled = {} })
|
||||
if type(M.formatting.format_on_save) == "boolean" then
|
||||
M.formatting.format_on_save = { enabled = M.formatting.format_on_save }
|
||||
end
|
||||
|
||||
M.format_opts = vim.deepcopy(M.formatting)
|
||||
M.format_opts.disabled = nil
|
||||
M.format_opts.format_on_save = nil
|
||||
M.format_opts.filter = function(client)
|
||||
local filter = M.formatting.filter
|
||||
local disabled = M.formatting.disabled or {}
|
||||
-- check if client is fully disabled or filtered by function
|
||||
return not (vim.tbl_contains(disabled, client.name) or (type(filter) == "function" and not filter(client)))
|
||||
end
|
||||
|
||||
--- Helper function to set up a given server with the Neovim LSP client
|
||||
---@param server string The name of the server to be setup
|
||||
M.setup = function(server)
|
||||
-- if server doesn't exist, set it up from user server definition
|
||||
local config_avail, config = pcall(require, "lspconfig.server_configurations." .. server)
|
||||
if not config_avail or not config.default_config then
|
||||
local server_definition = user_opts(server_config .. server)
|
||||
if server_definition.cmd then require("lspconfig.configs")[server] = { default_config = server_definition } end
|
||||
end
|
||||
local opts = M.config(server)
|
||||
local setup_handler = setup_handlers[server] or setup_handlers[1]
|
||||
if not vim.tbl_contains(astronvim.lsp.skip_setup, server) and setup_handler then setup_handler(server, opts) end
|
||||
end
|
||||
|
||||
--- Helper function to check if any active LSP clients given a filter provide a specific capability
|
||||
---@param capability string The server capability to check for (example: "documentFormattingProvider")
|
||||
---@param filter vim.lsp.get_active_clients.filter|nil (table|nil) A table with
|
||||
--- key-value pairs used to filter the returned clients.
|
||||
--- The available keys are:
|
||||
--- - id (number): Only return clients with the given id
|
||||
--- - bufnr (number): Only return clients attached to this buffer
|
||||
--- - name (string): Only return clients with the given name
|
||||
---@return boolean # Whether or not any of the clients provide the capability
|
||||
function M.has_capability(capability, filter)
|
||||
for _, client in ipairs(vim.lsp.get_active_clients(filter)) do
|
||||
if client.supports_method(capability) then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local function add_buffer_autocmd(augroup, bufnr, autocmds)
|
||||
if not vim.tbl_islist(autocmds) then autocmds = { autocmds } end
|
||||
local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
|
||||
if not cmds_found or vim.tbl_isempty(cmds) then
|
||||
vim.api.nvim_create_augroup(augroup, { clear = false })
|
||||
for _, autocmd in ipairs(autocmds) do
|
||||
local events = autocmd.events
|
||||
autocmd.events = nil
|
||||
autocmd.group = augroup
|
||||
autocmd.buffer = bufnr
|
||||
vim.api.nvim_create_autocmd(events, autocmd)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local function del_buffer_autocmd(augroup, bufnr)
|
||||
local cmds_found, cmds = pcall(vim.api.nvim_get_autocmds, { group = augroup, buffer = bufnr })
|
||||
if cmds_found then vim.tbl_map(function(cmd) vim.api.nvim_del_autocmd(cmd.id) end, cmds) end
|
||||
end
|
||||
|
||||
--- The `on_attach` function used by AstroNvim
|
||||
---@param client table The LSP client details when attaching
|
||||
---@param bufnr number The buffer that the LSP client is attaching to
|
||||
M.on_attach = function(client, bufnr)
|
||||
local lsp_mappings = {
|
||||
n = {
|
||||
["<leader>ld"] = {
|
||||
function() vim.diagnostic.open_float() end,
|
||||
desc = "Hover diagnostics",
|
||||
},
|
||||
["[d"] = {
|
||||
function() vim.diagnostic.goto_prev() end,
|
||||
desc = "Previous diagnostic",
|
||||
},
|
||||
["]d"] = {
|
||||
function() vim.diagnostic.goto_next() end,
|
||||
desc = "Next diagnostic",
|
||||
},
|
||||
["gl"] = {
|
||||
function() vim.diagnostic.open_float() end,
|
||||
desc = "Hover diagnostics",
|
||||
},
|
||||
},
|
||||
v = {},
|
||||
}
|
||||
|
||||
if is_available "telescope.nvim" then
|
||||
lsp_mappings.n["<leader>lD"] =
|
||||
{ function() require("telescope.builtin").diagnostics() end, desc = "Search diagnostics" }
|
||||
end
|
||||
|
||||
if is_available "mason-lspconfig.nvim" then
|
||||
lsp_mappings.n["<leader>li"] = { "<cmd>LspInfo<cr>", desc = "LSP information" }
|
||||
end
|
||||
|
||||
if is_available "null-ls.nvim" then
|
||||
lsp_mappings.n["<leader>lI"] = { "<cmd>NullLsInfo<cr>", desc = "Null-ls information" }
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/codeAction" then
|
||||
lsp_mappings.n["<leader>la"] = {
|
||||
function() vim.lsp.buf.code_action() end,
|
||||
desc = "LSP code action",
|
||||
}
|
||||
lsp_mappings.v["<leader>la"] = lsp_mappings.n["<leader>la"]
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/codeLens" then
|
||||
add_buffer_autocmd("lsp_codelens_refresh", bufnr, {
|
||||
events = { "InsertLeave", "BufEnter" },
|
||||
desc = "Refresh codelens",
|
||||
callback = function()
|
||||
if not M.has_capability("textDocument/codeLens", { bufnr = bufnr }) then
|
||||
del_buffer_autocmd("lsp_codelens_refresh", bufnr)
|
||||
return
|
||||
end
|
||||
if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
|
||||
end,
|
||||
})
|
||||
if vim.g.codelens_enabled then vim.lsp.codelens.refresh() end
|
||||
lsp_mappings.n["<leader>ll"] = {
|
||||
function() vim.lsp.codelens.refresh() end,
|
||||
desc = "LSP CodeLens refresh",
|
||||
}
|
||||
lsp_mappings.n["<leader>lL"] = {
|
||||
function() vim.lsp.codelens.run() end,
|
||||
desc = "LSP CodeLens run",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/declaration" then
|
||||
lsp_mappings.n["gD"] = {
|
||||
function() vim.lsp.buf.declaration() end,
|
||||
desc = "Declaration of current symbol",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/definition" then
|
||||
lsp_mappings.n["gd"] = {
|
||||
function() vim.lsp.buf.definition() end,
|
||||
desc = "Show the definition of current symbol",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/formatting" and not tbl_contains(M.formatting.disabled, client.name) then
|
||||
lsp_mappings.n["<leader>lf"] = {
|
||||
function() vim.lsp.buf.format(M.format_opts) end,
|
||||
desc = "Format buffer",
|
||||
}
|
||||
lsp_mappings.v["<leader>lf"] = lsp_mappings.n["<leader>lf"]
|
||||
|
||||
vim.api.nvim_buf_create_user_command(
|
||||
bufnr,
|
||||
"Format",
|
||||
function() vim.lsp.buf.format(M.format_opts) end,
|
||||
{ desc = "Format file with LSP" }
|
||||
)
|
||||
local autoformat = M.formatting.format_on_save
|
||||
local filetype = vim.api.nvim_get_option_value("filetype", { buf = bufnr })
|
||||
if
|
||||
autoformat.enabled
|
||||
and (tbl_isempty(autoformat.allow_filetypes or {}) or tbl_contains(autoformat.allow_filetypes, filetype))
|
||||
and (tbl_isempty(autoformat.ignore_filetypes or {}) or not tbl_contains(autoformat.ignore_filetypes, filetype))
|
||||
then
|
||||
add_buffer_autocmd("lsp_auto_format", bufnr, {
|
||||
events = "BufWritePre",
|
||||
desc = "autoformat on save",
|
||||
callback = function()
|
||||
if not M.has_capability("textDocument/formatting", { bufnr = bufnr }) then
|
||||
del_buffer_autocmd("lsp_auto_format", bufnr)
|
||||
return
|
||||
end
|
||||
local autoformat_enabled = vim.b.autoformat_enabled
|
||||
if autoformat_enabled == nil then autoformat_enabled = vim.g.autoformat_enabled end
|
||||
if autoformat_enabled and ((not autoformat.filter) or autoformat.filter(bufnr)) then
|
||||
vim.lsp.buf.format(extend_tbl(M.format_opts, { bufnr = bufnr }))
|
||||
end
|
||||
end,
|
||||
})
|
||||
lsp_mappings.n["<leader>uf"] = {
|
||||
function() require("astronvim.utils.ui").toggle_buffer_autoformat() end,
|
||||
desc = "Toggle autoformatting (buffer)",
|
||||
}
|
||||
lsp_mappings.n["<leader>uF"] = {
|
||||
function() require("astronvim.utils.ui").toggle_autoformat() end,
|
||||
desc = "Toggle autoformatting (global)",
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/documentHighlight" then
|
||||
add_buffer_autocmd("lsp_document_highlight", bufnr, {
|
||||
{
|
||||
events = { "CursorHold", "CursorHoldI" },
|
||||
desc = "highlight references when cursor holds",
|
||||
callback = function()
|
||||
if not M.has_capability("textDocument/documentHighlight", { bufnr = bufnr }) then
|
||||
del_buffer_autocmd("lsp_document_highlight", bufnr)
|
||||
return
|
||||
end
|
||||
vim.lsp.buf.document_highlight()
|
||||
end,
|
||||
},
|
||||
{
|
||||
events = { "CursorMoved", "CursorMovedI" },
|
||||
desc = "clear references when cursor moves",
|
||||
callback = function() vim.lsp.buf.clear_references() end,
|
||||
},
|
||||
})
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/hover" then
|
||||
lsp_mappings.n["K"] = {
|
||||
function() vim.lsp.buf.hover() end,
|
||||
desc = "Hover symbol details",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/implementation" then
|
||||
lsp_mappings.n["gI"] = {
|
||||
function() vim.lsp.buf.implementation() end,
|
||||
desc = "Implementation of current symbol",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/inlayHint" then
|
||||
if vim.b.inlay_hints_enabled == nil then vim.b.inlay_hints_enabled = vim.g.inlay_hints_enabled end
|
||||
-- TODO: remove check after dropping support for Neovim v0.9
|
||||
if vim.lsp.buf.inlay_hint then
|
||||
if vim.b.inlay_hints_enabled then vim.lsp.buf.inlay_hint(bufnr, true) end
|
||||
lsp_mappings.n["<leader>uH"] = {
|
||||
function() require("astronvim.utils.ui").toggle_buffer_inlay_hints(bufnr) end,
|
||||
desc = "Toggle LSP inlay hints (buffer)",
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/references" then
|
||||
lsp_mappings.n["gr"] = {
|
||||
function() vim.lsp.buf.references() end,
|
||||
desc = "References of current symbol",
|
||||
}
|
||||
lsp_mappings.n["<leader>lR"] = {
|
||||
function() vim.lsp.buf.references() end,
|
||||
desc = "Search references",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/rename" then
|
||||
lsp_mappings.n["<leader>lr"] = {
|
||||
function() vim.lsp.buf.rename() end,
|
||||
desc = "Rename current symbol",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/signatureHelp" then
|
||||
lsp_mappings.n["<leader>lh"] = {
|
||||
function() vim.lsp.buf.signature_help() end,
|
||||
desc = "Signature help",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "textDocument/typeDefinition" then
|
||||
lsp_mappings.n["gT"] = {
|
||||
function() vim.lsp.buf.type_definition() end,
|
||||
desc = "Definition of current type",
|
||||
}
|
||||
end
|
||||
|
||||
if client.supports_method "workspace/symbol" then
|
||||
lsp_mappings.n["<leader>lG"] = { function() vim.lsp.buf.workspace_symbol() end, desc = "Search workspace symbols" }
|
||||
end
|
||||
|
||||
if
|
||||
(
|
||||
client.supports_method "textDocument/semanticTokens/full"
|
||||
or client.supports_method "textDocument/semanticTokens/full/delta"
|
||||
) and vim.lsp.semantic_tokens
|
||||
then
|
||||
if vim.b.semantic_tokens_enabled == nil then vim.b.semantic_tokens_enabled = vim.g.semantic_tokens_enabled end
|
||||
vim.lsp.semantic_tokens[vim.b.semantic_tokens_enabled and "start" or "stop"](bufnr, client.id)
|
||||
lsp_mappings.n["<leader>uY"] = {
|
||||
function() require("astronvim.utils.ui").toggle_buffer_semantic_tokens(bufnr) end,
|
||||
desc = "Toggle LSP semantic highlight (buffer)",
|
||||
}
|
||||
end
|
||||
|
||||
if is_available "telescope.nvim" then -- setup telescope mappings if available
|
||||
if lsp_mappings.n.gd then lsp_mappings.n.gd[1] = function() require("telescope.builtin").lsp_definitions() end end
|
||||
if lsp_mappings.n.gI then
|
||||
lsp_mappings.n.gI[1] = function() require("telescope.builtin").lsp_implementations() end
|
||||
end
|
||||
if lsp_mappings.n.gr then lsp_mappings.n.gr[1] = function() require("telescope.builtin").lsp_references() end end
|
||||
if lsp_mappings.n["<leader>lR"] then
|
||||
lsp_mappings.n["<leader>lR"][1] = function() require("telescope.builtin").lsp_references() end
|
||||
end
|
||||
if lsp_mappings.n.gT then
|
||||
lsp_mappings.n.gT[1] = function() require("telescope.builtin").lsp_type_definitions() end
|
||||
end
|
||||
if lsp_mappings.n["<leader>lG"] then
|
||||
lsp_mappings.n["<leader>lG"][1] = function()
|
||||
vim.ui.input({ prompt = "Symbol Query: " }, function(query)
|
||||
if query then require("telescope.builtin").lsp_workspace_symbols { query = query } end
|
||||
end)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if not vim.tbl_isempty(lsp_mappings.v) then
|
||||
lsp_mappings.v["<leader>l"] = { desc = (vim.g.icons_enabled and " " or "") .. "LSP" }
|
||||
end
|
||||
utils.set_mappings(user_opts("lsp.mappings", lsp_mappings), { buffer = bufnr })
|
||||
|
||||
for id, _ in pairs(astronvim.lsp.progress) do -- clear lingering progress messages
|
||||
if not next(vim.lsp.get_active_clients { id = tonumber(id:match "^%d+") }) then astronvim.lsp.progress[id] = nil end
|
||||
end
|
||||
|
||||
local on_attach_override = user_opts("lsp.on_attach", nil, false)
|
||||
conditional_func(on_attach_override, true, client, bufnr)
|
||||
end
|
||||
|
||||
--- The default AstroNvim LSP capabilities
|
||||
M.capabilities = vim.lsp.protocol.make_client_capabilities()
|
||||
M.capabilities.textDocument.completion.completionItem.documentationFormat = { "markdown", "plaintext" }
|
||||
M.capabilities.textDocument.completion.completionItem.snippetSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.preselectSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.insertReplaceSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.labelDetailsSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.deprecatedSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.commitCharactersSupport = true
|
||||
M.capabilities.textDocument.completion.completionItem.tagSupport = { valueSet = { 1 } }
|
||||
M.capabilities.textDocument.completion.completionItem.resolveSupport =
|
||||
{ properties = { "documentation", "detail", "additionalTextEdits" } }
|
||||
M.capabilities.textDocument.foldingRange = { dynamicRegistration = false, lineFoldingOnly = true }
|
||||
M.capabilities = user_opts("lsp.capabilities", M.capabilities)
|
||||
M.flags = user_opts "lsp.flags"
|
||||
|
||||
--- Get the server configuration for a given language server to be provided to the server's `setup()` call
|
||||
---@param server_name string The name of the server
|
||||
---@return table # The table of LSP options used when setting up the given language server
|
||||
function M.config(server_name)
|
||||
local server = require("lspconfig")[server_name]
|
||||
local lsp_opts = extend_tbl(
|
||||
extend_tbl(server.document_config.default_config, server),
|
||||
{ capabilities = M.capabilities, flags = M.flags }
|
||||
)
|
||||
if server_name == "jsonls" then -- by default add json schemas
|
||||
local schemastore_avail, schemastore = pcall(require, "schemastore")
|
||||
if schemastore_avail then
|
||||
lsp_opts.settings = { json = { schemas = schemastore.json.schemas(), validate = { enable = true } } }
|
||||
end
|
||||
end
|
||||
if server_name == "yamlls" then -- by default add yaml schemas
|
||||
local schemastore_avail, schemastore = pcall(require, "schemastore")
|
||||
if schemastore_avail then lsp_opts.settings = { yaml = { schemas = schemastore.yaml.schemas() } } end
|
||||
end
|
||||
if server_name == "lua_ls" then -- by default initialize neodev and disable third party checking
|
||||
pcall(require, "neodev")
|
||||
lsp_opts.before_init = function(param, config)
|
||||
if vim.b.neodev_enabled then
|
||||
for _, astronvim_config in ipairs(astronvim.supported_configs) do
|
||||
if param.rootPath:match(astronvim_config) then
|
||||
table.insert(config.settings.Lua.workspace.library, astronvim.install.home .. "/lua")
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
lsp_opts.settings = { Lua = { workspace = { checkThirdParty = false } } }
|
||||
end
|
||||
local opts = user_opts(server_config .. server_name, lsp_opts)
|
||||
local old_on_attach = server.on_attach
|
||||
local user_on_attach = opts.on_attach
|
||||
opts.on_attach = function(client, bufnr)
|
||||
conditional_func(old_on_attach, true, client, bufnr)
|
||||
M.on_attach(client, bufnr)
|
||||
conditional_func(user_on_attach, true, client, bufnr)
|
||||
end
|
||||
return opts
|
||||
end
|
||||
|
||||
return M
|
||||
119
lua/astronvim/utils/mason.lua
Normal file
119
lua/astronvim/utils/mason.lua
Normal file
@@ -0,0 +1,119 @@
|
||||
--- ### Mason Utils
|
||||
--
|
||||
-- Mason related utility functions to use within AstroNvim and user configurations.
|
||||
--
|
||||
-- This module can be loaded with `local mason_utils = require("astronvim.utils.mason")`
|
||||
--
|
||||
-- @module astronvim.utils.mason
|
||||
-- @see astronvim.utils
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local notify = utils.notify
|
||||
local astroevent = utils.event
|
||||
|
||||
--- Update specified mason packages, or just update the registries if no packages are listed
|
||||
---@param pkg_names? string|string[] The package names as defined in Mason (Not mason-lspconfig or mason-null-ls) if the value is nil then it will just update the registries
|
||||
---@param auto_install? boolean whether or not to install a package that is not currently installed (default: True)
|
||||
function M.update(pkg_names, auto_install)
|
||||
pkg_names = pkg_names or {}
|
||||
if type(pkg_names) == "string" then pkg_names = { pkg_names } end
|
||||
if auto_install == nil then auto_install = true end
|
||||
local registry_avail, registry = pcall(require, "mason-registry")
|
||||
if not registry_avail then
|
||||
vim.api.nvim_err_writeln "Unable to access mason registry"
|
||||
return
|
||||
end
|
||||
|
||||
registry.update(vim.schedule_wrap(function(success, updated_registries)
|
||||
if success then
|
||||
local count = #updated_registries
|
||||
if vim.tbl_count(pkg_names) == 0 then
|
||||
notify(("Successfully updated %d %s."):format(count, count == 1 and "registry" or "registries"))
|
||||
end
|
||||
for _, pkg_name in ipairs(pkg_names) do
|
||||
local pkg_avail, pkg = pcall(registry.get_package, pkg_name)
|
||||
if not pkg_avail then
|
||||
notify(("Mason: %s is not available"):format(pkg_name), vim.log.levels.ERROR)
|
||||
else
|
||||
if not pkg:is_installed() then
|
||||
if auto_install then
|
||||
notify(("Mason: Installing %s"):format(pkg.name))
|
||||
pkg:install()
|
||||
else
|
||||
notify(("Mason: %s not installed"):format(pkg.name), vim.log.levels.WARN)
|
||||
end
|
||||
else
|
||||
pkg:check_new_version(function(update_available, version)
|
||||
if update_available then
|
||||
notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
|
||||
pkg:install():on("closed", function() notify(("Mason: Updated %s"):format(pkg.name)) end)
|
||||
else
|
||||
notify(("Mason: No updates available for %s"):format(pkg.name))
|
||||
end
|
||||
end)
|
||||
end
|
||||
end
|
||||
end
|
||||
else
|
||||
notify(("Failed to update registries: %s"):format(updated_registries), vim.log.levels.ERROR)
|
||||
end
|
||||
end))
|
||||
end
|
||||
|
||||
--- Update all packages in Mason
|
||||
function M.update_all()
|
||||
local registry_avail, registry = pcall(require, "mason-registry")
|
||||
if not registry_avail then
|
||||
vim.api.nvim_err_writeln "Unable to access mason registry"
|
||||
return
|
||||
end
|
||||
|
||||
notify "Mason: Checking for package updates..."
|
||||
registry.update(vim.schedule_wrap(function(success, updated_registries)
|
||||
if success then
|
||||
local installed_pkgs = registry.get_installed_packages()
|
||||
local running = #installed_pkgs
|
||||
local no_pkgs = running == 0
|
||||
|
||||
if no_pkgs then
|
||||
notify "Mason: No updates available"
|
||||
astroevent "MasonUpdateCompleted"
|
||||
else
|
||||
local updated = false
|
||||
for _, pkg in ipairs(installed_pkgs) do
|
||||
pkg:check_new_version(function(update_available, version)
|
||||
if update_available then
|
||||
updated = true
|
||||
notify(("Mason: Updating %s to %s"):format(pkg.name, version.latest_version))
|
||||
pkg:install():on("closed", function()
|
||||
running = running - 1
|
||||
if running == 0 then
|
||||
notify "Mason: Update Complete"
|
||||
astroevent "MasonUpdateCompleted"
|
||||
end
|
||||
end)
|
||||
else
|
||||
running = running - 1
|
||||
if running == 0 then
|
||||
if updated then
|
||||
notify "Mason: Update Complete"
|
||||
else
|
||||
notify "Mason: No updates available"
|
||||
end
|
||||
astroevent "MasonUpdateCompleted"
|
||||
end
|
||||
end
|
||||
end)
|
||||
end
|
||||
end
|
||||
else
|
||||
notify(("Failed to update registries: %s"):format(updated_registries), vim.log.levels.ERROR)
|
||||
end
|
||||
end))
|
||||
end
|
||||
|
||||
return M
|
||||
10
lua/astronvim/utils/status.lua
Normal file
10
lua/astronvim/utils/status.lua
Normal file
@@ -0,0 +1,10 @@
|
||||
return {
|
||||
component = require "astronvim.utils.status.component",
|
||||
condition = require "astronvim.utils.status.condition",
|
||||
env = require "astronvim.utils.status.env",
|
||||
heirline = require "astronvim.utils.status.heirline",
|
||||
hl = require "astronvim.utils.status.hl",
|
||||
init = require "astronvim.utils.status.init",
|
||||
provider = require "astronvim.utils.status.provider",
|
||||
utils = require "astronvim.utils.status.utils",
|
||||
}
|
||||
435
lua/astronvim/utils/status/component.lua
Normal file
435
lua/astronvim/utils/status/component.lua
Normal file
@@ -0,0 +1,435 @@
|
||||
--- ### AstroNvim Status Components
|
||||
--
|
||||
-- Statusline related component functions to use with Heirline
|
||||
--
|
||||
-- This module can be loaded with `local component = require "astronvim.utils.status.component"`
|
||||
--
|
||||
-- @module astronvim.utils.status.component
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local condition = require "astronvim.utils.status.condition"
|
||||
local env = require "astronvim.utils.status.env"
|
||||
local hl = require "astronvim.utils.status.hl"
|
||||
local init = require "astronvim.utils.status.init"
|
||||
local provider = require "astronvim.utils.status.provider"
|
||||
local status_utils = require "astronvim.utils.status.utils"
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local buffer_utils = require "astronvim.utils.buffer"
|
||||
local extend_tbl = utils.extend_tbl
|
||||
local get_icon = utils.get_icon
|
||||
local is_available = utils.is_available
|
||||
|
||||
--- A Heirline component for filling in the empty space of the bar
|
||||
---@param opts? table options for configuring the other fields of the heirline component
|
||||
---@return table # The heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.fill()
|
||||
function M.fill(opts) return extend_tbl({ provider = provider.fill() }, opts) end
|
||||
|
||||
--- A function to build a set of children components for an entire file information section
|
||||
---@param opts? table options for configuring file_icon, filename, filetype, file_modified, file_read_only, and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.file_info()
|
||||
function M.file_info(opts)
|
||||
opts = extend_tbl({
|
||||
file_icon = { hl = hl.file_icon "statusline", padding = { left = 1, right = 1 } },
|
||||
filename = {},
|
||||
file_modified = { padding = { left = 1 } },
|
||||
file_read_only = { padding = { left = 1 } },
|
||||
surround = { separator = "left", color = "file_info_bg", condition = condition.has_filetype },
|
||||
hl = hl.get_attributes "file_info",
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, {
|
||||
"file_icon",
|
||||
"unique_path",
|
||||
"filename",
|
||||
"filetype",
|
||||
"file_modified",
|
||||
"file_read_only",
|
||||
"close_button",
|
||||
}))
|
||||
end
|
||||
|
||||
--- A function with different file_info defaults specifically for use in the tabline
|
||||
---@param opts? table options for configuring file_icon, filename, filetype, file_modified, file_read_only, and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.tabline_file_info()
|
||||
function M.tabline_file_info(opts)
|
||||
return M.file_info(extend_tbl({
|
||||
file_icon = {
|
||||
condition = function(self) return not self._show_picker end,
|
||||
hl = hl.file_icon "tabline",
|
||||
},
|
||||
unique_path = {
|
||||
hl = function(self) return hl.get_attributes(self.tab_type .. "_path") end,
|
||||
},
|
||||
close_button = {
|
||||
hl = function(self) return hl.get_attributes(self.tab_type .. "_close") end,
|
||||
padding = { left = 1, right = 1 },
|
||||
on_click = {
|
||||
callback = function(_, minwid) buffer_utils.close(minwid) end,
|
||||
minwid = function(self) return self.bufnr end,
|
||||
name = "heirline_tabline_close_buffer_callback",
|
||||
},
|
||||
},
|
||||
padding = { left = 1, right = 1 },
|
||||
hl = function(self)
|
||||
local tab_type = self.tab_type
|
||||
if self._show_picker and self.tab_type ~= "buffer_active" then tab_type = "buffer_visible" end
|
||||
return hl.get_attributes(tab_type)
|
||||
end,
|
||||
surround = false,
|
||||
}, opts))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for an entire navigation section
|
||||
---@param opts? table options for configuring ruler, percentage, scrollbar, and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.nav()
|
||||
function M.nav(opts)
|
||||
opts = extend_tbl({
|
||||
ruler = {},
|
||||
percentage = { padding = { left = 1 } },
|
||||
scrollbar = { padding = { left = 1 }, hl = { fg = "scrollbar" } },
|
||||
surround = { separator = "right", color = "nav_bg" },
|
||||
hl = hl.get_attributes "nav",
|
||||
update = { "CursorMoved", "CursorMovedI", "BufEnter" },
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "ruler", "percentage", "scrollbar" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for information shown in the cmdline
|
||||
---@param opts? table options for configuring macro recording, search count, and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.cmd_info()
|
||||
function M.cmd_info(opts)
|
||||
opts = extend_tbl({
|
||||
macro_recording = {
|
||||
icon = { kind = "MacroRecording", padding = { right = 1 } },
|
||||
condition = condition.is_macro_recording,
|
||||
update = {
|
||||
"RecordingEnter",
|
||||
"RecordingLeave",
|
||||
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
|
||||
},
|
||||
},
|
||||
search_count = {
|
||||
icon = { kind = "Search", padding = { right = 1 } },
|
||||
padding = { left = 1 },
|
||||
condition = condition.is_hlsearch,
|
||||
},
|
||||
showcmd = {
|
||||
padding = { left = 1 },
|
||||
condition = condition.is_statusline_showcmd,
|
||||
},
|
||||
surround = {
|
||||
separator = "center",
|
||||
color = "cmd_info_bg",
|
||||
condition = function()
|
||||
return condition.is_hlsearch() or condition.is_macro_recording() or condition.is_statusline_showcmd()
|
||||
end,
|
||||
},
|
||||
condition = function() return vim.opt.cmdheight:get() == 0 end,
|
||||
hl = hl.get_attributes "cmd_info",
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "macro_recording", "search_count", "showcmd" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for a mode section
|
||||
---@param opts? table options for configuring mode_text, paste, spell, and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.mode { mode_text = true }
|
||||
function M.mode(opts)
|
||||
opts = extend_tbl({
|
||||
mode_text = false,
|
||||
paste = false,
|
||||
spell = false,
|
||||
surround = { separator = "left", color = hl.mode_bg },
|
||||
hl = hl.get_attributes "mode",
|
||||
update = {
|
||||
"ModeChanged",
|
||||
pattern = "*:*",
|
||||
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
|
||||
},
|
||||
}, opts)
|
||||
if not opts["mode_text"] then opts.str = { str = " " } end
|
||||
return M.builder(status_utils.setup_providers(opts, { "mode_text", "str", "paste", "spell" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for an LSP breadcrumbs section
|
||||
---@param opts? table options for configuring breadcrumbs and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.breadcumbs()
|
||||
function M.breadcrumbs(opts)
|
||||
opts = extend_tbl({ padding = { left = 1 }, condition = condition.aerial_available, update = "CursorMoved" }, opts)
|
||||
opts.init = init.breadcrumbs(opts)
|
||||
return opts
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for the current file path
|
||||
---@param opts? table options for configuring path and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.separated_path()
|
||||
function M.separated_path(opts)
|
||||
opts = extend_tbl({ padding = { left = 1 }, update = { "BufEnter", "DirChanged" } }, opts)
|
||||
opts.init = init.separated_path(opts)
|
||||
return opts
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for a git branch section
|
||||
---@param opts? table options for configuring git branch and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.git_branch()
|
||||
function M.git_branch(opts)
|
||||
opts = extend_tbl({
|
||||
git_branch = { icon = { kind = "GitBranch", padding = { right = 1 } } },
|
||||
surround = { separator = "left", color = "git_branch_bg", condition = condition.is_git_repo },
|
||||
hl = hl.get_attributes "git_branch",
|
||||
on_click = {
|
||||
name = "heirline_branch",
|
||||
callback = function()
|
||||
if is_available "telescope.nvim" then
|
||||
vim.defer_fn(function() require("telescope.builtin").git_branches() end, 100)
|
||||
end
|
||||
end,
|
||||
},
|
||||
update = { "User", pattern = "GitSignsUpdate" },
|
||||
init = init.update_events { "BufEnter" },
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "git_branch" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for a git difference section
|
||||
---@param opts? table options for configuring git changes and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.git_diff()
|
||||
function M.git_diff(opts)
|
||||
opts = extend_tbl({
|
||||
added = { icon = { kind = "GitAdd", padding = { left = 1, right = 1 } } },
|
||||
changed = { icon = { kind = "GitChange", padding = { left = 1, right = 1 } } },
|
||||
removed = { icon = { kind = "GitDelete", padding = { left = 1, right = 1 } } },
|
||||
hl = hl.get_attributes "git_diff",
|
||||
on_click = {
|
||||
name = "heirline_git",
|
||||
callback = function()
|
||||
if is_available "telescope.nvim" then
|
||||
vim.defer_fn(function() require("telescope.builtin").git_status() end, 100)
|
||||
end
|
||||
end,
|
||||
},
|
||||
surround = { separator = "left", color = "git_diff_bg", condition = condition.git_changed },
|
||||
update = { "User", pattern = "GitSignsUpdate" },
|
||||
init = init.update_events { "BufEnter" },
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "added", "changed", "removed" }, function(p_opts, p)
|
||||
local out = status_utils.build_provider(p_opts, p)
|
||||
if out then
|
||||
out.provider = "git_diff"
|
||||
out.opts.type = p
|
||||
if out.hl == nil then out.hl = { fg = "git_" .. p } end
|
||||
end
|
||||
return out
|
||||
end))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for a diagnostics section
|
||||
---@param opts? table options for configuring diagnostic providers and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.diagnostics()
|
||||
function M.diagnostics(opts)
|
||||
opts = extend_tbl({
|
||||
ERROR = { icon = { kind = "DiagnosticError", padding = { left = 1, right = 1 } } },
|
||||
WARN = { icon = { kind = "DiagnosticWarn", padding = { left = 1, right = 1 } } },
|
||||
INFO = { icon = { kind = "DiagnosticInfo", padding = { left = 1, right = 1 } } },
|
||||
HINT = { icon = { kind = "DiagnosticHint", padding = { left = 1, right = 1 } } },
|
||||
surround = { separator = "left", color = "diagnostics_bg", condition = condition.has_diagnostics },
|
||||
hl = hl.get_attributes "diagnostics",
|
||||
on_click = {
|
||||
name = "heirline_diagnostic",
|
||||
callback = function()
|
||||
if is_available "telescope.nvim" then
|
||||
vim.defer_fn(function() require("telescope.builtin").diagnostics() end, 100)
|
||||
end
|
||||
end,
|
||||
},
|
||||
update = { "DiagnosticChanged", "BufEnter" },
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "ERROR", "WARN", "INFO", "HINT" }, function(p_opts, p)
|
||||
local out = status_utils.build_provider(p_opts, p)
|
||||
if out then
|
||||
out.provider = "diagnostics"
|
||||
out.opts.severity = p
|
||||
if out.hl == nil then out.hl = { fg = "diag_" .. p } end
|
||||
end
|
||||
return out
|
||||
end))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for a Treesitter section
|
||||
---@param opts? table options for configuring diagnostic providers and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.treesitter()
|
||||
function M.treesitter(opts)
|
||||
opts = extend_tbl({
|
||||
str = { str = "TS", icon = { kind = "ActiveTS", padding = { right = 1 } } },
|
||||
surround = {
|
||||
separator = "right",
|
||||
color = "treesitter_bg",
|
||||
condition = condition.treesitter_available,
|
||||
},
|
||||
hl = hl.get_attributes "treesitter",
|
||||
update = { "OptionSet", pattern = "syntax" },
|
||||
init = init.update_events { "BufEnter" },
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "str" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of children components for an LSP section
|
||||
---@param opts? table options for configuring lsp progress and client_name providers and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.lsp()
|
||||
function M.lsp(opts)
|
||||
opts = extend_tbl({
|
||||
lsp_progress = {
|
||||
str = "",
|
||||
padding = { right = 1 },
|
||||
update = {
|
||||
"User",
|
||||
pattern = "AstroLspProgress",
|
||||
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
|
||||
},
|
||||
},
|
||||
lsp_client_names = {
|
||||
str = "LSP",
|
||||
update = {
|
||||
"LspAttach",
|
||||
"LspDetach",
|
||||
"BufEnter",
|
||||
callback = vim.schedule_wrap(function() vim.cmd.redrawstatus() end),
|
||||
},
|
||||
icon = { kind = "ActiveLSP", padding = { right = 2 } },
|
||||
},
|
||||
hl = hl.get_attributes "lsp",
|
||||
surround = { separator = "right", color = "lsp_bg", condition = condition.lsp_attached },
|
||||
on_click = {
|
||||
name = "heirline_lsp",
|
||||
callback = function()
|
||||
vim.defer_fn(function() vim.cmd.LspInfo() end, 100)
|
||||
end,
|
||||
},
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(
|
||||
opts,
|
||||
{ "lsp_progress", "lsp_client_names" },
|
||||
function(p_opts, p, i)
|
||||
return p_opts
|
||||
and {
|
||||
flexible = i,
|
||||
status_utils.build_provider(p_opts, provider[p](p_opts)),
|
||||
status_utils.build_provider(p_opts, provider.str(p_opts)),
|
||||
}
|
||||
or false
|
||||
end
|
||||
))
|
||||
end
|
||||
|
||||
--- A function to build a set of components for a foldcolumn section in a statuscolumn
|
||||
---@param opts? table options for configuring foldcolumn and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.foldcolumn()
|
||||
function M.foldcolumn(opts)
|
||||
opts = extend_tbl({
|
||||
foldcolumn = { padding = { right = 1 } },
|
||||
condition = condition.foldcolumn_enabled,
|
||||
on_click = {
|
||||
name = "fold_click",
|
||||
callback = function(...)
|
||||
local char = status_utils.statuscolumn_clickargs(...).char
|
||||
local fillchars = vim.opt_local.fillchars:get()
|
||||
if char == (fillchars.foldopen or get_icon "FoldOpened") then
|
||||
vim.cmd "norm! zc"
|
||||
elseif char == (fillchars.foldcolse or get_icon "FoldClosed") then
|
||||
vim.cmd "norm! zo"
|
||||
end
|
||||
end,
|
||||
},
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "foldcolumn" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of components for a numbercolumn section in statuscolumn
|
||||
---@param opts? table options for configuring numbercolumn and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.numbercolumn()
|
||||
function M.numbercolumn(opts)
|
||||
opts = extend_tbl({
|
||||
numbercolumn = { padding = { right = 1 } },
|
||||
condition = condition.numbercolumn_enabled,
|
||||
on_click = {
|
||||
name = "line_click",
|
||||
callback = function(...)
|
||||
local args = status_utils.statuscolumn_clickargs(...)
|
||||
if args.mods:find "c" then
|
||||
local dap_avail, dap = pcall(require, "dap")
|
||||
if dap_avail then vim.schedule(dap.toggle_breakpoint) end
|
||||
end
|
||||
end,
|
||||
},
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "numbercolumn" }))
|
||||
end
|
||||
|
||||
--- A function to build a set of components for a signcolumn section in statuscolumn
|
||||
---@param opts? table options for configuring signcolumn and the overall padding
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").component.signcolumn()
|
||||
function M.signcolumn(opts)
|
||||
opts = extend_tbl({
|
||||
signcolumn = {},
|
||||
condition = condition.signcolumn_enabled,
|
||||
on_click = {
|
||||
name = "sign_click",
|
||||
callback = function(...)
|
||||
local args = status_utils.statuscolumn_clickargs(...)
|
||||
if args.sign and args.sign.name and env.sign_handlers[args.sign.name] then
|
||||
env.sign_handlers[args.sign.name](args)
|
||||
end
|
||||
end,
|
||||
},
|
||||
}, opts)
|
||||
return M.builder(status_utils.setup_providers(opts, { "signcolumn" }))
|
||||
end
|
||||
|
||||
--- A general function to build a section of astronvim status providers with highlights, conditions, and section surrounding
|
||||
---@param opts? table a list of components to build into a section
|
||||
---@return table # The Heirline component table
|
||||
-- @usage local heirline_component = require("astronvim.utils.status").components.builder({ { provider = "file_icon", opts = { padding = { right = 1 } } }, { provider = "filename" } })
|
||||
function M.builder(opts)
|
||||
opts = extend_tbl({ padding = { left = 0, right = 0 } }, opts)
|
||||
local children = {}
|
||||
if opts.padding.left > 0 then -- add left padding
|
||||
table.insert(children, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
|
||||
end
|
||||
for key, entry in pairs(opts) do
|
||||
if
|
||||
type(key) == "number"
|
||||
and type(entry) == "table"
|
||||
and provider[entry.provider]
|
||||
and (entry.opts == nil or type(entry.opts) == "table")
|
||||
then
|
||||
entry.provider = provider[entry.provider](entry.opts)
|
||||
end
|
||||
children[key] = entry
|
||||
end
|
||||
if opts.padding.right > 0 then -- add right padding
|
||||
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
|
||||
end
|
||||
return opts.surround
|
||||
and status_utils.surround(opts.surround.separator, opts.surround.color, children, opts.surround.condition)
|
||||
or children
|
||||
end
|
||||
|
||||
return M
|
||||
137
lua/astronvim/utils/status/condition.lua
Normal file
137
lua/astronvim/utils/status/condition.lua
Normal file
@@ -0,0 +1,137 @@
|
||||
--- ### AstroNvim Status Conditions
|
||||
--
|
||||
-- Statusline related condition functions to use with Heirline
|
||||
--
|
||||
-- This module can be loaded with `local condition = require "astronvim.utils.status.condition"`
|
||||
--
|
||||
-- @module astronvim.utils.status.condition
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local env = require "astronvim.utils.status.env"
|
||||
|
||||
--- A condition function if the window is currently active
|
||||
---@return boolean # whether or not the window is currently actie
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_active }
|
||||
function M.is_active() return vim.api.nvim_get_current_win() == tonumber(vim.g.actual_curwin) end
|
||||
|
||||
--- A condition function if the buffer filetype,buftype,bufname match a pattern
|
||||
---@param patterns table the table of patterns to match
|
||||
---@param bufnr number of the buffer to match (Default: 0 [current])
|
||||
---@return boolean # whether or not LSP is attached
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = function() return require("astronvim.utils.status").condition.buffer_matches { buftype = { "terminal" } } end }
|
||||
function M.buffer_matches(patterns, bufnr)
|
||||
for kind, pattern_list in pairs(patterns) do
|
||||
if env.buf_matchers[kind](pattern_list, bufnr) then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
--- A condition function if a macro is being recorded
|
||||
---@return boolean # whether or not a macro is currently being recorded
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_macro_recording }
|
||||
function M.is_macro_recording() return vim.fn.reg_recording() ~= "" end
|
||||
|
||||
--- A condition function if search is visible
|
||||
---@return boolean # whether or not searching is currently visible
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_hlsearch }
|
||||
function M.is_hlsearch() return vim.v.hlsearch ~= 0 end
|
||||
|
||||
--- A condition function if showcmdloc is set to statusline
|
||||
---@return boolean # whether or not statusline showcmd is enabled
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_statusline_showcmd }
|
||||
function M.is_statusline_showcmd() return vim.fn.has "nvim-0.9" == 1 and vim.opt.showcmdloc:get() == "statusline" end
|
||||
|
||||
--- A condition function if the current file is in a git repo
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not the current file is in a git repo
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.is_git_repo }
|
||||
function M.is_git_repo(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
return vim.b[bufnr or 0].gitsigns_head or vim.b[bufnr or 0].gitsigns_status_dict
|
||||
end
|
||||
|
||||
--- A condition function if there are any git changes
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not there are any git changes
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.git_changed }
|
||||
function M.git_changed(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
local git_status = vim.b[bufnr or 0].gitsigns_status_dict
|
||||
return git_status and (git_status.added or 0) + (git_status.removed or 0) + (git_status.changed or 0) > 0
|
||||
end
|
||||
|
||||
--- A condition function if the current buffer is modified
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not the current buffer is modified
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.file_modified }
|
||||
function M.file_modified(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
return vim.bo[bufnr or 0].modified
|
||||
end
|
||||
|
||||
--- A condition function if the current buffer is read only
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not the current buffer is read only or not modifiable
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.file_read_only }
|
||||
function M.file_read_only(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
local buffer = vim.bo[bufnr or 0]
|
||||
return not buffer.modifiable or buffer.readonly
|
||||
end
|
||||
|
||||
--- A condition function if the current file has any diagnostics
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not the current file has any diagnostics
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.has_diagnostics }
|
||||
function M.has_diagnostics(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
return vim.g.diagnostics_mode > 0 and #vim.diagnostic.get(bufnr or 0) > 0
|
||||
end
|
||||
|
||||
--- A condition function if there is a defined filetype
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not there is a filetype
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.has_filetype }
|
||||
function M.has_filetype(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
return vim.fn.empty(vim.fn.expand "%:t") ~= 1 and vim.bo[bufnr or 0].filetype and vim.bo[bufnr or 0].filetype ~= ""
|
||||
end
|
||||
|
||||
--- A condition function if Aerial is available
|
||||
---@return boolean # whether or not aerial plugin is installed
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.aerial_available }
|
||||
-- function M.aerial_available() return is_available "aerial.nvim" end
|
||||
function M.aerial_available() return package.loaded["aerial"] end
|
||||
|
||||
--- A condition function if LSP is attached
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not LSP is attached
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.lsp_attached }
|
||||
function M.lsp_attached(bufnr)
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
return next(vim.lsp.get_active_clients { bufnr = bufnr or 0 }) ~= nil
|
||||
end
|
||||
|
||||
--- A condition function if treesitter is in use
|
||||
---@param bufnr table|integer a buffer number to check the condition for, a table with bufnr property, or nil to get the current buffer
|
||||
---@return boolean # whether or not treesitter is active
|
||||
-- @usage local heirline_component = { provider = "Example Provider", condition = require("astronvim.utils.status").condition.treesitter_available }
|
||||
function M.treesitter_available(bufnr)
|
||||
if not package.loaded["nvim-treesitter"] then return false end
|
||||
if type(bufnr) == "table" then bufnr = bufnr.bufnr end
|
||||
local parsers = require "nvim-treesitter.parsers"
|
||||
return parsers.has_parser(parsers.get_buf_lang(bufnr or vim.api.nvim_get_current_buf()))
|
||||
end
|
||||
|
||||
--- A condition function if the foldcolumn is enabled
|
||||
---@return boolean # true if vim.opt.foldcolumn > 0, false if vim.opt.foldcolumn == 0
|
||||
function M.foldcolumn_enabled() return vim.opt.foldcolumn:get() ~= "0" end
|
||||
|
||||
--- A condition function if the number column is enabled
|
||||
---@return boolean # true if vim.opt.number or vim.opt.relativenumber, false if neither
|
||||
function M.numbercolumn_enabled() return vim.opt.number:get() or vim.opt.relativenumber:get() end
|
||||
|
||||
return M
|
||||
143
lua/astronvim/utils/status/env.lua
Normal file
143
lua/astronvim/utils/status/env.lua
Normal file
@@ -0,0 +1,143 @@
|
||||
--- ### AstroNvim Status Environment
|
||||
--
|
||||
-- Statusline related environment variables shared between components/providers/etc.
|
||||
--
|
||||
-- This module can be loaded with `local env = require "astronvim.utils.status.env"`
|
||||
--
|
||||
-- @module astronvim.utils.status.env
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
M.fallback_colors = {
|
||||
none = "NONE",
|
||||
fg = "#abb2bf",
|
||||
bg = "#1e222a",
|
||||
dark_bg = "#2c323c",
|
||||
blue = "#61afef",
|
||||
green = "#98c379",
|
||||
grey = "#5c6370",
|
||||
bright_grey = "#777d86",
|
||||
dark_grey = "#5c5c5c",
|
||||
orange = "#ff9640",
|
||||
purple = "#c678dd",
|
||||
bright_purple = "#a9a1e1",
|
||||
red = "#e06c75",
|
||||
bright_red = "#ec5f67",
|
||||
white = "#c9c9c9",
|
||||
yellow = "#e5c07b",
|
||||
bright_yellow = "#ebae34",
|
||||
}
|
||||
|
||||
M.modes = {
|
||||
["n"] = { "NORMAL", "normal" },
|
||||
["no"] = { "OP", "normal" },
|
||||
["nov"] = { "OP", "normal" },
|
||||
["noV"] = { "OP", "normal" },
|
||||
["no"] = { "OP", "normal" },
|
||||
["niI"] = { "NORMAL", "normal" },
|
||||
["niR"] = { "NORMAL", "normal" },
|
||||
["niV"] = { "NORMAL", "normal" },
|
||||
["i"] = { "INSERT", "insert" },
|
||||
["ic"] = { "INSERT", "insert" },
|
||||
["ix"] = { "INSERT", "insert" },
|
||||
["t"] = { "TERM", "terminal" },
|
||||
["nt"] = { "TERM", "terminal" },
|
||||
["v"] = { "VISUAL", "visual" },
|
||||
["vs"] = { "VISUAL", "visual" },
|
||||
["V"] = { "LINES", "visual" },
|
||||
["Vs"] = { "LINES", "visual" },
|
||||
[""] = { "BLOCK", "visual" },
|
||||
["s"] = { "BLOCK", "visual" },
|
||||
["R"] = { "REPLACE", "replace" },
|
||||
["Rc"] = { "REPLACE", "replace" },
|
||||
["Rx"] = { "REPLACE", "replace" },
|
||||
["Rv"] = { "V-REPLACE", "replace" },
|
||||
["s"] = { "SELECT", "visual" },
|
||||
["S"] = { "SELECT", "visual" },
|
||||
[""] = { "BLOCK", "visual" },
|
||||
["c"] = { "COMMAND", "command" },
|
||||
["cv"] = { "COMMAND", "command" },
|
||||
["ce"] = { "COMMAND", "command" },
|
||||
["r"] = { "PROMPT", "inactive" },
|
||||
["rm"] = { "MORE", "inactive" },
|
||||
["r?"] = { "CONFIRM", "inactive" },
|
||||
["!"] = { "SHELL", "inactive" },
|
||||
["null"] = { "null", "inactive" },
|
||||
}
|
||||
|
||||
M.separators = astronvim.user_opts("heirline.separators", {
|
||||
none = { "", "" },
|
||||
left = { "", " " },
|
||||
right = { " ", "" },
|
||||
center = { " ", " " },
|
||||
tab = { "", " " },
|
||||
breadcrumbs = " ",
|
||||
path = " ",
|
||||
})
|
||||
|
||||
M.attributes = astronvim.user_opts("heirline.attributes", {
|
||||
buffer_active = { bold = true, italic = true },
|
||||
buffer_picker = { bold = true },
|
||||
macro_recording = { bold = true },
|
||||
git_branch = { bold = true },
|
||||
git_diff = { bold = true },
|
||||
})
|
||||
|
||||
M.icon_highlights = astronvim.user_opts("heirline.icon_highlights", {
|
||||
file_icon = {
|
||||
tabline = function(self) return self.is_active or self.is_visible end,
|
||||
statusline = true,
|
||||
},
|
||||
})
|
||||
|
||||
local function pattern_match(str, pattern_list)
|
||||
for _, pattern in ipairs(pattern_list) do
|
||||
if str:find(pattern) then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
M.buf_matchers = {
|
||||
filetype = function(pattern_list, bufnr) return pattern_match(vim.bo[bufnr or 0].filetype, pattern_list) end,
|
||||
buftype = function(pattern_list, bufnr) return pattern_match(vim.bo[bufnr or 0].buftype, pattern_list) end,
|
||||
bufname = function(pattern_list, bufnr)
|
||||
return pattern_match(vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr or 0), ":t"), pattern_list)
|
||||
end,
|
||||
}
|
||||
|
||||
M.sign_handlers = {}
|
||||
-- gitsigns handlers
|
||||
local gitsigns = function(_)
|
||||
local gitsigns_avail, gitsigns = pcall(require, "gitsigns")
|
||||
if gitsigns_avail then vim.schedule(gitsigns.preview_hunk) end
|
||||
end
|
||||
for _, sign in ipairs { "Topdelete", "Untracked", "Add", "Changedelete", "Delete" } do
|
||||
local name = "GitSigns" .. sign
|
||||
if not M.sign_handlers[name] then M.sign_handlers[name] = gitsigns end
|
||||
end
|
||||
-- diagnostic handlers
|
||||
local diagnostics = function(args)
|
||||
if args.mods:find "c" then
|
||||
vim.schedule(vim.lsp.buf.code_action)
|
||||
else
|
||||
vim.schedule(vim.diagnostic.open_float)
|
||||
end
|
||||
end
|
||||
for _, sign in ipairs { "Error", "Hint", "Info", "Warn" } do
|
||||
local name = "DiagnosticSign" .. sign
|
||||
if not M.sign_handlers[name] then M.sign_handlers[name] = diagnostics end
|
||||
end
|
||||
-- DAP handlers
|
||||
local dap_breakpoint = function(_)
|
||||
local dap_avail, dap = pcall(require, "dap")
|
||||
if dap_avail then vim.schedule(dap.toggle_breakpoint) end
|
||||
end
|
||||
for _, sign in ipairs { "", "Rejected", "Condition" } do
|
||||
local name = "DapBreakpoint" .. sign
|
||||
if not M.sign_handlers[name] then M.sign_handlers[name] = dap_breakpoint end
|
||||
end
|
||||
M.sign_handlers = astronvim.user_opts("heirline.sign_handlers", M.sign_handlers)
|
||||
|
||||
return M
|
||||
115
lua/astronvim/utils/status/heirline.lua
Normal file
115
lua/astronvim/utils/status/heirline.lua
Normal file
@@ -0,0 +1,115 @@
|
||||
--- ### AstroNvim Status Heirline Extensions
|
||||
--
|
||||
-- Statusline related heirline specific extensions
|
||||
--
|
||||
-- This module can be loaded with `local astro_heirline = require "astronvim.utils.status.heirline"`
|
||||
--
|
||||
-- @module astronvim.utils.status.heirline
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local hl = require "astronvim.utils.status.hl"
|
||||
local provider = require "astronvim.utils.status.provider"
|
||||
local status_utils = require "astronvim.utils.status.utils"
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local buffer_utils = require "astronvim.utils.buffer"
|
||||
local get_icon = utils.get_icon
|
||||
|
||||
--- A helper function to get the type a tab or buffer is
|
||||
---@param self table the self table from a heirline component function
|
||||
---@param prefix? string the prefix of the type, either "tab" or "buffer" (Default: "buffer")
|
||||
---@return string # the string of prefix with the type (i.e. "_active" or "_visible")
|
||||
function M.tab_type(self, prefix)
|
||||
local tab_type = ""
|
||||
if self.is_active then
|
||||
tab_type = "_active"
|
||||
elseif self.is_visible then
|
||||
tab_type = "_visible"
|
||||
end
|
||||
return (prefix or "buffer") .. tab_type
|
||||
end
|
||||
|
||||
--- Make a list of buffers, rendering each buffer with the provided component
|
||||
---@param component table
|
||||
---@return table
|
||||
M.make_buflist = function(component)
|
||||
local overflow_hl = hl.get_attributes("buffer_overflow", true)
|
||||
return require("heirline.utils").make_buflist(
|
||||
status_utils.surround(
|
||||
"tab",
|
||||
function(self)
|
||||
return {
|
||||
main = M.tab_type(self) .. "_bg",
|
||||
left = "tabline_bg",
|
||||
right = "tabline_bg",
|
||||
}
|
||||
end,
|
||||
{ -- bufferlist
|
||||
init = function(self) self.tab_type = M.tab_type(self) end,
|
||||
on_click = { -- add clickable component to each buffer
|
||||
callback = function(_, minwid) vim.api.nvim_win_set_buf(0, minwid) end,
|
||||
minwid = function(self) return self.bufnr end,
|
||||
name = "heirline_tabline_buffer_callback",
|
||||
},
|
||||
{ -- add buffer picker functionality to each buffer
|
||||
condition = function(self) return self._show_picker end,
|
||||
update = false,
|
||||
init = function(self)
|
||||
if not (self.label and self._picker_labels[self.label]) then
|
||||
local bufname = provider.filename()(self)
|
||||
local label = bufname:sub(1, 1)
|
||||
local i = 2
|
||||
while label ~= " " and self._picker_labels[label] do
|
||||
if i > #bufname then break end
|
||||
label = bufname:sub(i, i)
|
||||
i = i + 1
|
||||
end
|
||||
self._picker_labels[label] = self.bufnr
|
||||
self.label = label
|
||||
end
|
||||
end,
|
||||
provider = function(self) return provider.str { str = self.label, padding = { left = 1, right = 1 } } end,
|
||||
hl = hl.get_attributes "buffer_picker",
|
||||
},
|
||||
component, -- create buffer component
|
||||
},
|
||||
function(self) return buffer_utils.is_valid(self.bufnr) end -- disable surrounding
|
||||
),
|
||||
{ provider = get_icon "ArrowLeft" .. " ", hl = overflow_hl },
|
||||
{ provider = get_icon "ArrowRight" .. " ", hl = overflow_hl },
|
||||
function() return vim.t.bufs end, -- use astronvim bufs variable
|
||||
false -- disable internal caching
|
||||
)
|
||||
end
|
||||
|
||||
--- Alias to require("heirline.utils").make_tablist
|
||||
function M.make_tablist(...) return require("heirline.utils").make_tablist(...) end
|
||||
|
||||
--- Run the buffer picker and execute the callback function on the selected buffer
|
||||
---@param callback function with a single parameter of the buffer number
|
||||
function M.buffer_picker(callback)
|
||||
local tabline = require("heirline").tabline
|
||||
-- if buflist then
|
||||
local prev_showtabline = vim.opt.showtabline:get()
|
||||
if prev_showtabline ~= 2 then vim.opt.showtabline = 2 end
|
||||
vim.cmd.redrawtabline()
|
||||
---@diagnostic disable-next-line: undefined-field
|
||||
local buflist = tabline and tabline._buflist and tabline._buflist[1]
|
||||
if buflist then
|
||||
buflist._picker_labels = {}
|
||||
buflist._show_picker = true
|
||||
vim.cmd.redrawtabline()
|
||||
local char = vim.fn.getcharstr()
|
||||
local bufnr = buflist._picker_labels[char]
|
||||
if bufnr then callback(bufnr) end
|
||||
buflist._show_picker = false
|
||||
end
|
||||
if prev_showtabline ~= 2 then vim.opt.showtabline = prev_showtabline end
|
||||
vim.cmd.redrawtabline()
|
||||
-- end
|
||||
end
|
||||
|
||||
return M
|
||||
76
lua/astronvim/utils/status/hl.lua
Normal file
76
lua/astronvim/utils/status/hl.lua
Normal file
@@ -0,0 +1,76 @@
|
||||
--- ### AstroNvim Status Highlighting
|
||||
--
|
||||
-- Statusline related highlighting utilities
|
||||
--
|
||||
-- This module can be loaded with `local hl = require "astronvim.utils.status.hl"`
|
||||
--
|
||||
-- @module astronvim.utils.status.hl
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local env = require "astronvim.utils.status.env"
|
||||
|
||||
--- Get the highlight background color of the lualine theme for the current colorscheme
|
||||
---@param mode string the neovim mode to get the color of
|
||||
---@param fallback string the color to fallback on if a lualine theme is not present
|
||||
---@return string # The background color of the lualine theme or the fallback parameter if one doesn't exist
|
||||
function M.lualine_mode(mode, fallback)
|
||||
if not vim.g.colors_name then return fallback end
|
||||
local lualine_avail, lualine = pcall(require, "lualine.themes." .. vim.g.colors_name)
|
||||
local lualine_opts = lualine_avail and lualine[mode]
|
||||
return lualine_opts and type(lualine_opts.a) == "table" and lualine_opts.a.bg or fallback
|
||||
end
|
||||
|
||||
--- Get the highlight for the current mode
|
||||
---@return table # the highlight group for the current mode
|
||||
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.mode },
|
||||
function M.mode() return { bg = M.mode_bg() } end
|
||||
|
||||
--- Get the foreground color group for the current mode, good for usage with Heirline surround utility
|
||||
---@return string # the highlight group for the current mode foreground
|
||||
-- @usage local heirline_component = require("heirline.utils").surround({ "|", "|" }, require("astronvim.utils.status").hl.mode_bg, heirline_component),
|
||||
|
||||
function M.mode_bg() return env.modes[vim.fn.mode()][2] end
|
||||
|
||||
--- Get the foreground color group for the current filetype
|
||||
---@return table # the highlight group for the current filetype foreground
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.fileicon(), hl = require("astronvim.utils.status").hl.filetype_color },
|
||||
function M.filetype_color(self)
|
||||
local devicons_avail, devicons = pcall(require, "nvim-web-devicons")
|
||||
if not devicons_avail then return {} end
|
||||
local _, color = devicons.get_icon_color(
|
||||
vim.fn.fnamemodify(vim.api.nvim_buf_get_name(self and self.bufnr or 0), ":t"),
|
||||
nil,
|
||||
{ default = true }
|
||||
)
|
||||
return { fg = color }
|
||||
end
|
||||
|
||||
--- Merge the color and attributes from user settings for a given name
|
||||
---@param name string, the name of the element to get the attributes and colors for
|
||||
---@param include_bg? boolean whether or not to include background color (Default: false)
|
||||
---@return table # a table of highlight information
|
||||
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.get_attributes("treesitter") },
|
||||
function M.get_attributes(name, include_bg)
|
||||
local hl = env.attributes[name] or {}
|
||||
hl.fg = name .. "_fg"
|
||||
if include_bg then hl.bg = name .. "_bg" end
|
||||
return hl
|
||||
end
|
||||
|
||||
--- Enable filetype color highlight if enabled in icon_highlights.file_icon options
|
||||
---@param name string the icon_highlights.file_icon table element
|
||||
---@return function # for setting hl property in a component
|
||||
-- @usage local heirline_component = { provider = "Example Provider", hl = require("astronvim.utils.status").hl.file_icon("winbar") },
|
||||
function M.file_icon(name)
|
||||
local hl_enabled = env.icon_highlights.file_icon[name]
|
||||
return function(self)
|
||||
if hl_enabled == true or (type(hl_enabled) == "function" and hl_enabled(self)) then
|
||||
return M.filetype_color(self)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return M
|
||||
155
lua/astronvim/utils/status/init.lua
Normal file
155
lua/astronvim/utils/status/init.lua
Normal file
@@ -0,0 +1,155 @@
|
||||
--- ### AstroNvim Status Initializers
|
||||
--
|
||||
-- Statusline related init functions for building dynamic statusline components
|
||||
--
|
||||
-- This module can be loaded with `local init = require "astronvim.utils.status.init"`
|
||||
--
|
||||
-- @module astronvim.utils.status.init
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local env = require "astronvim.utils.status.env"
|
||||
local provider = require "astronvim.utils.status.provider"
|
||||
local status_utils = require "astronvim.utils.status.utils"
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local extend_tbl = utils.extend_tbl
|
||||
|
||||
--- An `init` function to build a set of children components for LSP breadcrumbs
|
||||
---@param opts? table # options for configuring the breadcrumbs (default: `{ max_depth = 5, separator = " ", icon = { enabled = true, hl = false }, padding = { left = 0, right = 0 } }`)
|
||||
---@return function # The Heirline init function
|
||||
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.breadcrumbs { padding = { left = 1 } } }
|
||||
function M.breadcrumbs(opts)
|
||||
opts = extend_tbl({
|
||||
max_depth = 5,
|
||||
separator = env.separators.breadcrumbs or " ",
|
||||
icon = { enabled = true, hl = env.icon_highlights.breadcrumbs },
|
||||
padding = { left = 0, right = 0 },
|
||||
}, opts)
|
||||
return function(self)
|
||||
local data = require("aerial").get_location(true) or {}
|
||||
local children = {}
|
||||
-- add prefix if needed, use the separator if true, or use the provided character
|
||||
if opts.prefix and not vim.tbl_isempty(data) then
|
||||
table.insert(children, { provider = opts.prefix == true and opts.separator or opts.prefix })
|
||||
end
|
||||
local start_idx = 0
|
||||
if opts.max_depth and opts.max_depth > 0 then
|
||||
start_idx = #data - opts.max_depth
|
||||
if start_idx > 0 then
|
||||
table.insert(children, { provider = require("astronvim.utils").get_icon "Ellipsis" .. opts.separator })
|
||||
end
|
||||
end
|
||||
-- create a child for each level
|
||||
for i, d in ipairs(data) do
|
||||
if i > start_idx then
|
||||
local child = {
|
||||
{ provider = string.gsub(d.name, "%%", "%%%%"):gsub("%s*->%s*", "") }, -- add symbol name
|
||||
on_click = { -- add on click function
|
||||
minwid = status_utils.encode_pos(d.lnum, d.col, self.winnr),
|
||||
callback = function(_, minwid)
|
||||
local lnum, col, winnr = status_utils.decode_pos(minwid)
|
||||
vim.api.nvim_win_set_cursor(vim.fn.win_getid(winnr), { lnum, col })
|
||||
end,
|
||||
name = "heirline_breadcrumbs",
|
||||
},
|
||||
}
|
||||
if opts.icon.enabled then -- add icon and highlight if enabled
|
||||
local hl = opts.icon.hl
|
||||
if type(hl) == "function" then hl = hl(self) end
|
||||
local hlgroup = string.format("Aerial%sIcon", d.kind)
|
||||
table.insert(child, 1, {
|
||||
provider = string.format("%s ", d.icon),
|
||||
hl = (hl and vim.fn.hlexists(hlgroup) == 1) and hlgroup or nil,
|
||||
})
|
||||
end
|
||||
if #data > 1 and i < #data then table.insert(child, { provider = opts.separator }) end -- add a separator only if needed
|
||||
table.insert(children, child)
|
||||
end
|
||||
end
|
||||
if opts.padding.left > 0 then -- add left padding
|
||||
table.insert(children, 1, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
|
||||
end
|
||||
if opts.padding.right > 0 then -- add right padding
|
||||
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
|
||||
end
|
||||
-- instantiate the new child
|
||||
self[1] = self:new(children, 1)
|
||||
end
|
||||
end
|
||||
|
||||
--- An `init` function to build a set of children components for a separated path to file
|
||||
---@param opts? table options for configuring the breadcrumbs (default: `{ max_depth = 3, path_func = provider.unique_path(), separator = " ", suffix = true, padding = { left = 0, right = 0 } }`)
|
||||
---@return function # The Heirline init function
|
||||
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.separated_path { padding = { left = 1 } } }
|
||||
function M.separated_path(opts)
|
||||
opts = extend_tbl({
|
||||
max_depth = 3,
|
||||
path_func = provider.unique_path(),
|
||||
separator = env.separators.path or " ",
|
||||
suffix = true,
|
||||
padding = { left = 0, right = 0 },
|
||||
}, opts)
|
||||
if opts.suffix == true then opts.suffix = opts.separator end
|
||||
return function(self)
|
||||
local path = opts.path_func(self)
|
||||
if path == "." then path = "" end -- if there is no path, just replace with empty string
|
||||
local data = vim.fn.split(path, "/")
|
||||
local children = {}
|
||||
-- add prefix if needed, use the separator if true, or use the provided character
|
||||
if opts.prefix and not vim.tbl_isempty(data) then
|
||||
table.insert(children, { provider = opts.prefix == true and opts.separator or opts.prefix })
|
||||
end
|
||||
local start_idx = 0
|
||||
if opts.max_depth and opts.max_depth > 0 then
|
||||
start_idx = #data - opts.max_depth
|
||||
if start_idx > 0 then
|
||||
table.insert(children, { provider = require("astronvim.utils").get_icon "Ellipsis" .. opts.separator })
|
||||
end
|
||||
end
|
||||
-- create a child for each level
|
||||
for i, d in ipairs(data) do
|
||||
if i > start_idx then
|
||||
local child = { { provider = d } }
|
||||
local separator = i < #data and opts.separtor or opts.suffix
|
||||
if separator then table.insert(child, { provider = separator }) end
|
||||
table.insert(children, child)
|
||||
end
|
||||
end
|
||||
if opts.padding.left > 0 then -- add left padding
|
||||
table.insert(children, 1, { provider = status_utils.pad_string(" ", { left = opts.padding.left - 1 }) })
|
||||
end
|
||||
if opts.padding.right > 0 then -- add right padding
|
||||
table.insert(children, { provider = status_utils.pad_string(" ", { right = opts.padding.right - 1 }) })
|
||||
end
|
||||
-- instantiate the new child
|
||||
self[1] = self:new(children, 1)
|
||||
end
|
||||
end
|
||||
|
||||
--- An `init` function to build multiple update events which is not supported yet by Heirline's update field
|
||||
---@param opts any[] an array like table of autocmd events as either just a string or a table with custom patterns and callbacks.
|
||||
---@return function # The Heirline init function
|
||||
-- @usage local heirline_component = { init = require("astronvim.utils.status").init.update_events { "BufEnter", { "User", pattern = "LspProgressUpdate" } } }
|
||||
function M.update_events(opts)
|
||||
return function(self)
|
||||
if not rawget(self, "once") then
|
||||
local clear_cache = function() self._win_cache = nil end
|
||||
for _, event in ipairs(opts) do
|
||||
local event_opts = { callback = clear_cache }
|
||||
if type(event) == "table" then
|
||||
event_opts.pattern = event.pattern
|
||||
event_opts.callback = event.callback or clear_cache
|
||||
event.pattern = nil
|
||||
event.callback = nil
|
||||
end
|
||||
vim.api.nvim_create_autocmd(event, event_opts)
|
||||
end
|
||||
self.once = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return M
|
||||
520
lua/astronvim/utils/status/provider.lua
Normal file
520
lua/astronvim/utils/status/provider.lua
Normal file
@@ -0,0 +1,520 @@
|
||||
--- ### AstroNvim Status Providers
|
||||
--
|
||||
-- Statusline related provider functions for building statusline components
|
||||
--
|
||||
-- This module can be loaded with `local provider = require "astronvim.utils.status.provider"`
|
||||
--
|
||||
-- @module astronvim.utils.status.provider
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local condition = require "astronvim.utils.status.condition"
|
||||
local env = require "astronvim.utils.status.env"
|
||||
local status_utils = require "astronvim.utils.status.utils"
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local extend_tbl = utils.extend_tbl
|
||||
local get_icon = utils.get_icon
|
||||
|
||||
--- A provider function for the fill string
|
||||
---@return string # the statusline string for filling the empty space
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.fill }
|
||||
function M.fill() return "%=" end
|
||||
|
||||
--- A provider function for the signcolumn string
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return string # the statuscolumn string for adding the signcolumn
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.signcolumn }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.signcolumn(opts)
|
||||
opts = extend_tbl({ escape = false }, opts)
|
||||
return status_utils.stylize("%s", opts)
|
||||
end
|
||||
|
||||
--- A provider function for the numbercolumn string
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the statuscolumn string for adding the numbercolumn
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.numbercolumn }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.numbercolumn(opts)
|
||||
opts = extend_tbl({ thousands = false, culright = true, escape = false }, opts)
|
||||
return function()
|
||||
local lnum, rnum, virtnum = vim.v.lnum, vim.v.relnum, vim.v.virtnum
|
||||
local num, relnum = vim.opt.number:get(), vim.opt.relativenumber:get()
|
||||
local str
|
||||
if not num and not relnum then
|
||||
str = ""
|
||||
elseif virtnum ~= 0 then
|
||||
str = "%="
|
||||
else
|
||||
local cur = relnum and (rnum > 0 and rnum or (num and lnum or 0)) or lnum
|
||||
if opts.thousands and cur > 999 then
|
||||
cur = string.reverse(cur):gsub("%d%d%d", "%1" .. opts.thousands):reverse():gsub("^%" .. opts.thousands, "")
|
||||
end
|
||||
str = (rnum == 0 and not opts.culright and relnum) and cur .. "%=" or "%=" .. cur
|
||||
end
|
||||
return status_utils.stylize(str, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for building a foldcolumn
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # a custom foldcolumn function for the statuscolumn that doesn't show the nest levels
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.foldcolumn }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.foldcolumn(opts)
|
||||
opts = extend_tbl({ escape = false }, opts)
|
||||
local ffi = require "astronvim.utils.ffi" -- get AstroNvim C extensions
|
||||
local fillchars = vim.opt.fillchars:get()
|
||||
local foldopen = fillchars.foldopen or get_icon "FoldOpened"
|
||||
local foldclosed = fillchars.foldclose or get_icon "FoldClosed"
|
||||
local foldsep = fillchars.foldsep or get_icon "FoldSeparator"
|
||||
return function() -- move to M.fold_indicator
|
||||
local wp = ffi.C.find_window_by_handle(0, ffi.new "Error") -- get window handler
|
||||
local width = ffi.C.compute_foldcolumn(wp, 0) -- get foldcolumn width
|
||||
-- get fold info of current line
|
||||
local foldinfo = width > 0 and ffi.C.fold_info(wp, vim.v.lnum) or { start = 0, level = 0, llevel = 0, lines = 0 }
|
||||
|
||||
local str = ""
|
||||
if width ~= 0 then
|
||||
str = vim.v.relnum > 0 and "%#FoldColumn#" or "%#CursorLineFold#"
|
||||
if foldinfo.level == 0 then
|
||||
str = str .. (" "):rep(width)
|
||||
else
|
||||
local closed = foldinfo.lines > 0
|
||||
local first_level = foldinfo.level - width - (closed and 1 or 0) + 1
|
||||
if first_level < 1 then first_level = 1 end
|
||||
|
||||
for col = 1, width do
|
||||
str = str
|
||||
.. (
|
||||
(vim.v.virtnum ~= 0 and foldsep)
|
||||
or ((closed and (col == foldinfo.level or col == width)) and foldclosed)
|
||||
or ((foldinfo.start == vim.v.lnum and first_level + col > foldinfo.llevel) and foldopen)
|
||||
or foldsep
|
||||
)
|
||||
if col == foldinfo.level then
|
||||
str = str .. (" "):rep(width - col)
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
return status_utils.stylize(str .. "%*", opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for the current tab numbre
|
||||
---@return function # the statusline function to return a string for a tab number
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.tabnr() }
|
||||
function M.tabnr()
|
||||
return function(self) return (self and self.tabnr) and "%" .. self.tabnr .. "T " .. self.tabnr .. " %T" or "" end
|
||||
end
|
||||
|
||||
--- A provider function for showing if spellcheck is on
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting if spell is enabled
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.spell() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.spell(opts)
|
||||
opts = extend_tbl({ str = "", icon = { kind = "Spellcheck" }, show_empty = true }, opts)
|
||||
return function() return status_utils.stylize(vim.wo.spell and opts.str or nil, opts) end
|
||||
end
|
||||
|
||||
--- A provider function for showing if paste is enabled
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting if paste is enabled
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.paste() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.paste(opts)
|
||||
opts = extend_tbl({ str = "", icon = { kind = "Paste" }, show_empty = true }, opts)
|
||||
local paste = vim.opt.paste
|
||||
if type(paste) ~= "boolean" then paste = paste:get() end
|
||||
return function() return status_utils.stylize(paste and opts.str or nil, opts) end
|
||||
end
|
||||
|
||||
--- A provider function for displaying if a macro is currently being recorded
|
||||
---@param opts? table a prefix before the recording register and options passed to the stylize function
|
||||
---@return function # a function that returns a string of the current recording status
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.macro_recording() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.macro_recording(opts)
|
||||
opts = extend_tbl({ prefix = "@" }, opts)
|
||||
return function()
|
||||
local register = vim.fn.reg_recording()
|
||||
if register ~= "" then register = opts.prefix .. register end
|
||||
return status_utils.stylize(register, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for displaying the current command
|
||||
---@param opts? table of options passed to the stylize function
|
||||
---@return string # the statusline string for showing the current command
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.showcmd() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.showcmd(opts)
|
||||
opts = extend_tbl({ minwid = 0, maxwid = 5, escape = false }, opts)
|
||||
return status_utils.stylize(("%%%d.%d(%%S%%)"):format(opts.minwid, opts.maxwid), opts)
|
||||
end
|
||||
|
||||
--- A provider function for displaying the current search count
|
||||
---@param opts? table options for `vim.fn.searchcount` and options passed to the stylize function
|
||||
---@return function # a function that returns a string of the current search location
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.search_count() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.search_count(opts)
|
||||
local search_func = vim.tbl_isempty(opts or {}) and function() return vim.fn.searchcount() end
|
||||
or function() return vim.fn.searchcount(opts) end
|
||||
return function()
|
||||
local search_ok, search = pcall(search_func)
|
||||
if search_ok and type(search) == "table" and search.total then
|
||||
return status_utils.stylize(
|
||||
string.format(
|
||||
"%s%d/%s%d",
|
||||
search.current > search.maxcount and ">" or "",
|
||||
math.min(search.current, search.maxcount),
|
||||
search.incomplete == 2 and ">" or "",
|
||||
math.min(search.total, search.maxcount)
|
||||
),
|
||||
opts
|
||||
)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the text of the current vim mode
|
||||
---@param opts? table options for padding the text and options passed to the stylize function
|
||||
---@return function # the function for displaying the text of the current vim mode
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.mode_text() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.mode_text(opts)
|
||||
local max_length = math.max(unpack(vim.tbl_map(function(str) return #str[1] end, vim.tbl_values(env.modes))))
|
||||
return function()
|
||||
local text = env.modes[vim.fn.mode()][1]
|
||||
if opts and opts.pad_text then
|
||||
local padding = max_length - #text
|
||||
if opts.pad_text == "right" then
|
||||
text = string.rep(" ", padding) .. text
|
||||
elseif opts.pad_text == "left" then
|
||||
text = text .. string.rep(" ", padding)
|
||||
elseif opts.pad_text == "center" then
|
||||
text = string.rep(" ", math.floor(padding / 2)) .. text .. string.rep(" ", math.ceil(padding / 2))
|
||||
end
|
||||
end
|
||||
return status_utils.stylize(text, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the percentage of the current location in a document
|
||||
---@param opts? table options for Top/Bot text, fixed width, and options passed to the stylize function
|
||||
---@return function # the statusline string for displaying the percentage of current document location
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.percentage() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.percentage(opts)
|
||||
opts = extend_tbl({ escape = false, fixed_width = true, edge_text = true }, opts)
|
||||
return function()
|
||||
local text = "%" .. (opts.fixed_width and (opts.edge_text and "2" or "3") or "") .. "p%%"
|
||||
if opts.edge_text then
|
||||
local current_line = vim.fn.line "."
|
||||
if current_line == 1 then
|
||||
text = "Top"
|
||||
elseif current_line == vim.fn.line "$" then
|
||||
text = "Bot"
|
||||
end
|
||||
end
|
||||
return status_utils.stylize(text, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current line and character in a document
|
||||
---@param opts? table options for padding the line and character locations and options passed to the stylize function
|
||||
---@return function # the statusline string for showing location in document line_num:char_num
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.ruler({ pad_ruler = { line = 3, char = 2 } }) }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.ruler(opts)
|
||||
opts = extend_tbl({ pad_ruler = { line = 3, char = 2 } }, opts)
|
||||
local padding_str = string.format("%%%dd:%%-%dd", opts.pad_ruler.line, opts.pad_ruler.char)
|
||||
return function()
|
||||
local line = vim.fn.line "."
|
||||
local char = vim.fn.virtcol "."
|
||||
return status_utils.stylize(string.format(padding_str, line, char), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current location as a scrollbar
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the scrollbar
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.scrollbar() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.scrollbar(opts)
|
||||
local sbar = { "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" }
|
||||
return function()
|
||||
local curr_line = vim.api.nvim_win_get_cursor(0)[1]
|
||||
local lines = vim.api.nvim_buf_line_count(0)
|
||||
local i = math.floor((curr_line - 1) / lines * #sbar) + 1
|
||||
if sbar[i] then return status_utils.stylize(string.rep(sbar[i], 2), opts) end
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider to simply show a close button icon
|
||||
---@param opts? table options passed to the stylize function and the kind of icon to use
|
||||
---@return string # the stylized icon
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.close_button() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.close_button(opts)
|
||||
opts = extend_tbl({ kind = "BufferClose" }, opts)
|
||||
return status_utils.stylize(get_icon(opts.kind), opts)
|
||||
end
|
||||
|
||||
--- A provider function for showing the current filetype
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the filetype
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.filetype() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.filetype(opts)
|
||||
return function(self)
|
||||
local buffer = vim.bo[self and self.bufnr or 0]
|
||||
return status_utils.stylize(string.lower(buffer.filetype), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current filename
|
||||
---@param opts? table options for argument to fnamemodify to format filename and options passed to the stylize function
|
||||
---@return function # the function for outputting the filename
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.filename() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.filename(opts)
|
||||
opts = extend_tbl({
|
||||
fallback = "Empty",
|
||||
fname = function(nr) return vim.api.nvim_buf_get_name(nr) end,
|
||||
modify = ":t",
|
||||
}, opts)
|
||||
return function(self)
|
||||
local filename = vim.fn.fnamemodify(opts.fname(self and self.bufnr or 0), opts.modify)
|
||||
return status_utils.stylize((filename == "" and opts.fallback or filename), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current file encoding
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the file encoding
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_encoding() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.file_encoding(opts)
|
||||
return function(self)
|
||||
local buf_enc = vim.bo[self and self.bufnr or 0].fenc
|
||||
return status_utils.stylize(string.upper(buf_enc ~= "" and buf_enc or vim.o.enc), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current file format
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the file format
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_format() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.file_format(opts)
|
||||
return function(self)
|
||||
local buf_format = vim.bo[self and self.bufnr or 0].fileformat
|
||||
return status_utils.stylize(string.upper(buf_format ~= "" and buf_format or vim.o.fileformat), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- Get a unique filepath between all buffers
|
||||
---@param opts? table options for function to get the buffer name, a buffer number, max length, and options passed to the stylize function
|
||||
---@return function # path to file that uniquely identifies each buffer
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.unique_path() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.unique_path(opts)
|
||||
opts = extend_tbl({
|
||||
buf_name = function(bufnr) return vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr), ":t") end,
|
||||
bufnr = 0,
|
||||
max_length = 16,
|
||||
}, opts)
|
||||
local function path_parts(bufnr)
|
||||
local parts = {}
|
||||
for match in (vim.api.nvim_buf_get_name(bufnr) .. "/"):gmatch("(.-)" .. "/") do
|
||||
table.insert(parts, match)
|
||||
end
|
||||
return parts
|
||||
end
|
||||
return function(self)
|
||||
opts.bufnr = self and self.bufnr or opts.bufnr
|
||||
local name = opts.buf_name(opts.bufnr)
|
||||
local unique_path = ""
|
||||
-- check for same buffer names under different dirs
|
||||
local current
|
||||
for _, value in ipairs(vim.t.bufs) do
|
||||
if name == opts.buf_name(value) and value ~= opts.bufnr then
|
||||
if not current then current = path_parts(opts.bufnr) end
|
||||
local other = path_parts(value)
|
||||
|
||||
for i = #current - 1, 1, -1 do
|
||||
if current[i] ~= other[i] then
|
||||
unique_path = current[i] .. "/"
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
return status_utils.stylize(
|
||||
(
|
||||
opts.max_length > 0
|
||||
and #unique_path > opts.max_length
|
||||
and string.sub(unique_path, 1, opts.max_length - 2) .. get_icon "Ellipsis" .. "/"
|
||||
) or unique_path,
|
||||
opts
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing if the current file is modifiable
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the indicator if the file is modified
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_modified() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.file_modified(opts)
|
||||
opts = extend_tbl({ str = "", icon = { kind = "FileModified" }, show_empty = true }, opts)
|
||||
return function(self)
|
||||
return status_utils.stylize(condition.file_modified((self or {}).bufnr) and opts.str or nil, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing if the current file is read-only
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the indicator if the file is read-only
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_read_only() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.file_read_only(opts)
|
||||
opts = extend_tbl({ str = "", icon = { kind = "FileReadOnly" }, show_empty = true }, opts)
|
||||
return function(self)
|
||||
return status_utils.stylize(condition.file_read_only((self or {}).bufnr) and opts.str or nil, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current filetype icon
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the filetype icon
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.file_icon() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.file_icon(opts)
|
||||
return function(self)
|
||||
local devicons_avail, devicons = pcall(require, "nvim-web-devicons")
|
||||
if not devicons_avail then return "" end
|
||||
local ft_icon, _ = devicons.get_icon(
|
||||
vim.fn.fnamemodify(vim.api.nvim_buf_get_name(self and self.bufnr or 0), ":t"),
|
||||
nil,
|
||||
{ default = true }
|
||||
)
|
||||
return status_utils.stylize(ft_icon, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current git branch
|
||||
---@param opts table options passed to the stylize function
|
||||
---@return function # the function for outputting the git branch
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.git_branch() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.git_branch(opts)
|
||||
return function(self) return status_utils.stylize(vim.b[self and self.bufnr or 0].gitsigns_head or "", opts) end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current git diff count of a specific type
|
||||
---@param opts? table options for type of git diff and options passed to the stylize function
|
||||
---@return function|nil # the function for outputting the git diff
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.git_diff({ type = "added" }) }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.git_diff(opts)
|
||||
if not opts or not opts.type then return end
|
||||
return function(self)
|
||||
local status = vim.b[self and self.bufnr or 0].gitsigns_status_dict
|
||||
return status_utils.stylize(
|
||||
status and status[opts.type] and status[opts.type] > 0 and tostring(status[opts.type]) or "",
|
||||
opts
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current diagnostic count of a specific severity
|
||||
---@param opts table options for severity of diagnostic and options passed to the stylize function
|
||||
---@return function|nil # the function for outputting the diagnostic count
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.diagnostics({ severity = "ERROR" }) }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.diagnostics(opts)
|
||||
if not opts or not opts.severity then return end
|
||||
return function(self)
|
||||
local bufnr = self and self.bufnr or 0
|
||||
local count = #vim.diagnostic.get(bufnr, opts.severity and { severity = vim.diagnostic.severity[opts.severity] })
|
||||
return status_utils.stylize(count ~= 0 and tostring(count) or "", opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the current progress of loading language servers
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # the function for outputting the LSP progress
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.lsp_progress() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.lsp_progress(opts)
|
||||
local spinner = utils.get_spinner("LSPLoading", 1) or { "" }
|
||||
return function()
|
||||
local _, Lsp = next(astronvim.lsp.progress)
|
||||
return status_utils.stylize(Lsp and (spinner[math.floor(vim.loop.hrtime() / 12e7) % #spinner + 1] .. table.concat({
|
||||
Lsp.title or "",
|
||||
Lsp.message or "",
|
||||
Lsp.percentage and "(" .. Lsp.percentage .. "%)" or "",
|
||||
}, " ")), opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing the connected LSP client names
|
||||
---@param opts? table options for explanding null_ls clients, max width percentage, and options passed to the stylize function
|
||||
---@return function # the function for outputting the LSP client names
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.lsp_client_names({ expand_null_ls = true, truncate = 0.25 }) }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.lsp_client_names(opts)
|
||||
opts = extend_tbl({ expand_null_ls = true, truncate = 0.25 }, opts)
|
||||
return function(self)
|
||||
local buf_client_names = {}
|
||||
for _, client in pairs(vim.lsp.get_active_clients { bufnr = self and self.bufnr or 0 }) do
|
||||
if client.name == "null-ls" and opts.expand_null_ls then
|
||||
local null_ls_sources = {}
|
||||
for _, type in ipairs { "FORMATTING", "DIAGNOSTICS" } do
|
||||
for _, source in ipairs(status_utils.null_ls_sources(vim.bo.filetype, type)) do
|
||||
null_ls_sources[source] = true
|
||||
end
|
||||
end
|
||||
vim.list_extend(buf_client_names, vim.tbl_keys(null_ls_sources))
|
||||
else
|
||||
table.insert(buf_client_names, client.name)
|
||||
end
|
||||
end
|
||||
local str = table.concat(buf_client_names, ", ")
|
||||
if type(opts.truncate) == "number" then
|
||||
local max_width = math.floor(status_utils.width() * opts.truncate)
|
||||
if #str > max_width then str = string.sub(str, 0, max_width) .. "…" end
|
||||
end
|
||||
return status_utils.stylize(str, opts)
|
||||
end
|
||||
end
|
||||
|
||||
--- A provider function for showing if treesitter is connected
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return function # function for outputting TS if treesitter is connected
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.treesitter_status() }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.treesitter_status(opts)
|
||||
return function() return status_utils.stylize(require("nvim-treesitter.parser").has_parser() and "TS" or "", opts) end
|
||||
end
|
||||
|
||||
--- A provider function for displaying a single string
|
||||
---@param opts? table options passed to the stylize function
|
||||
---@return string # the stylized statusline string
|
||||
-- @usage local heirline_component = { provider = require("astronvim.utils.status").provider.str({ str = "Hello" }) }
|
||||
-- @see astronvim.utils.status.utils.stylize
|
||||
function M.str(opts)
|
||||
opts = extend_tbl({ str = " " }, opts)
|
||||
return status_utils.stylize(opts.str, opts)
|
||||
end
|
||||
|
||||
return M
|
||||
202
lua/astronvim/utils/status/utils.lua
Normal file
202
lua/astronvim/utils/status/utils.lua
Normal file
@@ -0,0 +1,202 @@
|
||||
--- ### AstroNvim Status Utilities
|
||||
--
|
||||
-- Statusline related uitility functions
|
||||
--
|
||||
-- This module can be loaded with `local status_utils = require "astronvim.utils.status.utils"`
|
||||
--
|
||||
-- @module astronvim.utils.status.utils
|
||||
-- @copyright 2023
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local env = require "astronvim.utils.status.env"
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local extend_tbl = utils.extend_tbl
|
||||
local get_icon = utils.get_icon
|
||||
|
||||
--- Convert a component parameter table to a table that can be used with the component builder
|
||||
---@param opts? table a table of provider options
|
||||
---@param provider? function|string a provider in `M.providers`
|
||||
---@return table|false # the provider table that can be used in `M.component.builder`
|
||||
function M.build_provider(opts, provider, _)
|
||||
return opts
|
||||
and {
|
||||
provider = provider,
|
||||
opts = opts,
|
||||
condition = opts.condition,
|
||||
on_click = opts.on_click,
|
||||
update = opts.update,
|
||||
hl = opts.hl,
|
||||
}
|
||||
or false
|
||||
end
|
||||
|
||||
--- Convert key/value table of options to an array of providers for the component builder
|
||||
---@param opts table the table of options for the components
|
||||
---@param providers string[] an ordered list like array of providers that are configured in the options table
|
||||
---@param setup? function a function that takes provider options table, provider name, provider index and returns the setup provider table, optional, default is `M.build_provider`
|
||||
---@return table # the fully setup options table with the appropriately ordered providers
|
||||
function M.setup_providers(opts, providers, setup)
|
||||
setup = setup or M.build_provider
|
||||
for i, provider in ipairs(providers) do
|
||||
opts[i] = setup(opts[provider], provider, i)
|
||||
end
|
||||
return opts
|
||||
end
|
||||
|
||||
--- A utility function to get the width of the bar
|
||||
---@param is_winbar? boolean true if you want the width of the winbar, false if you want the statusline width
|
||||
---@return integer # the width of the specified bar
|
||||
function M.width(is_winbar)
|
||||
return vim.o.laststatus == 3 and not is_winbar and vim.o.columns or vim.api.nvim_win_get_width(0)
|
||||
end
|
||||
|
||||
--- Add left and/or right padding to a string
|
||||
---@param str string the string to add padding to
|
||||
---@param padding table a table of the format `{ left = 0, right = 0}` that defines the number of spaces to include to the left and the right of the string
|
||||
---@return string # the padded string
|
||||
function M.pad_string(str, padding)
|
||||
padding = padding or {}
|
||||
return str and str ~= "" and string.rep(" ", padding.left or 0) .. str .. string.rep(" ", padding.right or 0) or ""
|
||||
end
|
||||
|
||||
local function escape(str) return str:gsub("%%", "%%%%") end
|
||||
|
||||
--- A utility function to stylize a string with an icon from lspkind, separators, and left/right padding
|
||||
---@param str? string the string to stylize
|
||||
---@param opts? table options of `{ padding = { left = 0, right = 0 }, separator = { left = "|", right = "|" }, escape = true, show_empty = false, icon = { kind = "NONE", padding = { left = 0, right = 0 } } }`
|
||||
---@return string # the stylized string
|
||||
-- @usage local string = require("astronvim.utils.status").utils.stylize("Hello", { padding = { left = 1, right = 1 }, icon = { kind = "String" } })
|
||||
function M.stylize(str, opts)
|
||||
opts = extend_tbl({
|
||||
padding = { left = 0, right = 0 },
|
||||
separator = { left = "", right = "" },
|
||||
show_empty = false,
|
||||
escape = true,
|
||||
icon = { kind = "NONE", padding = { left = 0, right = 0 } },
|
||||
}, opts)
|
||||
local icon = M.pad_string(get_icon(opts.icon.kind), opts.icon.padding)
|
||||
return str
|
||||
and (str ~= "" or opts.show_empty)
|
||||
and opts.separator.left .. M.pad_string(icon .. (opts.escape and escape(str) or str), opts.padding) .. opts.separator.right
|
||||
or ""
|
||||
end
|
||||
|
||||
--- Surround component with separator and color adjustment
|
||||
---@param separator string|string[] the separator index to use in `env.separators`
|
||||
---@param color function|string|table the color to use as the separator foreground/component background
|
||||
---@param component table the component to surround
|
||||
---@param condition boolean|function the condition for displaying the surrounded component
|
||||
---@return table # the new surrounded component
|
||||
function M.surround(separator, color, component, condition)
|
||||
local function surround_color(self)
|
||||
local colors = type(color) == "function" and color(self) or color
|
||||
return type(colors) == "string" and { main = colors } or colors
|
||||
end
|
||||
|
||||
separator = type(separator) == "string" and env.separators[separator] or separator
|
||||
local surrounded = { condition = condition }
|
||||
if separator[1] ~= "" then
|
||||
table.insert(surrounded, {
|
||||
provider = separator[1],
|
||||
hl = function(self)
|
||||
local s_color = surround_color(self)
|
||||
if s_color then return { fg = s_color.main, bg = s_color.left } end
|
||||
end,
|
||||
})
|
||||
end
|
||||
table.insert(surrounded, {
|
||||
hl = function(self)
|
||||
local s_color = surround_color(self)
|
||||
if s_color then return { bg = s_color.main } end
|
||||
end,
|
||||
extend_tbl(component, {}),
|
||||
})
|
||||
if separator[2] ~= "" then
|
||||
table.insert(surrounded, {
|
||||
provider = separator[2],
|
||||
hl = function(self)
|
||||
local s_color = surround_color(self)
|
||||
if s_color then return { fg = s_color.main, bg = s_color.right } end
|
||||
end,
|
||||
})
|
||||
end
|
||||
return surrounded
|
||||
end
|
||||
|
||||
--- Encode a position to a single value that can be decoded later
|
||||
---@param line integer line number of position
|
||||
---@param col integer column number of position
|
||||
---@param winnr integer a window number
|
||||
---@return integer the encoded position
|
||||
function M.encode_pos(line, col, winnr) return bit.bor(bit.lshift(line, 16), bit.lshift(col, 6), winnr) end
|
||||
|
||||
--- Decode a previously encoded position to it's sub parts
|
||||
---@param c integer the encoded position
|
||||
---@return integer line, integer column, integer window
|
||||
function M.decode_pos(c) return bit.rshift(c, 16), bit.band(bit.rshift(c, 6), 1023), bit.band(c, 63) end
|
||||
|
||||
--- Get a list of registered null-ls providers for a given filetype
|
||||
---@param filetype string the filetype to search null-ls for
|
||||
---@return table # a table of null-ls sources
|
||||
function M.null_ls_providers(filetype)
|
||||
local registered = {}
|
||||
-- try to load null-ls
|
||||
local sources_avail, sources = pcall(require, "null-ls.sources")
|
||||
if sources_avail then
|
||||
-- get the available sources of a given filetype
|
||||
for _, source in ipairs(sources.get_available(filetype)) do
|
||||
-- get each source name
|
||||
for method in pairs(source.methods) do
|
||||
registered[method] = registered[method] or {}
|
||||
table.insert(registered[method], source.name)
|
||||
end
|
||||
end
|
||||
end
|
||||
-- return the found null-ls sources
|
||||
return registered
|
||||
end
|
||||
|
||||
--- Get the null-ls sources for a given null-ls method
|
||||
---@param filetype string the filetype to search null-ls for
|
||||
---@param method string the null-ls method (check null-ls documentation for available methods)
|
||||
---@return string[] # the available sources for the given filetype and method
|
||||
function M.null_ls_sources(filetype, method)
|
||||
local methods_avail, methods = pcall(require, "null-ls.methods")
|
||||
return methods_avail and M.null_ls_providers(filetype)[methods.internal[method]] or {}
|
||||
end
|
||||
|
||||
--- A helper function for decoding statuscolumn click events with mouse click pressed, modifier keys, as well as which signcolumn sign was clicked if any
|
||||
---@param self any the self parameter from Heirline component on_click.callback function call
|
||||
---@param minwid any the minwid parameter from Heirline component on_click.callback function call
|
||||
---@param clicks any the clicks parameter from Heirline component on_click.callback function call
|
||||
---@param button any the button parameter from Heirline component on_click.callback function call
|
||||
---@param mods any the button parameter from Heirline component on_click.callback function call
|
||||
---@return table # the argument table with the decoded mouse information and signcolumn signs information
|
||||
-- @usage local heirline_component = { on_click = { callback = function(...) local args = require("astronvim.utils.status").utils.statuscolumn_clickargs(...) end } }
|
||||
function M.statuscolumn_clickargs(self, minwid, clicks, button, mods)
|
||||
local args = {
|
||||
minwid = minwid,
|
||||
clicks = clicks,
|
||||
button = button,
|
||||
mods = mods,
|
||||
mousepos = vim.fn.getmousepos(),
|
||||
}
|
||||
if not self.signs then self.signs = {} end
|
||||
args.char = vim.fn.screenstring(args.mousepos.screenrow, args.mousepos.screencol)
|
||||
if args.char == " " then args.char = vim.fn.screenstring(args.mousepos.screenrow, args.mousepos.screencol - 1) end
|
||||
args.sign = self.signs[args.char]
|
||||
if not args.sign then -- update signs if not found on first click
|
||||
for _, sign_def in ipairs(vim.fn.sign_getdefined()) do
|
||||
if sign_def.text then self.signs[sign_def.text:gsub("%s", "")] = sign_def end
|
||||
end
|
||||
args.sign = self.signs[args.char]
|
||||
end
|
||||
vim.api.nvim_set_current_win(args.mousepos.winid)
|
||||
vim.api.nvim_win_set_cursor(0, { args.mousepos.line, 0 })
|
||||
return args
|
||||
end
|
||||
|
||||
return M
|
||||
230
lua/astronvim/utils/ui.lua
Normal file
230
lua/astronvim/utils/ui.lua
Normal file
@@ -0,0 +1,230 @@
|
||||
--- ### AstroNvim UI Options
|
||||
--
|
||||
-- Utility functions for easy UI toggles.
|
||||
--
|
||||
-- This module can be loaded with `local ui = require("astronvim.utils.ui")`
|
||||
--
|
||||
-- @module astronvim.utils.ui
|
||||
-- @see astronvim.utils
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local M = {}
|
||||
|
||||
local notify = require("astronvim.utils").notify
|
||||
|
||||
local function bool2str(bool) return bool and "on" or "off" end
|
||||
|
||||
--- Toggle notifications for UI toggles
|
||||
function M.toggle_ui_notifications() -- TODO: rename to toggle_notifications in AstroNvim v4
|
||||
vim.g.ui_notifications_enabled = not vim.g.ui_notifications_enabled
|
||||
notify(string.format("Notifications %s", bool2str(vim.g.ui_notifications_enabled)))
|
||||
end
|
||||
|
||||
--- Toggle autopairs
|
||||
function M.toggle_autopairs()
|
||||
local ok, autopairs = pcall(require, "nvim-autopairs")
|
||||
if ok then
|
||||
if autopairs.state.disabled then
|
||||
autopairs.enable()
|
||||
else
|
||||
autopairs.disable()
|
||||
end
|
||||
vim.g.autopairs_enabled = autopairs.state.disabled
|
||||
notify(string.format("autopairs %s", bool2str(not autopairs.state.disabled)))
|
||||
else
|
||||
notify "autopairs not available"
|
||||
end
|
||||
end
|
||||
|
||||
--- Toggle diagnostics
|
||||
function M.toggle_diagnostics()
|
||||
vim.g.diagnostics_mode = (vim.g.diagnostics_mode - 1) % 4
|
||||
vim.diagnostic.config(require("astronvim.utils.lsp").diagnostics[vim.g.diagnostics_mode])
|
||||
if vim.g.diagnostics_mode == 0 then
|
||||
notify "diagnostics off"
|
||||
elseif vim.g.diagnostics_mode == 1 then
|
||||
notify "only status diagnostics"
|
||||
elseif vim.g.diagnostics_mode == 2 then
|
||||
notify "virtual text off"
|
||||
else
|
||||
notify "all diagnostics on"
|
||||
end
|
||||
end
|
||||
|
||||
--- Toggle background="dark"|"light"
|
||||
function M.toggle_background()
|
||||
vim.go.background = vim.go.background == "light" and "dark" or "light"
|
||||
notify(string.format("background=%s", vim.go.background))
|
||||
end
|
||||
|
||||
--- Toggle cmp entrirely
|
||||
function M.toggle_cmp()
|
||||
vim.g.cmp_enabled = not vim.g.cmp_enabled
|
||||
local ok, _ = pcall(require, "cmp")
|
||||
notify(ok and string.format("completion %s", bool2str(vim.g.cmp_enabled)) or "completion not available")
|
||||
end
|
||||
|
||||
--- Toggle auto format
|
||||
function M.toggle_autoformat()
|
||||
vim.g.autoformat_enabled = not vim.g.autoformat_enabled
|
||||
notify(string.format("Global autoformatting %s", bool2str(vim.g.autoformat_enabled)))
|
||||
end
|
||||
|
||||
--- Toggle buffer local auto format
|
||||
function M.toggle_buffer_autoformat()
|
||||
local old_val = vim.b.autoformat_enabled
|
||||
if old_val == nil then old_val = vim.g.autoformat_enabled end
|
||||
vim.b.autoformat_enabled = not old_val
|
||||
notify(string.format("Buffer autoformatting %s", bool2str(vim.b.autoformat_enabled)))
|
||||
end
|
||||
|
||||
--- Toggle buffer semantic token highlighting for all language servers that support it
|
||||
---@param bufnr? number the buffer to toggle the clients on
|
||||
function M.toggle_buffer_semantic_tokens(bufnr)
|
||||
vim.b.semantic_tokens_enabled = not vim.b.semantic_tokens_enabled
|
||||
for _, client in ipairs(vim.lsp.get_active_clients()) do
|
||||
if client.server_capabilities.semanticTokensProvider then
|
||||
vim.lsp.semantic_tokens[vim.b.semantic_tokens_enabled and "start" or "stop"](bufnr or 0, client.id)
|
||||
notify(string.format("Buffer lsp semantic highlighting %s", bool2str(vim.b.semantic_tokens_enabled)))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
--- Toggle buffer LSP inlay hints
|
||||
---@param bufnr? number the buffer to toggle the clients on
|
||||
function M.toggle_buffer_inlay_hints(bufnr)
|
||||
vim.b.inlay_hints_enabled = not vim.b.inlay_hints_enabled
|
||||
-- TODO: remove check after dropping support for Neovim v0.9
|
||||
if vim.lsp.buf.inlay_hint then
|
||||
vim.lsp.buf.inlay_hint(bufnr or 0, vim.b.inlay_hints_enabled)
|
||||
notify(string.format("Inlay hints %s", bool2str(vim.b.inlay_hints_enabled)))
|
||||
end
|
||||
end
|
||||
|
||||
--- Toggle codelens
|
||||
function M.toggle_codelens()
|
||||
vim.g.codelens_enabled = not vim.g.codelens_enabled
|
||||
if not vim.g.codelens_enabled then vim.lsp.codelens.clear() end
|
||||
notify(string.format("CodeLens %s", bool2str(vim.g.codelens_enabled)))
|
||||
end
|
||||
|
||||
--- Toggle showtabline=2|0
|
||||
function M.toggle_tabline()
|
||||
vim.opt.showtabline = vim.opt.showtabline:get() == 0 and 2 or 0
|
||||
notify(string.format("tabline %s", bool2str(vim.opt.showtabline:get() == 2)))
|
||||
end
|
||||
|
||||
--- Toggle conceal=2|0
|
||||
function M.toggle_conceal()
|
||||
vim.opt.conceallevel = vim.opt.conceallevel:get() == 0 and 2 or 0
|
||||
notify(string.format("conceal %s", bool2str(vim.opt.conceallevel:get() == 2)))
|
||||
end
|
||||
|
||||
--- Toggle laststatus=3|2|0
|
||||
function M.toggle_statusline()
|
||||
local laststatus = vim.opt.laststatus:get()
|
||||
local status
|
||||
if laststatus == 0 then
|
||||
vim.opt.laststatus = 2
|
||||
status = "local"
|
||||
elseif laststatus == 2 then
|
||||
vim.opt.laststatus = 3
|
||||
status = "global"
|
||||
elseif laststatus == 3 then
|
||||
vim.opt.laststatus = 0
|
||||
status = "off"
|
||||
end
|
||||
notify(string.format("statusline %s", status))
|
||||
end
|
||||
|
||||
--- Toggle signcolumn="auto"|"no"
|
||||
function M.toggle_signcolumn()
|
||||
if vim.wo.signcolumn == "no" then
|
||||
vim.wo.signcolumn = "yes"
|
||||
elseif vim.wo.signcolumn == "yes" then
|
||||
vim.wo.signcolumn = "auto"
|
||||
else
|
||||
vim.wo.signcolumn = "no"
|
||||
end
|
||||
notify(string.format("signcolumn=%s", vim.wo.signcolumn))
|
||||
end
|
||||
|
||||
--- Set the indent and tab related numbers
|
||||
function M.set_indent()
|
||||
local input_avail, input = pcall(vim.fn.input, "Set indent value (>0 expandtab, <=0 noexpandtab): ")
|
||||
if input_avail then
|
||||
local indent = tonumber(input)
|
||||
if not indent or indent == 0 then return end
|
||||
vim.bo.expandtab = (indent > 0) -- local to buffer
|
||||
indent = math.abs(indent)
|
||||
vim.bo.tabstop = indent -- local to buffer
|
||||
vim.bo.softtabstop = indent -- local to buffer
|
||||
vim.bo.shiftwidth = indent -- local to buffer
|
||||
notify(string.format("indent=%d %s", indent, vim.bo.expandtab and "expandtab" or "noexpandtab"))
|
||||
end
|
||||
end
|
||||
|
||||
--- Change the number display modes
|
||||
function M.change_number()
|
||||
local number = vim.wo.number -- local to window
|
||||
local relativenumber = vim.wo.relativenumber -- local to window
|
||||
if not number and not relativenumber then
|
||||
vim.wo.number = true
|
||||
elseif number and not relativenumber then
|
||||
vim.wo.relativenumber = true
|
||||
elseif number and relativenumber then
|
||||
vim.wo.number = false
|
||||
else -- not number and relativenumber
|
||||
vim.wo.relativenumber = false
|
||||
end
|
||||
notify(string.format("number %s, relativenumber %s", bool2str(vim.wo.number), bool2str(vim.wo.relativenumber)))
|
||||
end
|
||||
|
||||
--- Toggle spell
|
||||
function M.toggle_spell()
|
||||
vim.wo.spell = not vim.wo.spell -- local to window
|
||||
notify(string.format("spell %s", bool2str(vim.wo.spell)))
|
||||
end
|
||||
|
||||
--- Toggle paste
|
||||
function M.toggle_paste()
|
||||
vim.opt.paste = not vim.opt.paste:get() -- local to window
|
||||
notify(string.format("paste %s", bool2str(vim.opt.paste:get())))
|
||||
end
|
||||
|
||||
--- Toggle wrap
|
||||
function M.toggle_wrap()
|
||||
vim.wo.wrap = not vim.wo.wrap -- local to window
|
||||
notify(string.format("wrap %s", bool2str(vim.wo.wrap)))
|
||||
end
|
||||
|
||||
--- Toggle syntax highlighting and treesitter
|
||||
function M.toggle_syntax()
|
||||
local ts_avail, parsers = pcall(require, "nvim-treesitter.parsers")
|
||||
if vim.g.syntax_on then -- global var for on//off
|
||||
if ts_avail and parsers.has_parser() then vim.cmd.TSBufDisable "highlight" end
|
||||
vim.cmd.syntax "off" -- set vim.g.syntax_on = false
|
||||
else
|
||||
if ts_avail and parsers.has_parser() then vim.cmd.TSBufEnable "highlight" end
|
||||
vim.cmd.syntax "on" -- set vim.g.syntax_on = true
|
||||
end
|
||||
notify(string.format("syntax %s", bool2str(vim.g.syntax_on)))
|
||||
end
|
||||
|
||||
--- Toggle URL/URI syntax highlighting rules
|
||||
function M.toggle_url_match()
|
||||
vim.g.highlighturl_enabled = not vim.g.highlighturl_enabled
|
||||
require("astronvim.utils").set_url_match()
|
||||
end
|
||||
|
||||
local last_active_foldcolumn
|
||||
--- Toggle foldcolumn=0|1
|
||||
function M.toggle_foldcolumn()
|
||||
local curr_foldcolumn = vim.wo.foldcolumn
|
||||
if curr_foldcolumn ~= "0" then last_active_foldcolumn = curr_foldcolumn end
|
||||
vim.wo.foldcolumn = curr_foldcolumn == "0" and (last_active_foldcolumn or "1") or "0"
|
||||
notify(string.format("foldcolumn=%s", vim.wo.foldcolumn))
|
||||
end
|
||||
|
||||
return M
|
||||
339
lua/astronvim/utils/updater.lua
Normal file
339
lua/astronvim/utils/updater.lua
Normal file
@@ -0,0 +1,339 @@
|
||||
--- ### AstroNvim Updater
|
||||
--
|
||||
-- AstroNvim Updater utilities to use within AstroNvim and user configurations.
|
||||
--
|
||||
-- This module can also loaded with `local updater = require("astronvim.utils.updater")`
|
||||
--
|
||||
-- @module astronvim.utils.updater
|
||||
-- @see astronvim.utils
|
||||
-- @copyright 2022
|
||||
-- @license GNU General Public License v3.0
|
||||
|
||||
local git = require "astronvim.utils.git"
|
||||
|
||||
local M = {}
|
||||
|
||||
local utils = require "astronvim.utils"
|
||||
local notify = utils.notify
|
||||
|
||||
local function echo(messages)
|
||||
-- if no parameter provided, echo a new line
|
||||
messages = messages or { { "\n" } }
|
||||
if type(messages) == "table" then vim.api.nvim_echo(messages, false, {}) end
|
||||
end
|
||||
|
||||
local function confirm_prompt(messages, type)
|
||||
return vim.fn.confirm(messages, "&Yes\n&No", (type == "Error" or type == "Warning") and 2 or 1, type or "Question")
|
||||
== 1
|
||||
end
|
||||
|
||||
--- Helper function to generate AstroNvim snapshots (For internal use only)
|
||||
---@param write? boolean Whether or not to write to the snapshot file (default: false)
|
||||
---@return table # The plugin specification table of the snapshot
|
||||
function M.generate_snapshot(write)
|
||||
local file
|
||||
local prev_snapshot = require(astronvim.updater.snapshot.module)
|
||||
for _, plugin in ipairs(prev_snapshot) do
|
||||
prev_snapshot[plugin[1]] = plugin
|
||||
end
|
||||
local plugins = assert(require("lazy").plugins())
|
||||
local function git_commit(dir)
|
||||
local commit = assert(utils.cmd({ "git", "-C", dir, "rev-parse", "HEAD" }, false))
|
||||
if commit then return vim.trim(commit) end
|
||||
end
|
||||
if write == true then
|
||||
file = assert(io.open(astronvim.updater.snapshot.path, "w"))
|
||||
file:write "return {\n"
|
||||
end
|
||||
local snapshot = vim.tbl_map(function(plugin)
|
||||
if not plugin[1] and plugin.name == "lazy.nvim" then plugin[1] = "folke/lazy.nvim" end
|
||||
plugin = { plugin[1], commit = git_commit(plugin.dir), version = plugin.version }
|
||||
if prev_snapshot[plugin[1]] and prev_snapshot[plugin[1]].version then
|
||||
plugin.version = prev_snapshot[plugin[1]].version
|
||||
end
|
||||
if file then
|
||||
file:write((" { %q, "):format(plugin[1]))
|
||||
if plugin.version then
|
||||
file:write(("version = %q"):format(plugin.version))
|
||||
else
|
||||
file:write(("commit = %q"):format(plugin.commit))
|
||||
end
|
||||
file:write ", optional = true },\n"
|
||||
end
|
||||
return plugin
|
||||
end, plugins)
|
||||
if file then
|
||||
file:write "}"
|
||||
file:close()
|
||||
end
|
||||
return snapshot
|
||||
end
|
||||
|
||||
--- Get the current AstroNvim version
|
||||
---@param quiet? boolean Whether to quietly execute or send a notification
|
||||
---@return string # The current AstroNvim version string
|
||||
function M.version(quiet)
|
||||
local version = astronvim.install.version or git.current_version(false) or "unknown"
|
||||
if astronvim.updater.options.channel ~= "stable" then version = ("nightly (%s)"):format(version) end
|
||||
if version and not quiet then notify("Version: " .. version) end
|
||||
return version
|
||||
end
|
||||
|
||||
--- Get the full AstroNvim changelog
|
||||
---@param quiet? boolean Whether to quietly execute or display the changelog
|
||||
---@return table # The current AstroNvim changelog table of commit messages
|
||||
function M.changelog(quiet)
|
||||
local summary = {}
|
||||
vim.list_extend(summary, git.pretty_changelog(git.get_commit_range()))
|
||||
if not quiet then echo(summary) end
|
||||
return summary
|
||||
end
|
||||
|
||||
--- Attempt an update of AstroNvim
|
||||
---@param target string The target if checking out a specific tag or commit or nil if just pulling
|
||||
local function attempt_update(target, opts)
|
||||
-- if updating to a new stable version or a specific commit checkout the provided target
|
||||
if opts.channel == "stable" or opts.commit then
|
||||
return git.checkout(target, false)
|
||||
-- if no target, pull the latest
|
||||
else
|
||||
return git.pull(false)
|
||||
end
|
||||
end
|
||||
|
||||
--- Cancelled update message
|
||||
local cancelled_message = { { "Update cancelled", "WarningMsg" } }
|
||||
|
||||
--- Sync Packer and then update Mason
|
||||
function M.update_packages()
|
||||
require("lazy").sync { wait = true }
|
||||
require("astronvim.utils.mason").update_all()
|
||||
end
|
||||
|
||||
--- Create a table of options for the currently installed AstroNvim version
|
||||
---@param write? boolean Whether or not to write to the rollback file (default: false)
|
||||
---@return table # The table of updater options
|
||||
function M.create_rollback(write)
|
||||
local snapshot = { branch = git.current_branch(), commit = git.local_head() }
|
||||
if snapshot.branch == "HEAD" then snapshot.branch = "main" end
|
||||
snapshot.remote = git.branch_remote(snapshot.branch, false) or "origin"
|
||||
snapshot.remotes = { [snapshot.remote] = git.remote_url(snapshot.remote) }
|
||||
|
||||
if write == true then
|
||||
local file = assert(io.open(astronvim.updater.rollback_file, "w"))
|
||||
file:write("return " .. vim.inspect(snapshot, { newline = " ", indent = "" }))
|
||||
file:close()
|
||||
end
|
||||
|
||||
return snapshot
|
||||
end
|
||||
|
||||
--- AstroNvim's rollback to saved previous version function
|
||||
function M.rollback()
|
||||
local rollback_avail, rollback_opts = pcall(dofile, astronvim.updater.rollback_file)
|
||||
if not rollback_avail then
|
||||
notify("No rollback file available", vim.log.levels.ERROR)
|
||||
return
|
||||
end
|
||||
M.update(rollback_opts)
|
||||
end
|
||||
|
||||
--- Check if an update is available
|
||||
---@param opts? table the settings to use for checking for an update
|
||||
---@return table|boolean? # The information of an available update (`{ source = string, target = string }`), false if no update is available, or nil if there is an error
|
||||
function M.update_available(opts)
|
||||
if not opts then opts = astronvim.updater.options end
|
||||
opts = require("astronvim.utils").extend_tbl({ remote = "origin" }, opts)
|
||||
-- if the git command is not available, then throw an error
|
||||
if not git.available() then
|
||||
notify(
|
||||
"git command is not available, please verify it is accessible in a command line. This may be an issue with your PATH",
|
||||
vim.log.levels.ERROR
|
||||
)
|
||||
return
|
||||
end
|
||||
|
||||
-- if installed with an external package manager, disable the internal updater
|
||||
if not git.is_repo() then
|
||||
notify("Updater not available for non-git installations", vim.log.levels.ERROR)
|
||||
return
|
||||
end
|
||||
-- set up any remotes defined by the user if they do not exist
|
||||
for remote, entry in pairs(opts.remotes and opts.remotes or {}) do
|
||||
local url = git.parse_remote_url(entry)
|
||||
local current_url = git.remote_url(remote, false)
|
||||
local check_needed = false
|
||||
if not current_url then
|
||||
git.remote_add(remote, url)
|
||||
check_needed = true
|
||||
elseif
|
||||
current_url ~= url
|
||||
and confirm_prompt(
|
||||
("Remote %s is currently: %s\n" .. "Would you like us to set it to %s ?"):format(remote, current_url, url)
|
||||
)
|
||||
then
|
||||
git.remote_update(remote, url)
|
||||
check_needed = true
|
||||
end
|
||||
if check_needed and git.remote_url(remote, false) ~= url then
|
||||
vim.api.nvim_err_writeln("Error setting up remote " .. remote .. " to " .. url)
|
||||
return
|
||||
end
|
||||
end
|
||||
local is_stable = opts.channel == "stable"
|
||||
if is_stable then
|
||||
opts.branch = "main"
|
||||
elseif not opts.branch then
|
||||
opts.branch = "nightly"
|
||||
end
|
||||
-- setup branch if missing
|
||||
if not git.ref_verify(opts.remote .. "/" .. opts.branch, false) then
|
||||
git.remote_set_branches(opts.remote, opts.branch, false)
|
||||
end
|
||||
-- fetch the latest remote
|
||||
if not git.fetch(opts.remote) then
|
||||
vim.api.nvim_err_writeln("Error fetching remote: " .. opts.remote)
|
||||
return
|
||||
end
|
||||
-- switch to the necessary branch only if not on the stable channel
|
||||
if not is_stable then
|
||||
local local_branch = (opts.remote == "origin" and "" or (opts.remote .. "_")) .. opts.branch
|
||||
if git.current_branch() ~= local_branch then
|
||||
echo {
|
||||
{ "Switching to branch: " },
|
||||
{ opts.remote .. "/" .. opts.branch .. "\n\n", "String" },
|
||||
}
|
||||
if not git.checkout(local_branch, false) then
|
||||
git.checkout("-b " .. local_branch .. " " .. opts.remote .. "/" .. opts.branch, false)
|
||||
end
|
||||
end
|
||||
-- check if the branch was switched to successfully
|
||||
if git.current_branch() ~= local_branch then
|
||||
vim.api.nvim_err_writeln("Error checking out branch: " .. opts.remote .. "/" .. opts.branch)
|
||||
return
|
||||
end
|
||||
end
|
||||
local update = { source = git.local_head() }
|
||||
if is_stable then -- if stable get tag commit
|
||||
local version_search = opts.version or "latest"
|
||||
update.version = git.latest_version(git.get_versions(version_search))
|
||||
if not update.version then -- continue only if stable version is found
|
||||
vim.api.nvim_err_writeln("Error finding version: " .. version_search)
|
||||
return
|
||||
end
|
||||
update.target = git.tag_commit(update.version)
|
||||
elseif opts.commit then -- if commit specified use it
|
||||
update.target = git.branch_contains(opts.remote, opts.branch, opts.commit) and opts.commit or nil
|
||||
else -- get most recent commit
|
||||
update.target = git.remote_head(opts.remote, opts.branch)
|
||||
end
|
||||
|
||||
if not update.source or not update.target then -- continue if current and target commits were found
|
||||
vim.api.nvim_err_writeln "Error checking for updates"
|
||||
return
|
||||
elseif update.source ~= update.target then
|
||||
-- update available
|
||||
return update
|
||||
else
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
--- AstroNvim's updater function
|
||||
---@param opts? table the settings to use for the update
|
||||
function M.update(opts)
|
||||
if not opts then opts = astronvim.updater.options end
|
||||
opts = require("astronvim.utils").extend_tbl(
|
||||
{ remote = "origin", show_changelog = true, sync_plugins = true, auto_quit = false },
|
||||
opts
|
||||
)
|
||||
local available_update = M.update_available(opts)
|
||||
if available_update == nil then
|
||||
return
|
||||
elseif not available_update then -- continue if current and target commits were found
|
||||
notify "No updates available"
|
||||
elseif -- prompt user if they want to accept update
|
||||
not opts.skip_prompts
|
||||
and not confirm_prompt(
|
||||
("Update available to %s\nUpdating requires a restart, continue?"):format(
|
||||
available_update.version or available_update.target
|
||||
)
|
||||
)
|
||||
then
|
||||
echo(cancelled_message)
|
||||
return
|
||||
else -- perform update
|
||||
local source, target = available_update.source, available_update.target
|
||||
M.create_rollback(true) -- create rollback file before updating
|
||||
-- calculate and print the changelog
|
||||
local changelog = git.get_commit_range(source, target)
|
||||
local breaking = git.breaking_changes(changelog)
|
||||
if
|
||||
#breaking > 0
|
||||
and not opts.skip_prompts
|
||||
and not confirm_prompt(
|
||||
("Update contains the following breaking changes:\n%s\nWould you like to continue?"):format(
|
||||
table.concat(breaking, "\n")
|
||||
),
|
||||
"Warning"
|
||||
)
|
||||
then
|
||||
echo(cancelled_message)
|
||||
return
|
||||
end
|
||||
-- attempt an update
|
||||
local updated = attempt_update(target, opts)
|
||||
-- check for local file conflicts and prompt user to continue or abort
|
||||
if
|
||||
not updated
|
||||
and not opts.skip_prompts
|
||||
and not confirm_prompt(
|
||||
"Unable to pull due to local modifications to base files.\nReset local files and continue?",
|
||||
"Error"
|
||||
)
|
||||
then
|
||||
echo(cancelled_message)
|
||||
return
|
||||
-- if continued and there were errors reset the base config and attempt another update
|
||||
elseif not updated then
|
||||
git.hard_reset(source)
|
||||
updated = attempt_update(target, opts)
|
||||
end
|
||||
-- if update was unsuccessful throw an error
|
||||
if not updated then
|
||||
vim.api.nvim_err_writeln "Error occurred performing update"
|
||||
return
|
||||
end
|
||||
-- print a summary of the update with the changelog
|
||||
local summary = {
|
||||
{ "AstroNvim updated successfully to ", "Title" },
|
||||
{ git.current_version(), "String" },
|
||||
{ "!\n", "Title" },
|
||||
{
|
||||
opts.auto_quit and "AstroNvim will now update plugins and quit.\n\n"
|
||||
or "After plugins update, please restart.\n\n",
|
||||
"WarningMsg",
|
||||
},
|
||||
}
|
||||
if opts.show_changelog and #changelog > 0 then
|
||||
vim.list_extend(summary, { { "Changelog:\n", "Title" } })
|
||||
vim.list_extend(summary, git.pretty_changelog(changelog))
|
||||
end
|
||||
echo(summary)
|
||||
|
||||
-- if the user wants to auto quit, create an autocommand to quit AstroNvim on the update completing
|
||||
if opts.auto_quit then
|
||||
vim.api.nvim_create_autocmd("User", {
|
||||
desc = "Auto quit AstroNvim after update completes",
|
||||
pattern = "AstroUpdateComplete",
|
||||
command = "quitall",
|
||||
})
|
||||
end
|
||||
|
||||
require("lazy.core.plugin").load() -- force immediate reload of lazy
|
||||
if opts.sync_plugins then require("lazy").sync { wait = true } end
|
||||
utils.event "UpdateComplete"
|
||||
end
|
||||
end
|
||||
|
||||
return M
|
||||
Reference in New Issue
Block a user