830 lines
21 KiB
Lua
830 lines
21 KiB
Lua
local lib = require 'nvim-tree.lib'
|
|
local log = require 'nvim-tree.log'
|
|
local appearance = require 'nvim-tree.appearance'
|
|
local renderer = require 'nvim-tree.renderer'
|
|
local view = require 'nvim-tree.view'
|
|
local commands = require 'nvim-tree.commands'
|
|
local utils = require 'nvim-tree.utils'
|
|
local actions = require 'nvim-tree.actions'
|
|
local legacy = require 'nvim-tree.legacy'
|
|
local core = require 'nvim-tree.core'
|
|
local git = require 'nvim-tree.git'
|
|
local filters = require 'nvim-tree.explorer.filters'
|
|
local buffers = require 'nvim-tree.buffers'
|
|
local events = require 'nvim-tree.events'
|
|
local notify = require 'nvim-tree.notify'
|
|
|
|
local _config = {}
|
|
|
|
local M = {
|
|
init_root = '',
|
|
}
|
|
|
|
--- Update the tree root to a directory or the directory containing
|
|
---@param path string relative or absolute
|
|
---@param bufnr number|nil
|
|
function M.change_root(path, bufnr)
|
|
-- skip if current file is in ignore_list
|
|
if type(bufnr) == 'number' then
|
|
local ft = vim.api.nvim_buf_get_option(bufnr, 'filetype') or ''
|
|
for _, value in pairs(_config.update_focused_file.ignore_list) do
|
|
if utils.str_find(path, value) or utils.str_find(ft, value) then
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
-- don't find inexistent
|
|
if vim.fn.filereadable(path) == 0 then
|
|
return
|
|
end
|
|
|
|
local cwd = core.get_cwd()
|
|
if cwd == nil then
|
|
return
|
|
end
|
|
|
|
local vim_cwd = vim.fn.getcwd()
|
|
|
|
-- test if in vim_cwd
|
|
if utils.path_relative(path, vim_cwd) ~= path then
|
|
if vim_cwd ~= cwd then
|
|
actions.root.change_dir.fn(vim_cwd)
|
|
end
|
|
return
|
|
end
|
|
-- test if in cwd
|
|
if utils.path_relative(path, cwd) ~= path then
|
|
return
|
|
end
|
|
|
|
-- otherwise test M.init_root
|
|
if _config.prefer_startup_root and utils.path_relative(path, M.init_root) ~= path then
|
|
actions.root.change_dir.fn(M.init_root)
|
|
return
|
|
end
|
|
-- otherwise root_dirs
|
|
for _, dir in pairs(_config.root_dirs) do
|
|
dir = vim.fn.fnamemodify(dir, ':p')
|
|
if utils.path_relative(path, dir) ~= path then
|
|
actions.root.change_dir.fn(dir)
|
|
return
|
|
end
|
|
end
|
|
-- finally fall back to the folder containing the file
|
|
actions.root.change_dir.fn(vim.fn.fnamemodify(path, ':p:h'))
|
|
end
|
|
|
|
function M.tab_enter()
|
|
if view.is_visible { any_tabpage = true } then
|
|
local bufname = vim.api.nvim_buf_get_name(0)
|
|
local ft = vim.api.nvim_buf_get_option(0, 'ft')
|
|
for _, filter in ipairs(M.config.tab.sync.ignore) do
|
|
if bufname:match(filter) ~= nil or ft:match(filter) ~= nil then
|
|
return
|
|
end
|
|
end
|
|
view.open { focus_tree = false }
|
|
renderer.draw()
|
|
end
|
|
end
|
|
|
|
function M.open_on_directory()
|
|
local should_proceed = _config.hijack_directories.auto_open or view.is_visible()
|
|
if not should_proceed then
|
|
return
|
|
end
|
|
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local bufname = vim.api.nvim_buf_get_name(buf)
|
|
if vim.fn.isdirectory(bufname) ~= 1 then
|
|
return
|
|
end
|
|
|
|
actions.root.change_dir.force_dirchange(bufname, true)
|
|
end
|
|
|
|
function M.place_cursor_on_node()
|
|
local ok, search = pcall(vim.fn.searchcount)
|
|
if ok and search and search.exact_match == 1 then
|
|
return
|
|
end
|
|
|
|
local node = lib.get_node_at_cursor()
|
|
if not node or node.name == '..' then
|
|
return
|
|
end
|
|
node = utils.get_parent_of_group(node)
|
|
|
|
local line = vim.api.nvim_get_current_line()
|
|
local cursor = vim.api.nvim_win_get_cursor(0)
|
|
local idx = vim.fn.stridx(line, node.name)
|
|
|
|
if idx >= 0 then
|
|
vim.api.nvim_win_set_cursor(0, { cursor[1], idx })
|
|
end
|
|
end
|
|
|
|
---@return table
|
|
function M.get_config()
|
|
return M.config
|
|
end
|
|
|
|
---@param disable_netrw boolean
|
|
---@param hijack_netrw boolean
|
|
local function manage_netrw(disable_netrw, hijack_netrw)
|
|
if hijack_netrw then
|
|
vim.cmd 'silent! autocmd! FileExplorer *'
|
|
vim.cmd 'autocmd VimEnter * ++once silent! autocmd! FileExplorer *'
|
|
end
|
|
if disable_netrw then
|
|
vim.g.loaded_netrw = 1
|
|
vim.g.loaded_netrwPlugin = 1
|
|
end
|
|
end
|
|
|
|
---@param name string|nil
|
|
function M.change_dir(name)
|
|
if name then
|
|
actions.root.change_dir.fn(name)
|
|
end
|
|
|
|
if _config.update_focused_file.enable then
|
|
actions.tree.find_file.fn()
|
|
end
|
|
end
|
|
|
|
---@param opts table
|
|
local function setup_autocommands(opts)
|
|
local augroup_id = vim.api.nvim_create_augroup('NvimTree', { clear = true })
|
|
local function create_nvim_tree_autocmd(name, custom_opts)
|
|
local default_opts = { group = augroup_id }
|
|
vim.api.nvim_create_autocmd(name, vim.tbl_extend('force', default_opts, custom_opts))
|
|
end
|
|
|
|
-- reset and draw (highlights) when colorscheme is changed
|
|
create_nvim_tree_autocmd('ColorScheme', {
|
|
callback = function()
|
|
appearance.setup()
|
|
view.reset_winhl()
|
|
renderer.draw()
|
|
end,
|
|
})
|
|
|
|
-- prevent new opened file from opening in the same window as nvim-tree
|
|
create_nvim_tree_autocmd('BufWipeout', {
|
|
pattern = 'NvimTree_*',
|
|
callback = function()
|
|
if not utils.is_nvim_tree_buf(0) then
|
|
return
|
|
end
|
|
if opts.actions.open_file.eject then
|
|
view._prevent_buffer_override()
|
|
else
|
|
view.abandon_current_window()
|
|
end
|
|
end,
|
|
})
|
|
|
|
create_nvim_tree_autocmd('BufWritePost', {
|
|
callback = function()
|
|
if opts.auto_reload_on_write and not opts.filesystem_watchers.enable then
|
|
actions.reloaders.reload_explorer()
|
|
end
|
|
end,
|
|
})
|
|
|
|
create_nvim_tree_autocmd('BufReadPost', {
|
|
callback = function(data)
|
|
-- update opened file buffers
|
|
if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= 'none') and vim.bo[data.buf].buftype == '' then
|
|
utils.debounce('Buf:filter_buffer', opts.view.debounce_delay, function()
|
|
actions.reloaders.reload_explorer()
|
|
end)
|
|
end
|
|
end,
|
|
})
|
|
|
|
create_nvim_tree_autocmd('BufUnload', {
|
|
callback = function(data)
|
|
-- update opened file buffers
|
|
if (filters.config.filter_no_buffer or renderer.config.highlight_opened_files ~= 'none') and vim.bo[data.buf].buftype == '' then
|
|
utils.debounce('Buf:filter_buffer', opts.view.debounce_delay, function()
|
|
actions.reloaders.reload_explorer()
|
|
end)
|
|
end
|
|
end,
|
|
})
|
|
|
|
create_nvim_tree_autocmd('User', {
|
|
pattern = { 'FugitiveChanged', 'NeogitStatusRefreshed' },
|
|
callback = function()
|
|
if not opts.filesystem_watchers.enable and opts.git.enable then
|
|
actions.reloaders.reload_git()
|
|
end
|
|
end,
|
|
})
|
|
|
|
if opts.tab.sync.open then
|
|
create_nvim_tree_autocmd('TabEnter', { callback = vim.schedule_wrap(M.tab_enter) })
|
|
end
|
|
if opts.hijack_cursor then
|
|
create_nvim_tree_autocmd('CursorMoved', {
|
|
pattern = 'NvimTree_*',
|
|
callback = function()
|
|
if utils.is_nvim_tree_buf(0) then
|
|
M.place_cursor_on_node()
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
if opts.sync_root_with_cwd then
|
|
create_nvim_tree_autocmd('DirChanged', {
|
|
callback = function()
|
|
M.change_dir(vim.loop.cwd())
|
|
end,
|
|
})
|
|
end
|
|
if opts.update_focused_file.enable then
|
|
create_nvim_tree_autocmd('BufEnter', {
|
|
callback = function()
|
|
utils.debounce('BufEnter:find_file', opts.view.debounce_delay, function()
|
|
actions.tree.find_file.fn()
|
|
end)
|
|
end,
|
|
})
|
|
end
|
|
|
|
if opts.hijack_directories.enable then
|
|
create_nvim_tree_autocmd({ 'BufEnter', 'BufNewFile' }, { callback = M.open_on_directory })
|
|
end
|
|
|
|
create_nvim_tree_autocmd('BufEnter', {
|
|
pattern = 'NvimTree_*',
|
|
callback = function()
|
|
if utils.is_nvim_tree_buf(0) then
|
|
if vim.fn.getcwd() ~= core.get_cwd() or (opts.reload_on_bufenter and not opts.filesystem_watchers.enable) then
|
|
actions.reloaders.reload_explorer()
|
|
end
|
|
end
|
|
end,
|
|
})
|
|
|
|
if opts.view.centralize_selection then
|
|
create_nvim_tree_autocmd('BufEnter', {
|
|
pattern = 'NvimTree_*',
|
|
callback = function()
|
|
vim.schedule(function()
|
|
vim.api.nvim_buf_call(0, function()
|
|
vim.cmd [[norm! zz]]
|
|
end)
|
|
end)
|
|
end,
|
|
})
|
|
end
|
|
|
|
if opts.diagnostics.enable then
|
|
create_nvim_tree_autocmd('DiagnosticChanged', {
|
|
callback = function()
|
|
log.line('diagnostics', 'DiagnosticChanged')
|
|
require('nvim-tree.diagnostics').update()
|
|
end,
|
|
})
|
|
create_nvim_tree_autocmd('User', {
|
|
pattern = 'CocDiagnosticChange',
|
|
callback = function()
|
|
log.line('diagnostics', 'CocDiagnosticChange')
|
|
require('nvim-tree.diagnostics').update()
|
|
end,
|
|
})
|
|
end
|
|
|
|
if opts.view.float.enable and opts.view.float.quit_on_focus_loss then
|
|
create_nvim_tree_autocmd('WinLeave', {
|
|
pattern = 'NvimTree_*',
|
|
callback = function()
|
|
if utils.is_nvim_tree_buf(0) then
|
|
view.close()
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
|
|
if opts.modified.enable then
|
|
create_nvim_tree_autocmd({ 'BufModifiedSet', 'BufWritePost' }, {
|
|
callback = function()
|
|
utils.debounce('Buf:modified', opts.view.debounce_delay, function()
|
|
buffers.reload_modified()
|
|
actions.reloaders.reload_explorer()
|
|
end)
|
|
end,
|
|
})
|
|
end
|
|
|
|
-- TODO #1545 remove similar check from view.resize
|
|
if vim.fn.has 'nvim-0.9' == 1 then
|
|
create_nvim_tree_autocmd('WinResized', {
|
|
callback = function()
|
|
if vim.v.event and vim.v.event.windows then
|
|
for _, winid in ipairs(vim.v.event.windows) do
|
|
if vim.api.nvim_win_is_valid(winid) and utils.is_nvim_tree_buf(vim.api.nvim_win_get_buf(winid)) then
|
|
events._dispatch_on_tree_resize(vim.api.nvim_win_get_width(winid))
|
|
end
|
|
end
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
|
|
on_attach = 'default',
|
|
hijack_cursor = false,
|
|
auto_reload_on_write = true,
|
|
disable_netrw = false,
|
|
hijack_netrw = true,
|
|
hijack_unnamed_buffer_when_opening = false,
|
|
root_dirs = {},
|
|
prefer_startup_root = false,
|
|
sync_root_with_cwd = false,
|
|
reload_on_bufenter = false,
|
|
respect_buf_cwd = false,
|
|
select_prompts = false,
|
|
sort = {
|
|
sorter = 'name',
|
|
folders_first = true,
|
|
files_first = false,
|
|
},
|
|
view = {
|
|
centralize_selection = false,
|
|
cursorline = true,
|
|
debounce_delay = 15,
|
|
side = 'left',
|
|
preserve_window_proportions = false,
|
|
number = false,
|
|
relativenumber = false,
|
|
signcolumn = 'yes',
|
|
width = 30,
|
|
float = {
|
|
enable = false,
|
|
quit_on_focus_loss = true,
|
|
open_win_config = {
|
|
relative = 'editor',
|
|
border = 'rounded',
|
|
width = 30,
|
|
height = 30,
|
|
row = 1,
|
|
col = 1,
|
|
},
|
|
},
|
|
},
|
|
renderer = {
|
|
add_trailing = false,
|
|
group_empty = false,
|
|
full_name = false,
|
|
root_folder_label = ':~:s?$?/..?',
|
|
indent_width = 2,
|
|
special_files = { 'Cargo.toml', 'Makefile', 'README.md', 'readme.md' },
|
|
symlink_destination = true,
|
|
highlight_git = 'none',
|
|
highlight_diagnostics = 'none',
|
|
highlight_opened_files = 'none',
|
|
highlight_modified = 'none',
|
|
highlight_bookmarks = 'none',
|
|
highlight_clipboard = 'name',
|
|
indent_markers = {
|
|
enable = false,
|
|
inline_arrows = true,
|
|
icons = {
|
|
corner = '└',
|
|
edge = '│',
|
|
item = '│',
|
|
bottom = '─',
|
|
none = ' ',
|
|
},
|
|
},
|
|
icons = {
|
|
web_devicons = {
|
|
file = {
|
|
enable = true,
|
|
color = true,
|
|
},
|
|
folder = {
|
|
enable = false,
|
|
color = true,
|
|
},
|
|
},
|
|
git_placement = 'before',
|
|
modified_placement = 'after',
|
|
diagnostics_placement = 'signcolumn',
|
|
bookmarks_placement = 'signcolumn',
|
|
padding = ' ',
|
|
symlink_arrow = ' ➛ ',
|
|
show = {
|
|
file = true,
|
|
folder = true,
|
|
folder_arrow = true,
|
|
git = true,
|
|
modified = true,
|
|
diagnostics = true,
|
|
bookmarks = true,
|
|
},
|
|
glyphs = {
|
|
default = '',
|
|
symlink = '',
|
|
bookmark = '',
|
|
modified = '●',
|
|
folder = {
|
|
arrow_closed = '',
|
|
arrow_open = '',
|
|
default = '',
|
|
open = '',
|
|
empty = '',
|
|
empty_open = '',
|
|
symlink = '',
|
|
symlink_open = '',
|
|
},
|
|
git = {
|
|
unstaged = '✗',
|
|
staged = '✓',
|
|
unmerged = '',
|
|
renamed = '➜',
|
|
untracked = '★',
|
|
deleted = '',
|
|
ignored = '◌',
|
|
},
|
|
},
|
|
},
|
|
},
|
|
hijack_directories = {
|
|
enable = true,
|
|
auto_open = true,
|
|
},
|
|
update_focused_file = {
|
|
enable = false,
|
|
update_root = false,
|
|
ignore_list = {},
|
|
},
|
|
system_open = {
|
|
cmd = '',
|
|
args = {},
|
|
},
|
|
git = {
|
|
enable = true,
|
|
show_on_dirs = true,
|
|
show_on_open_dirs = true,
|
|
disable_for_dirs = {},
|
|
timeout = 400,
|
|
cygwin_support = false,
|
|
},
|
|
diagnostics = {
|
|
enable = false,
|
|
show_on_dirs = false,
|
|
show_on_open_dirs = true,
|
|
debounce_delay = 50,
|
|
severity = {
|
|
min = vim.diagnostic.severity.HINT,
|
|
max = vim.diagnostic.severity.ERROR,
|
|
},
|
|
icons = {
|
|
hint = '',
|
|
info = '',
|
|
warning = '',
|
|
error = '',
|
|
},
|
|
},
|
|
modified = {
|
|
enable = false,
|
|
show_on_dirs = true,
|
|
show_on_open_dirs = true,
|
|
},
|
|
filters = {
|
|
enable = true,
|
|
git_ignored = true,
|
|
dotfiles = false,
|
|
git_clean = false,
|
|
no_buffer = false,
|
|
no_bookmark = false,
|
|
custom = {},
|
|
exclude = {},
|
|
},
|
|
live_filter = {
|
|
prefix = '[FILTER]: ',
|
|
always_show_folders = true,
|
|
},
|
|
filesystem_watchers = {
|
|
enable = true,
|
|
debounce_delay = 50,
|
|
ignore_dirs = {},
|
|
},
|
|
actions = {
|
|
use_system_clipboard = true,
|
|
change_dir = {
|
|
enable = true,
|
|
global = false,
|
|
restrict_above_cwd = false,
|
|
},
|
|
expand_all = {
|
|
max_folder_discovery = 300,
|
|
exclude = {},
|
|
},
|
|
file_popup = {
|
|
open_win_config = {
|
|
col = 1,
|
|
row = 1,
|
|
relative = 'cursor',
|
|
border = 'shadow',
|
|
style = 'minimal',
|
|
},
|
|
},
|
|
open_file = {
|
|
quit_on_open = false,
|
|
eject = true,
|
|
resize_window = true,
|
|
window_picker = {
|
|
enable = true,
|
|
picker = 'default',
|
|
chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890',
|
|
exclude = {
|
|
filetype = { 'notify', 'packer', 'qf', 'diff', 'fugitive', 'fugitiveblame' },
|
|
buftype = { 'nofile', 'terminal', 'help' },
|
|
},
|
|
},
|
|
},
|
|
remove_file = {
|
|
close_window = true,
|
|
},
|
|
},
|
|
trash = {
|
|
cmd = 'gio trash',
|
|
},
|
|
tab = {
|
|
sync = {
|
|
open = false,
|
|
close = false,
|
|
ignore = {},
|
|
},
|
|
},
|
|
notify = {
|
|
threshold = vim.log.levels.INFO,
|
|
absolute_path = true,
|
|
},
|
|
help = {
|
|
sort_by = 'key',
|
|
},
|
|
ui = {
|
|
confirm = {
|
|
remove = true,
|
|
trash = true,
|
|
default_yes = false,
|
|
},
|
|
},
|
|
experimental = {},
|
|
log = {
|
|
enable = false,
|
|
truncate = false,
|
|
types = {
|
|
all = false,
|
|
config = false,
|
|
copy_paste = false,
|
|
dev = false,
|
|
diagnostics = false,
|
|
git = false,
|
|
profile = false,
|
|
watcher = false,
|
|
},
|
|
},
|
|
} -- END_DEFAULT_OPTS
|
|
|
|
local function merge_options(conf)
|
|
return vim.tbl_deep_extend('force', DEFAULT_OPTS, conf or {})
|
|
end
|
|
|
|
local FIELD_SKIP_VALIDATE = {
|
|
open_win_config = true,
|
|
}
|
|
|
|
local ACCEPTED_TYPES = {
|
|
on_attach = { 'function', 'string' },
|
|
sort = {
|
|
sorter = { 'function', 'string' },
|
|
},
|
|
view = {
|
|
width = {
|
|
'string',
|
|
'function',
|
|
'number',
|
|
'table',
|
|
min = { 'string', 'function', 'number' },
|
|
max = { 'string', 'function', 'number' },
|
|
padding = { 'function', 'number' },
|
|
},
|
|
},
|
|
renderer = {
|
|
group_empty = { 'boolean', 'function' },
|
|
root_folder_label = { 'function', 'string', 'boolean' },
|
|
},
|
|
filters = {
|
|
custom = { 'function' },
|
|
},
|
|
actions = {
|
|
open_file = {
|
|
window_picker = {
|
|
picker = { 'function', 'string' },
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
local ACCEPTED_STRINGS = {
|
|
sort = {
|
|
sorter = { 'name', 'case_sensitive', 'modification_time', 'extension', 'suffix', 'filetype' },
|
|
},
|
|
view = {
|
|
side = { 'left', 'right' },
|
|
signcolumn = { 'yes', 'no', 'auto' },
|
|
},
|
|
renderer = {
|
|
highlight_git = { 'none', 'icon', 'name', 'all' },
|
|
highlight_opened_files = { 'none', 'icon', 'name', 'all' },
|
|
highlight_modified = { 'none', 'icon', 'name', 'all' },
|
|
highlight_bookmarks = { 'none', 'icon', 'name', 'all' },
|
|
highlight_diagnostics = { 'none', 'icon', 'name', 'all' },
|
|
highlight_clipboard = { 'none', 'icon', 'name', 'all' },
|
|
icons = {
|
|
git_placement = { 'before', 'after', 'signcolumn' },
|
|
modified_placement = { 'before', 'after', 'signcolumn' },
|
|
diagnostics_placement = { 'before', 'after', 'signcolumn' },
|
|
bookmarks_placement = { 'before', 'after', 'signcolumn' },
|
|
},
|
|
},
|
|
help = {
|
|
sort_by = { 'key', 'desc' },
|
|
},
|
|
}
|
|
|
|
---@param conf table|nil
|
|
local function validate_options(conf)
|
|
local msg
|
|
|
|
---@param user any
|
|
---@param def any
|
|
---@param strs table
|
|
---@param types table
|
|
---@param prefix string
|
|
local function validate(user, def, strs, types, prefix)
|
|
-- if user's option is not a table there is nothing to do
|
|
if type(user) ~= 'table' then
|
|
return
|
|
end
|
|
|
|
-- only compare tables with contents that are not integer indexed
|
|
if type(def) ~= 'table' or not next(def) or type(next(def)) == 'number' then
|
|
-- unless the field can be a table (and is not a table in default config)
|
|
if vim.tbl_contains(types, 'table') then
|
|
-- use a dummy default to allow all checks
|
|
def = {}
|
|
else
|
|
return
|
|
end
|
|
end
|
|
|
|
for k, v in pairs(user) do
|
|
if not FIELD_SKIP_VALIDATE[k] then
|
|
local invalid
|
|
|
|
if def[k] == nil and types[k] == nil then
|
|
-- option does not exist
|
|
invalid = string.format('Unknown option: %s%s', prefix, k)
|
|
elseif type(v) ~= type(def[k]) then
|
|
local expected
|
|
|
|
if types[k] and #types[k] > 0 then
|
|
if not vim.tbl_contains(types[k], type(v)) then
|
|
expected = table.concat(types[k], '|')
|
|
end
|
|
else
|
|
expected = type(def[k])
|
|
end
|
|
|
|
if expected then
|
|
-- option is of the wrong type
|
|
invalid = string.format('Invalid option: %s%s. Expected %s, got %s', prefix, k, expected, type(v))
|
|
end
|
|
elseif type(v) == 'string' and strs[k] and not vim.tbl_contains(strs[k], v) then
|
|
-- option has type `string` but value is not accepted
|
|
invalid = string.format("Invalid value for field %s%s: '%s'", prefix, k, v)
|
|
end
|
|
|
|
if invalid then
|
|
if msg then
|
|
msg = string.format('%s\n%s', msg, invalid)
|
|
else
|
|
msg = invalid
|
|
end
|
|
user[k] = nil
|
|
else
|
|
validate(v, def[k], strs[k] or {}, types[k] or {}, prefix .. k .. '.')
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
validate(conf, DEFAULT_OPTS, ACCEPTED_STRINGS, ACCEPTED_TYPES, '')
|
|
|
|
if msg then
|
|
notify.warn(msg .. '\n\nsee :help nvim-tree-opts for available configuration options')
|
|
end
|
|
end
|
|
|
|
--- Apply OS specific localisations to DEFAULT_OPTS
|
|
local function localise_default_opts()
|
|
if utils.is_macos or utils.is_windows then
|
|
DEFAULT_OPTS.trash.cmd = 'trash'
|
|
end
|
|
end
|
|
|
|
function M.purge_all_state()
|
|
require('nvim-tree.watcher').purge_watchers()
|
|
view.close_all_tabs()
|
|
view.abandon_all_windows()
|
|
if core.get_explorer() ~= nil then
|
|
git.purge_state()
|
|
core.reset_explorer()
|
|
end
|
|
end
|
|
|
|
---@param conf table|nil
|
|
function M.setup(conf)
|
|
if vim.fn.has 'nvim-0.8' == 0 then
|
|
notify.warn 'nvim-tree.lua requires Neovim 0.8 or higher'
|
|
return
|
|
end
|
|
|
|
M.init_root = vim.fn.getcwd()
|
|
|
|
localise_default_opts()
|
|
|
|
legacy.migrate_legacy_options(conf or {})
|
|
|
|
validate_options(conf)
|
|
|
|
local opts = merge_options(conf)
|
|
|
|
local netrw_disabled = opts.disable_netrw or opts.hijack_netrw
|
|
|
|
_config.root_dirs = opts.root_dirs
|
|
_config.prefer_startup_root = opts.prefer_startup_root
|
|
_config.update_focused_file = opts.update_focused_file
|
|
_config.hijack_directories = opts.hijack_directories
|
|
_config.hijack_directories.enable = _config.hijack_directories.enable and netrw_disabled
|
|
|
|
manage_netrw(opts.disable_netrw, opts.hijack_netrw)
|
|
|
|
M.config = opts
|
|
require('nvim-tree.notify').setup(opts)
|
|
require('nvim-tree.log').setup(opts)
|
|
|
|
if log.enabled 'config' then
|
|
log.line('config', 'default config + user')
|
|
log.raw('config', '%s\n', vim.inspect(opts))
|
|
end
|
|
|
|
require('nvim-tree.actions').setup(opts)
|
|
require('nvim-tree.keymap').setup(opts)
|
|
require('nvim-tree.appearance').setup()
|
|
require('nvim-tree.diagnostics').setup(opts)
|
|
require('nvim-tree.explorer').setup(opts)
|
|
require('nvim-tree.git').setup(opts)
|
|
require('nvim-tree.git.utils').setup(opts)
|
|
require('nvim-tree.view').setup(opts)
|
|
require('nvim-tree.lib').setup(opts)
|
|
require('nvim-tree.renderer').setup(opts)
|
|
require('nvim-tree.live-filter').setup(opts)
|
|
require('nvim-tree.marks').setup(opts)
|
|
require('nvim-tree.buffers').setup(opts)
|
|
require('nvim-tree.help').setup(opts)
|
|
require('nvim-tree.watcher').setup(opts)
|
|
if M.config.renderer.icons.show.file and pcall(require, 'nvim-web-devicons') then
|
|
require('nvim-web-devicons').setup()
|
|
end
|
|
|
|
setup_autocommands(opts)
|
|
|
|
if vim.g.NvimTreeSetup ~= 1 then
|
|
-- first call to setup
|
|
commands.setup()
|
|
else
|
|
-- subsequent calls to setup
|
|
M.purge_all_state()
|
|
end
|
|
|
|
vim.g.NvimTreeSetup = 1
|
|
vim.api.nvim_exec_autocmds('User', { pattern = 'NvimTreeSetup' })
|
|
end
|
|
|
|
vim.g.NvimTreeRequired = 1
|
|
vim.api.nvim_exec_autocmds('User', { pattern = 'NvimTreeRequired' })
|
|
|
|
return M
|