470 lines
13 KiB
Lua
470 lines
13 KiB
Lua
local log = require("log")
|
|
|
|
local M = {}
|
|
|
|
M.os_name = vim.uv.os_uname().sysname
|
|
|
|
---@alias OutputStream "stdout" | "stderr" | "in_place"
|
|
|
|
---@class ow.FormatOptions
|
|
---@field buf? integer Buffer to apply formatting to
|
|
---@field cmd string[] Command to run. The following keywords get replaces by the specified values:
|
|
--- * %file% - path to the file for `buf`
|
|
--- * %filename% - name of the file for `buf`
|
|
--- * %row_start% - first row of selection
|
|
--- * %row_end% - last row of selection
|
|
--- * %col_start% - first column position of selection
|
|
--- * %col_end% - last column position of selection
|
|
--- * %byte_start% - byte count of first cell in selection
|
|
--- * %byte_end% - byte count of last cell in selection
|
|
---@field output? OutputStream What stream to use as the result. May be one of `stdout`, `stderr` or `in_place`.
|
|
---@field auto_indent? boolean Perform auto indent on formatted range
|
|
---@field only_selection? boolean Only send the selected lines to `stdin`
|
|
---@field ignore_ret? boolean Ignore non-zero return codes
|
|
---@field ignore_stderr? boolean Ignore stderr output when not using stderr for output
|
|
---@field env? table<string, string> Map of environment variables
|
|
|
|
--- Format buffer
|
|
---@param opts ow.FormatOptions
|
|
function M.format(opts)
|
|
opts = {
|
|
buf = opts.buf or vim.api.nvim_get_current_buf(),
|
|
cmd = opts.cmd,
|
|
output = opts.output or "stdout",
|
|
auto_indent = opts.auto_indent,
|
|
only_selection = opts.only_selection,
|
|
ignore_ret = opts.ignore_ret,
|
|
ignore_stderr = opts.ignore_stderr,
|
|
env = opts.env,
|
|
}
|
|
|
|
local file = vim.api.nvim_buf_get_name(opts.buf)
|
|
local filename = vim.fn.fnamemodify(file, ":t")
|
|
|
|
local mode = vim.fn.mode()
|
|
local is_visual = mode == "v" or mode == "V" or mode == ""
|
|
|
|
-- All 1-indexed, inclusive
|
|
local row_start, row_end
|
|
local col_start, col_end
|
|
if is_visual then
|
|
row_start, col_start = unpack(vim.fn.getpos("v"), 2, 3)
|
|
row_end, col_end = unpack(vim.fn.getpos("."), 2, 3)
|
|
|
|
if
|
|
row_start > row_end
|
|
or (row_start == row_end and col_start > col_end)
|
|
then
|
|
row_start, row_end, col_start, col_end =
|
|
row_end, row_start, col_end, col_start
|
|
end
|
|
|
|
if mode == "V" then
|
|
col_start = 1
|
|
col_end = #vim.api.nvim_buf_get_lines(
|
|
opts.buf,
|
|
row_end - 1,
|
|
row_end,
|
|
false
|
|
)[1]
|
|
end
|
|
else
|
|
row_start = 1
|
|
col_start = 1
|
|
row_end = vim.api.nvim_buf_line_count(opts.buf)
|
|
col_end = #vim.api.nvim_buf_get_lines(
|
|
opts.buf,
|
|
row_end - 1,
|
|
row_end,
|
|
false
|
|
)[1]
|
|
end
|
|
|
|
local byte_start = vim.api.nvim_buf_get_offset(opts.buf, row_start - 1)
|
|
+ col_start
|
|
- 1
|
|
local byte_end = vim.api.nvim_buf_get_offset(opts.buf, row_end - 1)
|
|
+ col_end
|
|
|
|
local input
|
|
if is_visual and opts.only_selection then
|
|
input = vim.api.nvim_buf_get_text(
|
|
opts.buf,
|
|
row_start - 1,
|
|
col_start - 1,
|
|
row_end - 1,
|
|
col_end,
|
|
{}
|
|
)
|
|
else
|
|
input = vim.api.nvim_buf_get_lines(opts.buf, 0, -1, false)
|
|
end
|
|
|
|
local tmp
|
|
if opts.output == "in_place" then
|
|
tmp = os.tmpname()
|
|
vim.fn.writefile(input, tmp, "s")
|
|
file = tmp
|
|
end
|
|
|
|
for i, arg in ipairs(opts.cmd) do
|
|
arg = arg:gsub("%%file%%", file)
|
|
arg = arg:gsub("%%filename%%", filename)
|
|
if is_visual then
|
|
arg = arg:gsub("%%row_start%%", row_start)
|
|
arg = arg:gsub("%%row_end%%", row_end)
|
|
arg = arg:gsub("%%col_start%%", col_start)
|
|
arg = arg:gsub("%%col_end%%", col_end)
|
|
arg = arg:gsub("%%byte_start%%", byte_start)
|
|
arg = arg:gsub("%%byte_end%%", byte_end)
|
|
end
|
|
opts.cmd[i] = arg
|
|
end
|
|
|
|
local resp = vim.system(opts.cmd, {
|
|
stdin = input,
|
|
env = opts.env,
|
|
}):wait()
|
|
local stdout = resp.stdout or ""
|
|
local stderr = resp.stderr or ""
|
|
|
|
local tmp_out
|
|
if tmp then
|
|
local f = io.open(tmp, "r")
|
|
if not f then
|
|
return
|
|
end
|
|
tmp_out = f:read("*a")
|
|
f:close()
|
|
os.remove(tmp)
|
|
end
|
|
|
|
if
|
|
(not opts.ignore_ret and resp.code ~= 0)
|
|
or (opts.output ~= "stderr" and not opts.ignore_stderr and stderr ~= "")
|
|
then
|
|
local msg = ""
|
|
if stderr ~= "" then
|
|
msg = ":\n" .. stderr
|
|
end
|
|
|
|
log.error("Failed to format (%d)%s", resp.code, msg)
|
|
return
|
|
end
|
|
|
|
local output = ""
|
|
if opts.output == "stdout" then
|
|
output = stdout
|
|
elseif opts.output == "stderr" then
|
|
output = stderr
|
|
elseif opts.output == "in_place" then
|
|
output = tmp_out or ""
|
|
end
|
|
output = output:gsub("%s+$", "")
|
|
|
|
local old_lines = input
|
|
local new_lines =
|
|
vim.split(output:gsub("\r\n", "\n"), "\n", { plain = true })
|
|
|
|
local diff = vim.text.diff(
|
|
table.concat(old_lines, "\n"),
|
|
table.concat(new_lines, "\n"),
|
|
{ result_type = "indices", algorithm = "histogram" }
|
|
)
|
|
|
|
if not diff or #diff == 0 then
|
|
return
|
|
end
|
|
|
|
---@type lsp.TextEdit[]
|
|
local text_edits = {}
|
|
|
|
---@diagnostic disable-next-line: param-type-mismatch
|
|
for _, hunk in ipairs(diff) do
|
|
local old_start, old_count, new_start, new_count = unpack(hunk)
|
|
|
|
local lines = {}
|
|
for j = new_start, new_start + new_count - 1 do
|
|
table.insert(lines, new_lines[j])
|
|
end
|
|
|
|
local new_text = table.concat(lines, "\n") .. "\n"
|
|
if new_count == 0 then
|
|
new_text = ""
|
|
end
|
|
|
|
local start_line = row_start - 1 + old_start - 1
|
|
local end_line = row_start - 1 + old_start - 1 + old_count
|
|
if old_count == 0 then
|
|
-- Insertion: old_start means "after line N" (where N is 1-indexed),
|
|
-- which equals the 0-indexed position old_start
|
|
start_line = start_line + 1
|
|
end_line = end_line + 1
|
|
end
|
|
|
|
table.insert(text_edits, {
|
|
range = {
|
|
start = {
|
|
line = start_line,
|
|
character = 0,
|
|
},
|
|
["end"] = {
|
|
line = end_line,
|
|
character = 0,
|
|
},
|
|
},
|
|
newText = new_text,
|
|
})
|
|
end
|
|
|
|
local view = vim.fn.winsaveview()
|
|
|
|
vim.lsp.util.apply_text_edits(text_edits, opts.buf, "utf-16")
|
|
|
|
if opts.auto_indent then
|
|
vim.api.nvim_cmd({
|
|
cmd = "normal",
|
|
args = { "==" },
|
|
bang = true,
|
|
range = {
|
|
row_start,
|
|
math.min(row_end, vim.api.nvim_buf_line_count(opts.buf)),
|
|
},
|
|
}, { output = false })
|
|
end
|
|
|
|
vim.fn.winrestview(view)
|
|
end
|
|
|
|
--- Check if `val` is a list of type `t` (if given)
|
|
---@param val any
|
|
---@param kt type
|
|
---@param vt type
|
|
---@return boolean
|
|
function M.is_map(val, kt, vt)
|
|
if type(val) ~= "table" then
|
|
return false
|
|
end
|
|
|
|
for k, v in pairs(val) do
|
|
if type(k) ~= kt then
|
|
return false
|
|
end
|
|
|
|
if type(v) ~= vt then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--- Check if `val` is a list of type `t` (if given)
|
|
---@param val any
|
|
---@param t? type
|
|
---@return boolean
|
|
function M.is_list(val, t)
|
|
if not vim.islist(val) then
|
|
return false
|
|
end
|
|
|
|
for k, v in pairs(val) do
|
|
if type(k) ~= "number" then
|
|
return false
|
|
end
|
|
|
|
if t and type(v) ~= t then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--- Check if `val` is a list of type `t` (if given), or nil
|
|
---@param val? any
|
|
---@param t? type
|
|
---@return boolean
|
|
function M.is_list_or_nil(val, t)
|
|
if val == nil then
|
|
return true
|
|
else
|
|
return M.is_list(val, t)
|
|
end
|
|
end
|
|
|
|
---@class ow.Util.DebounceHandle
|
|
---@field cancel fun()
|
|
---@field flush fun()
|
|
---@field pending fun(): boolean
|
|
---@field close fun()
|
|
|
|
---@generic F: fun(...)
|
|
---@param fn F
|
|
---@param delay integer
|
|
---@return F, ow.Util.DebounceHandle
|
|
function M.debounce(fn, delay)
|
|
local timer = assert(vim.uv.new_timer())
|
|
local args ---@type table?
|
|
local gen = 0
|
|
local fired_gen = 0
|
|
|
|
local cb_main = vim.schedule_wrap(function()
|
|
-- Identity check: the libuv fire may have been superseded by a
|
|
-- re-arm or a cancel between the timer firing and this scheduled
|
|
-- callback running.
|
|
if fired_gen ~= gen or args == nil then
|
|
return
|
|
end
|
|
local a = args
|
|
args = nil
|
|
fn(vim.F.unpack_len(a))
|
|
end)
|
|
|
|
local cb_uv = function()
|
|
fired_gen = gen
|
|
cb_main()
|
|
end
|
|
|
|
local function call(...)
|
|
args = vim.F.pack_len(...)
|
|
gen = gen + 1
|
|
timer:start(delay, 0, cb_uv)
|
|
end
|
|
|
|
return call,
|
|
{
|
|
cancel = function()
|
|
timer:stop()
|
|
args = nil
|
|
end,
|
|
flush = function()
|
|
if args == nil then
|
|
return
|
|
end
|
|
timer:stop()
|
|
local a = args
|
|
args = nil
|
|
fn(vim.F.unpack_len(a))
|
|
end,
|
|
pending = function()
|
|
return args ~= nil
|
|
end,
|
|
close = function()
|
|
timer:stop()
|
|
if not timer:is_closing() then
|
|
timer:close()
|
|
end
|
|
args = nil
|
|
end,
|
|
}
|
|
end
|
|
|
|
---@class ow.Util.KeyedDebounceHandle<K>
|
|
---@field cancel fun(key: K)
|
|
---@field flush fun(key: K)
|
|
---@field pending fun(key: K): boolean
|
|
---@field close fun()
|
|
|
|
---@generic K, F: fun(key: K, ...)
|
|
---@param fn F
|
|
---@param delay integer
|
|
---@return F, ow.Util.KeyedDebounceHandle<K>
|
|
function M.keyed_debounce(fn, delay)
|
|
---@type table<K, { call: fun(...), handle: ow.Util.DebounceHandle }>
|
|
local slots = {}
|
|
|
|
local function call(key, ...)
|
|
local t = type(key)
|
|
assert(
|
|
t == "string" or t == "number" or t == "boolean",
|
|
"key must be a primitive (string, number, boolean)"
|
|
)
|
|
local slot = slots[key]
|
|
if not slot then
|
|
local c, h = M.debounce(function(...)
|
|
fn(key, ...)
|
|
end, delay)
|
|
slot = { call = c, handle = h }
|
|
slots[key] = slot
|
|
end
|
|
slot.call(...)
|
|
end
|
|
|
|
return call,
|
|
{
|
|
cancel = function(key)
|
|
local slot = slots[key]
|
|
if slot then
|
|
slot.handle.close()
|
|
slots[key] = nil
|
|
end
|
|
end,
|
|
flush = function(key)
|
|
local slot = slots[key]
|
|
if slot then
|
|
slot.handle.flush()
|
|
end
|
|
end,
|
|
pending = function(key)
|
|
local slot = slots[key]
|
|
return slot ~= nil and slot.handle.pending()
|
|
end,
|
|
close = function()
|
|
for _, slot in pairs(slots) do
|
|
slot.handle.close()
|
|
end
|
|
slots = {}
|
|
end,
|
|
}
|
|
end
|
|
|
|
function M.get_hl_source(name)
|
|
local hl = vim.api.nvim_get_hl(0, { name = name })
|
|
while hl.link do
|
|
hl = vim.api.nvim_get_hl(0, { name = hl.link })
|
|
end
|
|
|
|
return hl
|
|
end
|
|
|
|
---Split a string on newlines, dropping the trailing empty element that an
|
|
---input ending in `\n` produces. Convenient for slicing subprocess stdout
|
|
---into a list of lines without a phantom blank at the end.
|
|
---@param content string
|
|
---@return string[]
|
|
function M.split_lines(content)
|
|
local lines = vim.split(content, "\n", { plain = true, trimempty = false })
|
|
if #lines > 0 and lines[#lines] == "" then
|
|
table.remove(lines)
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---Run a system command synchronously and return stdout on success. On
|
|
---non-zero exit, logs stderr via `log.error` and returns nil. Pass
|
|
---`opts.silent` to suppress the auto-log when failure is expected (e.g.
|
|
---probe-style commands like `git rev-parse` against a possibly-missing
|
|
---ref).
|
|
---@param cmd string[]
|
|
---@param opts { cwd: string?, stdin: string?, silent: boolean? }?
|
|
---@return string?
|
|
function M.system_sync(cmd, opts)
|
|
opts = opts or {}
|
|
local result = vim.system(cmd, {
|
|
cwd = opts.cwd,
|
|
stdin = opts.stdin,
|
|
text = true,
|
|
}):wait()
|
|
if result.code ~= 0 then
|
|
if not opts.silent then
|
|
local label = cmd[2] and (cmd[1] .. " " .. cmd[2]) or cmd[1] or "?"
|
|
log.error("%s failed: %s", label, vim.trim(result.stderr or ""))
|
|
end
|
|
return nil
|
|
end
|
|
return result.stdout or ""
|
|
end
|
|
|
|
return M
|