mirror of
https://github.com/harivansh-afk/forge.nvim.git
synced 2026-04-15 06:04:41 +00:00
468 lines
13 KiB
Lua
468 lines
13 KiB
Lua
local cfg = require('forge').config()
|
|
|
|
if cfg.keys ~= false then
|
|
local k = cfg.keys
|
|
|
|
if k.picker then
|
|
vim.keymap.set({ 'n', 'v' }, k.picker, function()
|
|
require('forge.pickers').git()
|
|
end, { desc = 'forge git picker' })
|
|
end
|
|
|
|
if k.next_qf then
|
|
vim.keymap.set('n', k.next_qf, require('forge.review').nav('cnext'), { desc = 'next quickfix entry' })
|
|
end
|
|
|
|
if k.prev_qf then
|
|
vim.keymap.set('n', k.prev_qf, require('forge.review').nav('cprev'), { desc = 'prev quickfix entry' })
|
|
end
|
|
|
|
if k.next_loc then
|
|
vim.keymap.set('n', k.next_loc, require('forge.review').nav('lnext'), { desc = 'next loclist entry' })
|
|
end
|
|
|
|
if k.prev_loc then
|
|
vim.keymap.set('n', k.prev_loc, require('forge.review').nav('lprev'), { desc = 'prev loclist entry' })
|
|
end
|
|
|
|
if k.fugitive ~= false then
|
|
vim.api.nvim_create_autocmd('FileType', {
|
|
pattern = 'fugitive',
|
|
callback = function(args)
|
|
local forge_mod = require('forge')
|
|
local f = forge_mod.detect()
|
|
if not f then
|
|
return
|
|
end
|
|
local fk = k.fugitive
|
|
local buf = args.buf
|
|
if fk.create then
|
|
vim.keymap.set('n', fk.create, function()
|
|
forge_mod.create_pr({ draft = false })
|
|
end, { buffer = buf, desc = 'create PR' })
|
|
end
|
|
if fk.create_draft then
|
|
vim.keymap.set('n', fk.create_draft, function()
|
|
forge_mod.create_pr({ draft = true })
|
|
end, { buffer = buf, desc = 'create draft PR' })
|
|
end
|
|
if fk.create_fill then
|
|
vim.keymap.set('n', fk.create_fill, function()
|
|
forge_mod.create_pr({ instant = true })
|
|
end, { buffer = buf, desc = 'create PR (fill)' })
|
|
end
|
|
if fk.create_web then
|
|
vim.keymap.set('n', fk.create_web, function()
|
|
forge_mod.create_pr({ web = true })
|
|
end, { buffer = buf, desc = 'create PR (web)' })
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
vim.api.nvim_create_autocmd('FileType', {
|
|
pattern = 'qf',
|
|
callback = function()
|
|
local info = vim.fn.getwininfo(vim.api.nvim_get_current_win())[1]
|
|
local items = info.loclist == 1 and vim.fn.getloclist(0) or vim.fn.getqflist()
|
|
if #items == 0 then
|
|
return
|
|
end
|
|
local bufname = vim.fn.bufname(items[1].bufnr)
|
|
if not bufname:match('^diffs://') then
|
|
return
|
|
end
|
|
vim.fn.matchadd('DiffAdd', [[\v\+\d+]])
|
|
vim.fn.matchadd('DiffDelete', [[\v-\d+]])
|
|
vim.fn.matchadd('DiffChange', [[\v\s\zsM\ze\s]])
|
|
vim.fn.matchadd('diffAdded', [[\v\s\zsA\ze\s]])
|
|
vim.fn.matchadd('DiffDelete', [[\v\s\zsD\ze\s]])
|
|
vim.fn.matchadd('DiffText', [[\v\s\zsR\ze\s]])
|
|
end,
|
|
})
|
|
|
|
local function require_forge_or_warn()
|
|
local forge_mod = require('forge')
|
|
local f = forge_mod.detect()
|
|
if not f then
|
|
vim.notify('[forge]: no forge detected', vim.log.levels.WARN)
|
|
return nil, forge_mod
|
|
end
|
|
return f, forge_mod
|
|
end
|
|
|
|
local function require_git_or_warn()
|
|
vim.fn.system('git rev-parse --show-toplevel')
|
|
if vim.v.shell_error ~= 0 then
|
|
vim.notify('[forge]: not a git repository', vim.log.levels.WARN)
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function parse_flags(args, start)
|
|
local flags = {}
|
|
local positional = {}
|
|
for i = start, #args do
|
|
local flag = args[i]:match('^%-%-(.+)$')
|
|
if flag then
|
|
local fk, fv = flag:match('^(.-)=(.+)$')
|
|
if fk then
|
|
flags[fk] = fv
|
|
else
|
|
flags[flag] = true
|
|
end
|
|
else
|
|
table.insert(positional, args[i])
|
|
end
|
|
end
|
|
return flags, positional
|
|
end
|
|
|
|
local function dispatch(args)
|
|
local sub = args[1]
|
|
|
|
if sub == 'pr' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local f, forge_mod = require_forge_or_warn()
|
|
if not f then
|
|
return
|
|
end
|
|
local pickers = require('forge.pickers')
|
|
if #args == 1 then
|
|
pickers.pr('open', f)
|
|
return
|
|
end
|
|
local flags, pos = parse_flags(args, 2)
|
|
if flags.state then
|
|
pickers.pr(flags.state, f)
|
|
return
|
|
end
|
|
local action = pos[1]
|
|
if action == 'create' then
|
|
local cf = parse_flags(args, 3)
|
|
local opts = {}
|
|
if cf.draft then
|
|
opts.draft = true
|
|
end
|
|
if cf.fill then
|
|
opts.instant = true
|
|
end
|
|
if cf.web then
|
|
opts.web = true
|
|
end
|
|
forge_mod.create_pr(opts)
|
|
return
|
|
end
|
|
local num = pos[2]
|
|
if not num then
|
|
vim.notify('[forge]: missing argument', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
if action == 'checkout' then
|
|
pickers.pr_actions(f, num)._by_name.checkout()
|
|
elseif action == 'diff' then
|
|
pickers.pr_actions(f, num)._by_name.diff()
|
|
elseif action == 'worktree' then
|
|
pickers.pr_actions(f, num)._by_name.worktree()
|
|
elseif action == 'checks' then
|
|
pickers.checks(f, num)
|
|
elseif action == 'browse' then
|
|
f:view_web(f.kinds.pr, num)
|
|
elseif action == 'manage' then
|
|
pickers.pr_manage(f, num)
|
|
else
|
|
vim.notify('[forge]: unknown pr action: ' .. action, vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'issue' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local f = require_forge_or_warn()
|
|
if not f then
|
|
return
|
|
end
|
|
local pickers = require('forge.pickers')
|
|
if #args == 1 then
|
|
pickers.issue('all', f)
|
|
return
|
|
end
|
|
local flags, pos = parse_flags(args, 2)
|
|
if flags.state then
|
|
pickers.issue(flags.state, f)
|
|
return
|
|
end
|
|
local action = pos[1]
|
|
local num = pos[2]
|
|
if action == 'browse' then
|
|
if not num then
|
|
vim.notify('[forge]: missing issue number', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
f:view_web(f.kinds.issue, num)
|
|
elseif action == 'close' then
|
|
if not num then
|
|
vim.notify('[forge]: missing issue number', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
pickers.issue_close(f, num)
|
|
elseif action == 'reopen' then
|
|
if not num then
|
|
vim.notify('[forge]: missing issue number', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
pickers.issue_reopen(f, num)
|
|
else
|
|
vim.notify('[forge]: unknown issue action: ' .. (action or ''), vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'ci' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local f = require_forge_or_warn()
|
|
if not f then
|
|
return
|
|
end
|
|
local flags = parse_flags(args, 2)
|
|
local branch
|
|
if not flags.all then
|
|
branch = vim.trim(vim.fn.system('git branch --show-current'))
|
|
if branch == '' then
|
|
branch = nil
|
|
end
|
|
end
|
|
require('forge.pickers').ci(f, branch)
|
|
return
|
|
end
|
|
|
|
if sub == 'commit' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local forge_mod = require('forge')
|
|
local f = forge_mod.detect()
|
|
local pickers = require('forge.pickers')
|
|
if #args == 1 then
|
|
pickers.commits(f)
|
|
return
|
|
end
|
|
local _, pos = parse_flags(args, 2)
|
|
local action = pos[1]
|
|
local sha = pos[2]
|
|
if not sha then
|
|
vim.notify('[forge]: missing commit sha', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
if action == 'checkout' then
|
|
forge_mod.log_now('checking out ' .. sha .. '...')
|
|
vim.system({ 'git', 'checkout', sha }, { text = true }, function(result)
|
|
vim.schedule(function()
|
|
if result.code == 0 then
|
|
vim.notify(('[forge]: checked out %s (detached)'):format(sha))
|
|
else
|
|
vim.notify('[forge]: checkout failed', vim.log.levels.ERROR)
|
|
end
|
|
vim.cmd.redraw()
|
|
end)
|
|
end)
|
|
elseif action == 'diff' then
|
|
local review = require('forge.review')
|
|
local range = sha .. '^..' .. sha
|
|
review.start(range)
|
|
local ok, commands = pcall(require, 'diffs.commands')
|
|
if ok then
|
|
commands.greview(range)
|
|
end
|
|
forge_mod.log_now('reviewing ' .. sha)
|
|
elseif action == 'browse' then
|
|
if not f then
|
|
vim.notify('[forge]: no forge detected', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
f:browse_commit(sha)
|
|
else
|
|
vim.notify('[forge]: unknown commit action: ' .. action, vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'branch' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local forge_mod = require('forge')
|
|
local f = forge_mod.detect()
|
|
local pickers = require('forge.pickers')
|
|
if #args == 1 then
|
|
pickers.branches(f)
|
|
return
|
|
end
|
|
local _, pos = parse_flags(args, 2)
|
|
local action = pos[1]
|
|
local name = pos[2]
|
|
if not name then
|
|
vim.notify('[forge]: missing branch name', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
if action == 'diff' then
|
|
local review = require('forge.review')
|
|
review.start(name)
|
|
local ok, commands = pcall(require, 'diffs.commands')
|
|
if ok then
|
|
commands.greview(name)
|
|
end
|
|
forge_mod.log_now('reviewing ' .. name)
|
|
elseif action == 'browse' then
|
|
if not f then
|
|
vim.notify('[forge]: no forge detected', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
f:browse_branch(name)
|
|
else
|
|
vim.notify('[forge]: unknown branch action: ' .. action, vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'worktree' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
require('fzf-lua').git_worktrees()
|
|
return
|
|
end
|
|
|
|
if sub == 'browse' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local f = require_forge_or_warn()
|
|
if not f then
|
|
return
|
|
end
|
|
local flags = parse_flags(args, 2)
|
|
if flags.root then
|
|
f:browse_root()
|
|
elseif flags.commit then
|
|
local sha = vim.trim(vim.fn.system('git rev-parse HEAD'))
|
|
f:browse_commit(sha)
|
|
else
|
|
local forge_mod = require('forge')
|
|
local loc = forge_mod.file_loc()
|
|
local branch = vim.trim(vim.fn.system('git branch --show-current'))
|
|
if branch == '' then
|
|
vim.notify('[forge]: detached HEAD', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
f:browse(loc, branch)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'yank' then
|
|
if not require_git_or_warn() then
|
|
return
|
|
end
|
|
local f = require_forge_or_warn()
|
|
if not f then
|
|
return
|
|
end
|
|
local forge_mod = require('forge')
|
|
local loc = forge_mod.file_loc()
|
|
local flags = parse_flags(args, 2)
|
|
if flags.commit then
|
|
f:yank_commit(loc)
|
|
else
|
|
f:yank_branch(loc)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'review' then
|
|
local review = require('forge.review')
|
|
if #args < 2 then
|
|
vim.notify('[forge]: missing review action (end, toggle)', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
local action = args[2]
|
|
if action == 'end' then
|
|
review.stop()
|
|
elseif action == 'toggle' then
|
|
review.toggle()
|
|
else
|
|
vim.notify('[forge]: unknown review action: ' .. action, vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
if sub == 'cache' then
|
|
if #args < 2 then
|
|
vim.notify('[forge]: missing cache action (clear)', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
if args[2] == 'clear' then
|
|
require('forge').clear_cache()
|
|
vim.notify('[forge]: cache cleared')
|
|
else
|
|
vim.notify('[forge]: unknown cache action: ' .. args[2], vim.log.levels.WARN)
|
|
end
|
|
return
|
|
end
|
|
|
|
vim.notify('[forge]: unknown command: ' .. sub, vim.log.levels.WARN)
|
|
end
|
|
|
|
local function complete(arglead, cmdline, _)
|
|
local parts = vim.split(vim.trim(cmdline), '%s+')
|
|
local subcmds = { 'pr', 'issue', 'ci', 'commit', 'branch', 'worktree', 'browse', 'yank', 'review', 'cache' }
|
|
local sub_actions = {
|
|
pr = { 'checkout', 'diff', 'worktree', 'checks', 'browse', 'manage', 'create', '--state=open', '--state=closed', '--state=all' },
|
|
issue = { 'browse', 'close', 'reopen', '--state=open', '--state=closed', '--state=all' },
|
|
ci = { '--all' },
|
|
commit = { 'checkout', 'diff', 'browse' },
|
|
branch = { 'diff', 'browse' },
|
|
review = { 'end', 'toggle' },
|
|
cache = { 'clear' },
|
|
browse = { '--root', '--commit' },
|
|
yank = { '--commit' },
|
|
}
|
|
local create_flags = { '--draft', '--fill', '--web' }
|
|
|
|
if #parts <= 2 then
|
|
return vim.tbl_filter(function(s) return s:find(arglead, 1, true) == 1 end, subcmds)
|
|
end
|
|
local sub = parts[2]
|
|
if #parts == 3 or (#parts == 4 and sub == 'pr' and parts[3] == 'create') then
|
|
local candidates = sub_actions[sub] or {}
|
|
if sub == 'pr' and #parts >= 3 and parts[3] == 'create' then
|
|
candidates = create_flags
|
|
end
|
|
return vim.tbl_filter(function(s) return s:find(arglead, 1, true) == 1 end, candidates)
|
|
end
|
|
if sub == 'pr' and parts[3] == 'create' then
|
|
return vim.tbl_filter(function(s) return s:find(arglead, 1, true) == 1 end, create_flags)
|
|
end
|
|
return {}
|
|
end
|
|
|
|
vim.api.nvim_create_user_command('Forge', function(opts)
|
|
local args = vim.split(vim.trim(opts.args), '%s+')
|
|
if #args == 0 or args[1] == '' then
|
|
require('forge.pickers').git()
|
|
return
|
|
end
|
|
dispatch(args)
|
|
end, {
|
|
nargs = '*',
|
|
complete = complete,
|
|
desc = 'forge.nvim',
|
|
})
|