86f553cd0a
* build: replace luacheck with selene Problem: luacheck is unmaintained (last release 2018) and required suppressing four warning classes to avoid false positives. It also lacks first-class vim/neovim awareness. Solution: switch to selene with std='vim' for vim-aware linting. Replace the luacheck CI job with selene, update the Makefile lint target, and delete .luacheckrc. * build: add nix devshell and pre-commit hooks Problem: oil.nvim had no reproducible dev environment. The .envrc set up a Python venv for the now-removed docgen pipeline, and there were no pre-commit hooks for local formatting checks. Solution: add flake.nix with stylua, selene, and prettier in the devshell. Replace the stale Python .envrc with 'use flake'. Add .pre-commit-config.yaml with stylua and prettier hooks matching other plugins in the repo collection. * fix: format with stylua * build(selene): configure lints and add inline suppressions Problem: selene fails on 5 errors and 3 warnings from upstream code patterns that are intentional (mixed tables in config API, unused callback parameters, identical if branches for readability). Solution: globally allow mixed_table and unused_variable (high volume, inherent to the codebase design). Add inline selene:allow directives for the 8 remaining issues: if_same_then_else (4), mismatched_arg_count (1), empty_if (2), global_usage (1). Remove .envrc from tracking. * build: switch typecheck action to mrcjkb/lua-typecheck-action Problem: oil.nvim used stevearc/nvim-typecheck-action, which required cloning the action repo locally for the Makefile lint target. All other plugins in the collection use mrcjkb/lua-typecheck-action. Solution: swap to mrcjkb/lua-typecheck-action@v0 for consistency. Remove the nvim-typecheck-action git clone from the Makefile and .gitignore. Drop LuaLS from the local lint target since it requires a full language server install — CI handles it.
652 lines
16 KiB
Lua
652 lines
16 KiB
Lua
local oil = require('oil')
|
|
local util = require('oil.util')
|
|
|
|
local M = {}
|
|
|
|
M.show_help = {
|
|
callback = function()
|
|
local config = require('oil.config')
|
|
require('oil.keymap_util').show_help(config.keymaps)
|
|
end,
|
|
desc = 'Show default keymaps',
|
|
}
|
|
|
|
M.select = {
|
|
desc = 'Open the entry under the cursor',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
local callback = opts.callback
|
|
opts.callback = nil
|
|
oil.select(opts, callback)
|
|
end,
|
|
parameters = {
|
|
vertical = {
|
|
type = 'boolean',
|
|
desc = 'Open the buffer in a vertical split',
|
|
},
|
|
horizontal = {
|
|
type = 'boolean',
|
|
desc = 'Open the buffer in a horizontal split',
|
|
},
|
|
split = {
|
|
type = '"aboveleft"|"belowright"|"topleft"|"botright"',
|
|
desc = 'Split modifier',
|
|
},
|
|
tab = {
|
|
type = 'boolean',
|
|
desc = 'Open the buffer in a new tab',
|
|
},
|
|
close = {
|
|
type = 'boolean',
|
|
desc = 'Close the original oil buffer once selection is made',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.select_vsplit = {
|
|
desc = 'Open the entry under the cursor in a vertical split',
|
|
deprecated = true,
|
|
callback = function()
|
|
oil.select({ vertical = true })
|
|
end,
|
|
}
|
|
|
|
M.select_split = {
|
|
desc = 'Open the entry under the cursor in a horizontal split',
|
|
deprecated = true,
|
|
callback = function()
|
|
oil.select({ horizontal = true })
|
|
end,
|
|
}
|
|
|
|
M.select_tab = {
|
|
desc = 'Open the entry under the cursor in a new tab',
|
|
deprecated = true,
|
|
callback = function()
|
|
oil.select({ tab = true })
|
|
end,
|
|
}
|
|
|
|
M.preview = {
|
|
desc = 'Open the entry under the cursor in a preview window, or close the preview window if already open',
|
|
parameters = {
|
|
vertical = {
|
|
type = 'boolean',
|
|
desc = 'Open the buffer in a vertical split',
|
|
},
|
|
horizontal = {
|
|
type = 'boolean',
|
|
desc = 'Open the buffer in a horizontal split',
|
|
},
|
|
split = {
|
|
type = '"aboveleft"|"belowright"|"topleft"|"botright"',
|
|
desc = 'Split modifier',
|
|
},
|
|
},
|
|
callback = function(opts)
|
|
local entry = oil.get_cursor_entry()
|
|
if not entry then
|
|
vim.notify('Could not find entry under cursor', vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
local winid = util.get_preview_win()
|
|
if winid then
|
|
local cur_id = vim.w[winid].oil_entry_id
|
|
if entry.id == cur_id then
|
|
vim.api.nvim_win_close(winid, true)
|
|
if util.is_floating_win() then
|
|
local layout = require('oil.layout')
|
|
local win_opts = layout.get_fullscreen_win_opts()
|
|
vim.api.nvim_win_set_config(0, win_opts)
|
|
end
|
|
return
|
|
end
|
|
end
|
|
oil.open_preview(opts)
|
|
end,
|
|
}
|
|
|
|
M.preview_scroll_down = {
|
|
desc = 'Scroll down in the preview window',
|
|
callback = function()
|
|
local winid = util.get_preview_win()
|
|
if winid then
|
|
vim.api.nvim_win_call(winid, function()
|
|
vim.cmd.normal({
|
|
args = { vim.api.nvim_replace_termcodes('<C-d>', true, true, true) },
|
|
bang = true,
|
|
})
|
|
end)
|
|
end
|
|
end,
|
|
}
|
|
|
|
M.preview_scroll_up = {
|
|
desc = 'Scroll up in the preview window',
|
|
callback = function()
|
|
local winid = util.get_preview_win()
|
|
if winid then
|
|
vim.api.nvim_win_call(winid, function()
|
|
vim.cmd.normal({
|
|
args = { vim.api.nvim_replace_termcodes('<C-u>', true, true, true) },
|
|
bang = true,
|
|
})
|
|
end)
|
|
end
|
|
end,
|
|
}
|
|
|
|
M.preview_scroll_left = {
|
|
desc = 'Scroll left in the preview window',
|
|
callback = function()
|
|
local winid = util.get_preview_win()
|
|
if winid then
|
|
vim.api.nvim_win_call(winid, function()
|
|
vim.cmd.normal({ 'zH', bang = true })
|
|
end)
|
|
end
|
|
end,
|
|
}
|
|
|
|
M.preview_scroll_right = {
|
|
desc = 'Scroll right in the preview window',
|
|
callback = function()
|
|
local winid = util.get_preview_win()
|
|
if winid then
|
|
vim.api.nvim_win_call(winid, function()
|
|
vim.cmd.normal({ 'zL', bang = true })
|
|
end)
|
|
end
|
|
end,
|
|
}
|
|
|
|
M.parent = {
|
|
desc = 'Navigate to the parent path',
|
|
callback = oil.open,
|
|
}
|
|
|
|
M.close = {
|
|
desc = 'Close oil and restore original buffer',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
oil.close(opts)
|
|
end,
|
|
parameters = {
|
|
exit_if_last_buf = {
|
|
type = 'boolean',
|
|
desc = 'Exit vim if oil is closed as the last buffer',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.close_float = {
|
|
desc = 'Close oil if the window is floating, otherwise do nothing',
|
|
callback = function(opts)
|
|
if vim.w.is_oil_win then
|
|
opts = opts or {}
|
|
oil.close(opts)
|
|
end
|
|
end,
|
|
parameters = {
|
|
exit_if_last_buf = {
|
|
type = 'boolean',
|
|
desc = 'Exit vim if oil is closed as the last buffer',
|
|
},
|
|
},
|
|
}
|
|
|
|
---@param cmd string
|
|
---@param silent? boolean
|
|
local function cd(cmd, silent)
|
|
local dir = oil.get_current_dir()
|
|
if dir then
|
|
vim.cmd({ cmd = cmd, args = { dir } })
|
|
if not silent then
|
|
vim.notify(string.format('CWD: %s', dir), vim.log.levels.INFO)
|
|
end
|
|
else
|
|
vim.notify('Cannot :cd; not in a directory', vim.log.levels.WARN)
|
|
end
|
|
end
|
|
|
|
M.cd = {
|
|
desc = ':cd to the current oil directory',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
local cmd = 'cd'
|
|
if opts.scope == 'tab' then
|
|
cmd = 'tcd'
|
|
elseif opts.scope == 'win' then
|
|
cmd = 'lcd'
|
|
end
|
|
cd(cmd, opts.silent)
|
|
end,
|
|
parameters = {
|
|
scope = {
|
|
type = 'nil|"tab"|"win"',
|
|
desc = 'Scope of the directory change (e.g. use |:tcd| or |:lcd|)',
|
|
},
|
|
silent = {
|
|
type = 'boolean',
|
|
desc = 'Do not show a message when changing directories',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.tcd = {
|
|
desc = ':tcd to the current oil directory',
|
|
deprecated = true,
|
|
callback = function()
|
|
cd('tcd')
|
|
end,
|
|
}
|
|
|
|
M.open_cwd = {
|
|
desc = "Open oil in Neovim's current working directory",
|
|
callback = function()
|
|
oil.open(vim.fn.getcwd())
|
|
end,
|
|
}
|
|
|
|
M.toggle_hidden = {
|
|
desc = 'Toggle hidden files and directories',
|
|
callback = function()
|
|
require('oil.view').toggle_hidden()
|
|
end,
|
|
}
|
|
|
|
M.open_terminal = {
|
|
desc = 'Open a terminal in the current directory',
|
|
callback = function()
|
|
local config = require('oil.config')
|
|
local bufname = vim.api.nvim_buf_get_name(0)
|
|
local adapter = config.get_adapter_by_scheme(bufname)
|
|
if not adapter then
|
|
return
|
|
end
|
|
if adapter.name == 'files' then
|
|
local dir = oil.get_current_dir()
|
|
assert(dir, 'Oil buffer with files adapter must have current directory')
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
if vim.fn.has('nvim-0.11') == 1 then
|
|
vim.fn.jobstart(vim.o.shell, { cwd = dir, term = true })
|
|
else
|
|
---@diagnostic disable-next-line: deprecated
|
|
vim.fn.termopen(vim.o.shell, { cwd = dir })
|
|
end
|
|
elseif adapter.name == 'ssh' then
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
local url = require('oil.adapters.ssh').parse_url(bufname)
|
|
local cmd = require('oil.adapters.ssh.connection').create_ssh_command(url)
|
|
local term_id
|
|
if vim.fn.has('nvim-0.11') == 1 then
|
|
term_id = vim.fn.jobstart(cmd, { term = true })
|
|
else
|
|
---@diagnostic disable-next-line: deprecated
|
|
term_id = vim.fn.termopen(cmd)
|
|
end
|
|
if term_id then
|
|
vim.api.nvim_chan_send(term_id, string.format('cd %s\n', url.path))
|
|
end
|
|
else
|
|
vim.notify(
|
|
string.format("Cannot open terminal for unsupported adapter: '%s'", adapter.name),
|
|
vim.log.levels.WARN
|
|
)
|
|
end
|
|
end,
|
|
}
|
|
|
|
---Copied from vim.ui.open in Neovim 0.10+
|
|
---@param path string
|
|
---@return nil|string[] cmd
|
|
---@return nil|string error
|
|
local function get_open_cmd(path)
|
|
if vim.fn.has('mac') == 1 then
|
|
return { 'open', path }
|
|
elseif vim.fn.has('win32') == 1 then
|
|
if vim.fn.executable('rundll32') == 1 then
|
|
return { 'rundll32', 'url.dll,FileProtocolHandler', path }
|
|
else
|
|
return nil, 'rundll32 not found'
|
|
end
|
|
elseif vim.fn.executable('explorer.exe') == 1 then
|
|
return { 'explorer.exe', path }
|
|
elseif vim.fn.executable('xdg-open') == 1 then
|
|
return { 'xdg-open', path }
|
|
else
|
|
return nil, 'no handler found'
|
|
end
|
|
end
|
|
|
|
M.open_external = {
|
|
desc = 'Open the entry under the cursor in an external program',
|
|
callback = function()
|
|
local entry = oil.get_cursor_entry()
|
|
local dir = oil.get_current_dir()
|
|
if not entry or not dir then
|
|
return
|
|
end
|
|
local path = dir .. entry.name
|
|
|
|
if vim.ui.open then
|
|
vim.ui.open(path)
|
|
return
|
|
end
|
|
|
|
local cmd, err = get_open_cmd(path)
|
|
if not cmd then
|
|
vim.notify(string.format('Could not open %s: %s', path, err), vim.log.levels.ERROR)
|
|
return
|
|
end
|
|
local jid = vim.fn.jobstart(cmd, { detach = true })
|
|
assert(jid > 0, 'Failed to start job')
|
|
end,
|
|
}
|
|
|
|
M.refresh = {
|
|
desc = 'Refresh current directory list',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
if vim.bo.modified and not opts.force then
|
|
local ok, choice = pcall(vim.fn.confirm, 'Discard changes?', 'No\nYes')
|
|
if not ok or choice ~= 2 then
|
|
return
|
|
end
|
|
end
|
|
vim.cmd.edit({ bang = true })
|
|
|
|
-- :h CTRL-L-default
|
|
vim.cmd.nohlsearch()
|
|
end,
|
|
parameters = {
|
|
force = {
|
|
desc = 'When true, do not prompt user if they will be discarding changes',
|
|
type = 'boolean',
|
|
},
|
|
},
|
|
}
|
|
|
|
local function open_cmdline_with_path(path)
|
|
local escaped =
|
|
vim.api.nvim_replace_termcodes(': ' .. vim.fn.fnameescape(path) .. '<Home>', true, false, true)
|
|
vim.api.nvim_feedkeys(escaped, 'n', false)
|
|
end
|
|
|
|
M.open_cmdline = {
|
|
desc = 'Open vim cmdline with current entry as an argument',
|
|
callback = function(opts)
|
|
opts = vim.tbl_deep_extend('keep', opts or {}, {
|
|
shorten_path = true,
|
|
})
|
|
local config = require('oil.config')
|
|
local fs = require('oil.fs')
|
|
local entry = oil.get_cursor_entry()
|
|
if not entry then
|
|
return
|
|
end
|
|
local bufname = vim.api.nvim_buf_get_name(0)
|
|
local scheme, path = util.parse_url(bufname)
|
|
if not scheme then
|
|
return
|
|
end
|
|
local adapter = config.get_adapter_by_scheme(scheme)
|
|
if not adapter or not path or adapter.name ~= 'files' then
|
|
return
|
|
end
|
|
local fullpath = fs.posix_to_os_path(path) .. entry.name
|
|
if opts.modify then
|
|
fullpath = vim.fn.fnamemodify(fullpath, opts.modify)
|
|
end
|
|
if opts.shorten_path then
|
|
fullpath = fs.shorten_path(fullpath)
|
|
end
|
|
open_cmdline_with_path(fullpath)
|
|
end,
|
|
parameters = {
|
|
modify = {
|
|
desc = 'Modify the path with |fnamemodify()| using this as the mods argument',
|
|
type = 'string',
|
|
},
|
|
shorten_path = {
|
|
desc = 'Use relative paths when possible',
|
|
type = 'boolean',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.yank_entry = {
|
|
desc = 'Yank the filepath of the entry under the cursor to a register',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
local entry = oil.get_cursor_entry()
|
|
local dir = oil.get_current_dir()
|
|
if not entry or not dir then
|
|
return
|
|
end
|
|
local name = entry.name
|
|
if entry.type == 'directory' then
|
|
name = name .. '/'
|
|
end
|
|
local path = dir .. name
|
|
if opts.modify then
|
|
path = vim.fn.fnamemodify(path, opts.modify)
|
|
end
|
|
vim.fn.setreg(vim.v.register, path)
|
|
end,
|
|
parameters = {
|
|
modify = {
|
|
desc = 'Modify the path with |fnamemodify()| using this as the mods argument',
|
|
type = 'string',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.copy_entry_path = {
|
|
desc = 'Yank the filepath of the entry under the cursor to a register',
|
|
deprecated = true,
|
|
callback = function()
|
|
local entry = oil.get_cursor_entry()
|
|
local dir = oil.get_current_dir()
|
|
if not entry or not dir then
|
|
return
|
|
end
|
|
vim.fn.setreg(vim.v.register, dir .. entry.name)
|
|
end,
|
|
}
|
|
|
|
M.copy_entry_filename = {
|
|
desc = 'Yank the filename of the entry under the cursor to a register',
|
|
deprecated = true,
|
|
callback = function()
|
|
local entry = oil.get_cursor_entry()
|
|
if not entry then
|
|
return
|
|
end
|
|
vim.fn.setreg(vim.v.register, entry.name)
|
|
end,
|
|
}
|
|
|
|
M.copy_to_system_clipboard = {
|
|
desc = 'Copy the entry under the cursor to the system clipboard',
|
|
callback = function()
|
|
require('oil.clipboard').copy_to_system_clipboard()
|
|
end,
|
|
}
|
|
|
|
M.paste_from_system_clipboard = {
|
|
desc = 'Paste the system clipboard into the current oil directory',
|
|
callback = function(opts)
|
|
require('oil.clipboard').paste_from_system_clipboard(opts and opts.delete_original)
|
|
end,
|
|
parameters = {
|
|
delete_original = {
|
|
type = 'boolean',
|
|
desc = 'Delete the original file after copying',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.open_cmdline_dir = {
|
|
desc = 'Open vim cmdline with current directory as an argument',
|
|
deprecated = true,
|
|
callback = function()
|
|
local fs = require('oil.fs')
|
|
local dir = oil.get_current_dir()
|
|
if dir then
|
|
open_cmdline_with_path(fs.shorten_path(dir))
|
|
end
|
|
end,
|
|
}
|
|
|
|
M.change_sort = {
|
|
desc = 'Change the sort order',
|
|
callback = function(opts)
|
|
opts = opts or {}
|
|
|
|
if opts.sort then
|
|
oil.set_sort(opts.sort)
|
|
return
|
|
end
|
|
|
|
local sort_cols = { 'name', 'size', 'atime', 'mtime', 'ctime', 'birthtime' }
|
|
vim.ui.select(sort_cols, { prompt = 'Sort by', kind = 'oil_sort_col' }, function(col)
|
|
if not col then
|
|
return
|
|
end
|
|
vim.ui.select(
|
|
{ 'ascending', 'descending' },
|
|
{ prompt = 'Sort order', kind = 'oil_sort_order' },
|
|
function(order)
|
|
if not order then
|
|
return
|
|
end
|
|
order = order == 'ascending' and 'asc' or 'desc'
|
|
oil.set_sort({
|
|
{ 'type', 'asc' },
|
|
{ col, order },
|
|
})
|
|
end
|
|
)
|
|
end)
|
|
end,
|
|
parameters = {
|
|
sort = {
|
|
type = 'oil.SortSpec[]',
|
|
desc = 'List of columns plus direction (see |oil.set_sort|) instead of interactive selection',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.toggle_trash = {
|
|
desc = 'Jump to and from the trash for the current directory',
|
|
callback = function()
|
|
local fs = require('oil.fs')
|
|
local bufname = vim.api.nvim_buf_get_name(0)
|
|
local scheme, path = util.parse_url(bufname)
|
|
local bufnr = vim.api.nvim_get_current_buf()
|
|
local url
|
|
if scheme == 'oil://' then
|
|
url = 'oil-trash://' .. path
|
|
elseif scheme == 'oil-trash://' then
|
|
url = 'oil://' .. path
|
|
-- The non-linux trash implementations don't support per-directory trash,
|
|
-- so jump back to the stored source buffer.
|
|
if not fs.is_linux then
|
|
local src_bufnr = vim.b.oil_trash_toggle_src
|
|
if src_bufnr and vim.api.nvim_buf_is_valid(src_bufnr) then
|
|
url = vim.api.nvim_buf_get_name(src_bufnr)
|
|
end
|
|
end
|
|
else
|
|
vim.notify('No trash found for buffer', vim.log.levels.WARN)
|
|
return
|
|
end
|
|
vim.cmd.edit({ args = { url } })
|
|
vim.b.oil_trash_toggle_src = bufnr
|
|
end,
|
|
}
|
|
|
|
M.send_to_qflist = {
|
|
desc = 'Sends files in the current oil directory to the quickfix list, replacing the previous entries.',
|
|
callback = function(opts)
|
|
opts = vim.tbl_deep_extend('keep', opts or {}, {
|
|
target = 'qflist',
|
|
action = 'r',
|
|
only_matching_search = false,
|
|
})
|
|
util.send_to_quickfix({
|
|
target = opts.target,
|
|
action = opts.action,
|
|
only_matching_search = opts.only_matching_search,
|
|
})
|
|
end,
|
|
parameters = {
|
|
target = {
|
|
type = '"qflist"|"loclist"',
|
|
desc = 'The target list to send files to',
|
|
},
|
|
action = {
|
|
type = '"r"|"a"',
|
|
desc = 'Replace or add to current quickfix list (see |setqflist-action|)',
|
|
},
|
|
only_matching_search = {
|
|
type = 'boolean',
|
|
desc = 'Whether to only add the files that matches the last search. This option only applies when search highlighting is active',
|
|
},
|
|
},
|
|
}
|
|
|
|
M.add_to_qflist = {
|
|
desc = 'Adds files in the current oil directory to the quickfix list, keeping the previous entries.',
|
|
deprecated = true,
|
|
callback = function()
|
|
util.send_to_quickfix({
|
|
target = 'qflist',
|
|
mode = 'a',
|
|
})
|
|
end,
|
|
}
|
|
|
|
M.send_to_loclist = {
|
|
desc = 'Sends files in the current oil directory to the location list, replacing the previous entries.',
|
|
deprecated = true,
|
|
callback = function()
|
|
util.send_to_quickfix({
|
|
target = 'loclist',
|
|
mode = 'r',
|
|
})
|
|
end,
|
|
}
|
|
|
|
M.add_to_loclist = {
|
|
desc = 'Adds files in the current oil directory to the location list, keeping the previous entries.',
|
|
deprecated = true,
|
|
callback = function()
|
|
util.send_to_quickfix({
|
|
target = 'loclist',
|
|
mode = 'a',
|
|
})
|
|
end,
|
|
}
|
|
|
|
---List actions for documentation generation
|
|
---@private
|
|
M._get_actions = function()
|
|
local ret = {}
|
|
for name, action in pairs(M) do
|
|
if type(action) == 'table' and action.desc then
|
|
table.insert(ret, {
|
|
name = name,
|
|
desc = action.desc,
|
|
deprecated = action.deprecated,
|
|
parameters = action.parameters,
|
|
})
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
return M
|