mirror of
https://github.com/zoriya/jj.nvim.git
synced 2026-08-05 18:56:13 +00:00
280 lines
8.8 KiB
Lua
280 lines
8.8 KiB
Lua
--- @class jj.file
|
|
local M = {}
|
|
|
|
local runner = require("jj.core.runner")
|
|
local buffer = require("jj.core.buffer")
|
|
local utils = require("jj.utils")
|
|
local parser = require("jj.core.parser")
|
|
|
|
--- @class jj.file.read_target_opts
|
|
--- @field rev? string Revision to read the file from
|
|
--- @field path? string Path to the file (`%`, absolute, or repository-relative)
|
|
|
|
--- @class jj.file.open_target_opts
|
|
--- @field rev? string Revision to open the file from
|
|
--- @field path? string Path to the file (`%`, absolute, or repository-relative)
|
|
--- @field split? "horizontal"|"vertical"|"tab"|"current" Open in split direction (default: "current")
|
|
|
|
--- Fetch file content from jj synchronously.
|
|
--- Returns lines with blank lines preserved; trailing empty line removed.
|
|
--- @param rev string The revision (change ID or other revset)
|
|
--- @param path string Cwd-relative path
|
|
--- @return string[] lines
|
|
--- @return boolean had_eol Whether the content had a trailing newline
|
|
--- @return boolean ok Whether the command succeeded
|
|
local function get_file_content(rev, path)
|
|
local content, ok = runner.execute_command(
|
|
string.format("jj file show -r %s %s", vim.fn.shellescape(rev), vim.fn.shellescape(path)),
|
|
nil,
|
|
nil,
|
|
true
|
|
)
|
|
if not ok or not content then
|
|
return {}, false, false
|
|
end
|
|
local lines = vim.split(content, "\n", { plain = true, trimempty = false })
|
|
local had_eol = #lines > 0 and lines[#lines] == ""
|
|
if had_eol then
|
|
table.remove(lines, #lines)
|
|
end
|
|
return lines, had_eol, true
|
|
end
|
|
M.get_file_content = get_file_content
|
|
|
|
--- Reads a target file revision into the current buffer (undoable).
|
|
--- @param opts? jj.file.read_target_opts
|
|
function M.read_target(opts)
|
|
local revision = opts and opts.rev or "@"
|
|
local raw_path = opts and opts.path or "%"
|
|
local path, normalize_err = utils.normalize_relative_path(raw_path)
|
|
if not path then
|
|
utils.notify(normalize_err or "Could not normalize path", vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local cmd = string.format("jj file show -r %s %s", vim.fn.shellescape(revision), vim.fn.shellescape(path))
|
|
runner.execute_command_async(cmd, function(out)
|
|
local lines = vim.split(out, "\n", { plain = true, trimempty = false })
|
|
if #lines > 0 and lines[#lines] == "" then
|
|
table.remove(lines, #lines)
|
|
end
|
|
if vim.bo[buf].modifiable == false then
|
|
utils.notify("Current buffer is not modifiable", vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
|
|
vim.bo[buf].modified = true
|
|
end, string.format("Could not read `%s` from `%s`", path, revision))
|
|
end
|
|
|
|
--- Write buffer content back into a jj revision, bypassing the working copy.
|
|
--- @param buf integer
|
|
--- @param change_id string
|
|
--- @param rel_path string Repository-relative path of the file
|
|
--- @param force boolean Whether to bypass the immutability check (`:w!`)
|
|
local function write_revision_file(buf, change_id, rel_path, force)
|
|
if utils.is_change_immutable(change_id) then
|
|
if not force then
|
|
utils.notify("Cannot write to immutable revision: " .. change_id, vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
end
|
|
|
|
local new_content = table.concat(vim.api.nvim_buf_get_lines(buf, 0, -1, false), "\n")
|
|
if vim.bo[buf].eol then
|
|
new_content = new_content .. "\n"
|
|
end
|
|
|
|
local tmp = vim.fn.tempname()
|
|
local cf = io.open(tmp, "w")
|
|
if not cf then
|
|
utils.notify("Failed to create temp file", vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
cf:write(new_content)
|
|
cf:close()
|
|
|
|
-- Configure `cp` as the diffedit tool inline via --config.
|
|
-- jj expands $right to the directory it populates with <rev>'s content,
|
|
-- so the parent directory for rel_path already exists there.
|
|
local prog_config = 'merge-tools.jj-nvim-write.program="cp"'
|
|
-- json_encode produces valid TOML inline arrays.
|
|
local args_config = "merge-tools.jj-nvim-write.edit-args="
|
|
.. vim.fn.json_encode({ tmp, "$right/" .. rel_path })
|
|
|
|
local _, ok = runner.execute_command(
|
|
string.format(
|
|
"jj diffedit --from 'root()' --to %s --config %s --config %s --tool jj-nvim-write -- %s",
|
|
vim.fn.shellescape(change_id),
|
|
vim.fn.shellescape(prog_config),
|
|
vim.fn.shellescape(args_config),
|
|
vim.fn.shellescape(rel_path)
|
|
),
|
|
"jj: failed to edit revision"
|
|
)
|
|
|
|
os.remove(tmp)
|
|
|
|
if not ok then return end
|
|
vim.bo[buf].modified = false
|
|
utils.notify(string.format("Written to revision %s", change_id))
|
|
end
|
|
M.write_revision_file = write_revision_file
|
|
|
|
--- Opens a target file revision in a new buffer.
|
|
--- @param opts jj.file.open_target_opts
|
|
function M.open_target(opts)
|
|
local revision = opts.rev or "@"
|
|
local raw_path = opts.path or "%"
|
|
local path, normalize_err = utils.normalize_relative_path(raw_path)
|
|
if not path then
|
|
utils.notify(normalize_err or "Could not normalize path", vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
|
|
local raw_ids, ok = runner.execute_command(
|
|
string.format([[jj log --no-graph -r %s -T 'change_id ++ "\n"' --quiet]], vim.fn.shellescape(revision)),
|
|
"jj: failed to resolve revision",
|
|
nil,
|
|
true
|
|
)
|
|
if not ok then return end
|
|
local ids = vim.split(vim.trim(raw_ids), "\n", { trimempty = true })
|
|
if #ids ~= 1 then
|
|
utils.notify(string.format("Revision '%s' is ambiguous", revision), vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
local change_id = ids[1]
|
|
|
|
local lines, had_eol, ok_read = get_file_content(change_id, path)
|
|
if not ok_read then
|
|
utils.notify(string.format("Could not read `%s` from `%s`", path, change_id), vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
local ft = vim.filetype.match({ filename = path })
|
|
|
|
local buf, _ = buffer.create({
|
|
name = string.format("jj://%s/%s", change_id, path),
|
|
split = opts.split or "current",
|
|
modifiable = true,
|
|
buftype = "acwrite",
|
|
bufhidden = "wipe",
|
|
filetype = ft,
|
|
})
|
|
vim.bo[buf].buflisted = true
|
|
vim.bo[buf].swapfile = false
|
|
local ul = vim.bo[buf].undolevels
|
|
vim.bo[buf].undolevels = -1
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
|
|
vim.bo[buf].undolevels = ul
|
|
vim.bo[buf].eol = had_eol
|
|
|
|
vim.api.nvim_create_autocmd("BufWriteCmd", {
|
|
buffer = buf,
|
|
callback = function()
|
|
write_revision_file(buf, change_id, path, vim.v.cmdbang == 1)
|
|
end,
|
|
})
|
|
|
|
vim.bo[buf].modified = false
|
|
vim.bo[buf].modifiable = not utils.is_change_immutable(change_id)
|
|
end
|
|
|
|
--- Complete `<rev>:<file>` arguments for file commands.
|
|
--- @param arglead string
|
|
--- @return string[]
|
|
local function complete_target(arglead)
|
|
local rev, file_prefix = arglead:match("^([^:]+):(.*)$")
|
|
if not rev then
|
|
return {}
|
|
end
|
|
|
|
local out, ok = runner.execute_command(
|
|
string.format("jj file list -r %s", vim.fn.shellescape(rev)),
|
|
nil,
|
|
nil,
|
|
true
|
|
)
|
|
if not ok or not out then
|
|
return {}
|
|
end
|
|
|
|
local items = {}
|
|
local seen = {}
|
|
for line in out:gmatch("[^\r\n]+") do
|
|
local file = vim.trim(line)
|
|
if file ~= "" and vim.startswith(file, file_prefix) then
|
|
local candidate = rev .. ":" .. file
|
|
if not seen[candidate] then
|
|
table.insert(items, candidate)
|
|
seen[candidate] = true
|
|
end
|
|
end
|
|
end
|
|
return items
|
|
end
|
|
|
|
function M.register_command()
|
|
-- Allow :e on jj:// buffers to reload their content.
|
|
vim.api.nvim_create_autocmd("BufReadCmd", {
|
|
pattern = "jj://*",
|
|
nested = true,
|
|
callback = function()
|
|
local name = vim.api.nvim_buf_get_name(0)
|
|
local change_id, path = utils.parse_jj_uri(name)
|
|
if not change_id then return end
|
|
local lines, had_eol, ok_read = get_file_content(change_id, path)
|
|
if not ok_read then
|
|
utils.notify(string.format("Could not read `%s` from `%s`", path, change_id), vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
vim.bo[buf].modifiable = true
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
|
|
vim.bo[buf].eol = had_eol
|
|
vim.bo[buf].modified = false
|
|
vim.bo[buf].modifiable = not utils.is_change_immutable(change_id)
|
|
vim.api.nvim_exec_autocmds("BufReadPost", { buffer = buf })
|
|
end,
|
|
})
|
|
|
|
vim.api.nvim_create_user_command("Jread", function(opts)
|
|
local parsed = parser.parse_file_module_input(opts.args)
|
|
M.read_target({
|
|
rev = parsed and parsed.rev,
|
|
path = parsed and parsed.path,
|
|
})
|
|
end, {
|
|
desc = "Read a jj file revision into the current buffer",
|
|
nargs = "?",
|
|
complete = function(arglead, _, _)
|
|
return complete_target(arglead)
|
|
end,
|
|
})
|
|
|
|
local function create_open_command(name, split, desc)
|
|
vim.api.nvim_create_user_command(name, function(opts)
|
|
local parsed = parser.parse_file_module_input(opts.args)
|
|
M.open_target({
|
|
rev = parsed and parsed.rev,
|
|
path = parsed and parsed.path,
|
|
split = split,
|
|
})
|
|
end, {
|
|
desc = desc,
|
|
nargs = "?",
|
|
complete = function(arglead, _, _)
|
|
return complete_target(arglead)
|
|
end,
|
|
})
|
|
end
|
|
|
|
create_open_command("Jedit", "current", "Open a jj file revision in the current window")
|
|
create_open_command("Jtabedit", "tab", "Open a jj file revision in a new tab")
|
|
create_open_command("Jsplit", "horizontal", "Open a jj file revision in a horizontal split")
|
|
create_open_command("Jvsplit", "vertical", "Open a jj file revision in a vertical split")
|
|
end
|
|
|
|
return M
|