From eedd642aad6c1af5d1f9073418acdcde7be660c4 Mon Sep 17 00:00:00 2001 From: Alexander Courtis Date: Sun, 22 Jan 2023 15:07:02 +1100 Subject: [PATCH 1/5] feat(api): api.tree.open: add current_window option --- doc/nvim-tree-lua.txt | 11 ++++++++++- lua/nvim-tree.lua | 25 +++++++++++++++++++++---- lua/nvim-tree/api.lua | 5 +++++ lua/nvim-tree/lib.lua | 14 +++++++++++--- 4 files changed, 47 insertions(+), 8 deletions(-) diff --git a/doc/nvim-tree-lua.txt b/doc/nvim-tree-lua.txt index 84cc4e51318..1b740c06a0e 100644 --- a/doc/nvim-tree-lua.txt +++ b/doc/nvim-tree-lua.txt @@ -1238,8 +1238,17 @@ that injects the node from the cursor position in the tree when calling the function. It will use the node you pass as an argument in priority if it exists. +api.tree.open({opts}) *nvim-tree.api.tree.open()* + Open the tree, focusing it if already open. + + Parameters: ~ + • {opts} (table) optional parameters + + Options: ~ + • {path} (string) root directory for the tree + • {current_window} (boolean) open the tree in the current window + - api.tree: *nvim-tree.api.tree* - - open `(path?: string)` - close - toggle `(find_file?: bool, no_focus?: bool, path?: string)` - focus diff --git a/lua/nvim-tree.lua b/lua/nvim-tree.lua index 3df149331cb..72fc989df24 100644 --- a/lua/nvim-tree.lua +++ b/lua/nvim-tree.lua @@ -70,13 +70,30 @@ end ---@deprecated M.on_keypress = require("nvim-tree.actions.dispatch").dispatch -function M.open(cwd) - cwd = cwd ~= "" and cwd or nil +---Open the tree, focusing if already open. +---@param opts ApiTreeOpenOpts|nil|string +function M.open(opts) + opts = opts or {} + + -- legacy case: only parameter is path + if type(opts) == "string" then + opts = { path = opts } + end + + -- sanitise path + if type(opts.path) == "string" then + if vim.fn.isdirectory(opts.path) == 0 then + opts.path = nil + end + else + opts.path = nil + end + if view.is_visible() then lib.set_target_win() view.focus() else - lib.open(cwd) + lib.open(opts) end end @@ -275,7 +292,7 @@ function M.on_enter(netrw_disabled) end if should_open or should_hijack or existing_tree_wins[1] ~= nil then - lib.open(cwd) + lib.open({ path = cwd }) if should_focus_other_window then vim.cmd "noautocmd wincmd p" diff --git a/lua/nvim-tree/api.lua b/lua/nvim-tree/api.lua index e40bfcd6729..fa212c3971b 100644 --- a/lua/nvim-tree/api.lua +++ b/lua/nvim-tree/api.lua @@ -16,7 +16,12 @@ local function inject_node(f) end end +---@class ApiTreeOpenOpts +---@field path string|nil path +---@field current_window boolean|nil + Api.tree.open = require("nvim-tree").open + Api.tree.toggle = require("nvim-tree").toggle Api.tree.close = require("nvim-tree.view").close Api.tree.close_in_this_tab = require("nvim-tree.view").close_this_tab_only diff --git a/lua/nvim-tree/lib.lua b/lua/nvim-tree/lib.lua index 82be687c82b..a84ba7cde6a 100644 --- a/lua/nvim-tree/lib.lua +++ b/lua/nvim-tree/lib.lua @@ -2,6 +2,7 @@ local renderer = require "nvim-tree.renderer" local view = require "nvim-tree.view" local core = require "nvim-tree.core" local utils = require "nvim-tree.utils" +local log = require "nvim-tree.log" local M = { target_winid = nil, @@ -150,15 +151,22 @@ function M.prompt(prompt_input, prompt_select, items_short, items_long, callback end end -function M.open(cwd) +---Open the tree, initialising as needed. Maybe hijack the current buffer. +---@param opts ApiTreeOpenOpts|string|nil legacy case opts is path string +function M.open(opts) + opts = opts or {} + M.set_target_win() - if not core.get_explorer() or cwd then - core.init(cwd or vim.loop.cwd()) + if not core.get_explorer() or opts.path then + core.init(opts.path or vim.loop.cwd()) end if should_hijack_current_buf() then view.close_this_tab_only() view.open_in_current_win() renderer.draw() + elseif opts.current_window then + view.open_in_current_win({ hijack_current_buf = false, resize = false }) + renderer.draw() else open_view_and_draw() end From ff65e9082dc4a67f9d9e1134ac5faba2e2eaa60f Mon Sep 17 00:00:00 2001 From: Alexander Courtis Date: Sun, 22 Jan 2023 16:04:08 +1100 Subject: [PATCH 2/5] feat(api): api.tree.toggle: add current_window option --- doc/nvim-tree-lua.txt | 14 ++++++++++- lua/nvim-tree.lua | 55 ++++++++++++++++++++++++++++--------------- lua/nvim-tree/api.lua | 7 ++++++ 3 files changed, 56 insertions(+), 20 deletions(-) diff --git a/doc/nvim-tree-lua.txt b/doc/nvim-tree-lua.txt index 1b740c06a0e..b60dafba0a0 100644 --- a/doc/nvim-tree-lua.txt +++ b/doc/nvim-tree-lua.txt @@ -1248,9 +1248,21 @@ api.tree.open({opts}) *nvim-tree.api.tree.ope • {path} (string) root directory for the tree • {current_window} (boolean) open the tree in the current window +api.tree.toggle({opts}) *nvim-tree.api.tree.toggle()* + Open or close the tree. + + Parameters: ~ + • {opts} (table) optional parameters + + Options: ~ + • {path} (string) root directory for the tree + • {current_window} (boolean) open the tree in the current window + • {focus} (boolean) focus the tree when opening + • {find_file} (boolean) find the current buffer + • {update_root} (boolean) see |nvim-tree.update_focused_file.update_root| + - api.tree: *nvim-tree.api.tree* - close - - toggle `(find_file?: bool, no_focus?: bool, path?: string)` - focus - reload - change_root `(path: string)` diff --git a/lua/nvim-tree.lua b/lua/nvim-tree.lua index 72fc989df24..8788a632b94 100644 --- a/lua/nvim-tree.lua +++ b/lua/nvim-tree.lua @@ -73,19 +73,17 @@ M.on_keypress = require("nvim-tree.actions.dispatch").dispatch ---Open the tree, focusing if already open. ---@param opts ApiTreeOpenOpts|nil|string function M.open(opts) - opts = opts or {} - - -- legacy case: only parameter is path - if type(opts) == "string" then - opts = { path = opts } + -- legacy arguments + if type(opts) ~= "table" then + opts = { + path = opts, + } end + opts = opts or {} + -- sanitise path - if type(opts.path) == "string" then - if vim.fn.isdirectory(opts.path) == 0 then - opts.path = nil - end - else + if type(opts.path) ~= "string" or vim.fn.isdirectory(opts.path) == 0 then opts.path = nil end @@ -181,16 +179,35 @@ function M.find_file(with_open, bufnr, bang) find_file(with_open, bufnr, bang) end -function M.toggle(with_find_file, no_focus, cwd, bang) +---Toggle the tree. +---@param opts ApiTreeToggleOpts|nil|boolean +function M.toggle(opts, no_focus, cwd, bang) + -- legacy arguments + if type(opts) ~= "table" then + opts = { + path = cwd, + focus = not no_focus, + find_file = opts, + update_root = bang, + } + end + + opts = opts or {} + + -- sanitise path + if type(opts.path) ~= "string" or vim.fn.isdirectory(opts.path) == 0 then + opts.path = nil + end + if view.is_visible() then view.close() else local previous_buf = vim.api.nvim_get_current_buf() - M.open(cwd) - if _config.update_focused_file.enable or with_find_file then - find_file(false, previous_buf, bang) + M.open { path = opts.path, current_window = opts.current_window } + if _config.update_focused_file.enable or opts.find_file then + find_file(false, previous_buf, opts.update_root) end - if no_focus then + if not opts.focus then vim.cmd "noautocmd wincmd p" end end @@ -292,7 +309,7 @@ function M.on_enter(netrw_disabled) end if should_open or should_hijack or existing_tree_wins[1] ~= nil then - lib.open({ path = cwd }) + lib.open { path = cwd } if should_focus_other_window then vim.cmd "noautocmd wincmd p" @@ -321,11 +338,11 @@ end local function setup_vim_commands() vim.api.nvim_create_user_command("NvimTreeOpen", function(res) - M.open(res.args) + M.open { path = res.args } end, { nargs = "?", complete = "dir" }) vim.api.nvim_create_user_command("NvimTreeClose", view.close, { bar = true }) vim.api.nvim_create_user_command("NvimTreeToggle", function(res) - M.toggle(false, false, res.args) + M.toggle { find_file = false, focus = true, path = res.args, update_root = false } end, { nargs = "?", complete = "dir" }) vim.api.nvim_create_user_command("NvimTreeFocus", M.focus, { bar = true }) vim.api.nvim_create_user_command("NvimTreeRefresh", reloaders.reload_explorer, { bar = true }) @@ -334,7 +351,7 @@ local function setup_vim_commands() find_file(true, nil, res.bang) end, { bang = true, bar = true }) vim.api.nvim_create_user_command("NvimTreeFindFileToggle", function(res) - M.toggle(true, false, res.args, res.bang) + M.toggle { find_file = true, focus = false, path = res.args, update_root = res.bang } end, { bang = true, nargs = "?", complete = "dir" }) vim.api.nvim_create_user_command("NvimTreeResize", function(res) M.resize(res.args) diff --git a/lua/nvim-tree/api.lua b/lua/nvim-tree/api.lua index fa212c3971b..6b528eccf4f 100644 --- a/lua/nvim-tree/api.lua +++ b/lua/nvim-tree/api.lua @@ -22,6 +22,13 @@ end Api.tree.open = require("nvim-tree").open +---@class ApiTreeToggleOpts +---@field path string|nil +---@field current_window boolean|nil +---@field focus boolean|nil +---@field find_file boolean|nil +---@field update_root boolean|nil + Api.tree.toggle = require("nvim-tree").toggle Api.tree.close = require("nvim-tree.view").close Api.tree.close_in_this_tab = require("nvim-tree.view").close_this_tab_only From 19f3b135f0bb7e6f71040a70513f7ce0113000a7 Mon Sep 17 00:00:00 2001 From: Alexander Courtis Date: Sun, 22 Jan 2023 16:06:33 +1100 Subject: [PATCH 3/5] feat(api): api.tree.toggle: add current_window option --- lua/nvim-tree/lib.lua | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lua/nvim-tree/lib.lua b/lua/nvim-tree/lib.lua index a84ba7cde6a..254af4bfbb1 100644 --- a/lua/nvim-tree/lib.lua +++ b/lua/nvim-tree/lib.lua @@ -2,7 +2,6 @@ local renderer = require "nvim-tree.renderer" local view = require "nvim-tree.view" local core = require "nvim-tree.core" local utils = require "nvim-tree.utils" -local log = require "nvim-tree.log" local M = { target_winid = nil, @@ -151,7 +150,7 @@ function M.prompt(prompt_input, prompt_select, items_short, items_long, callback end end ----Open the tree, initialising as needed. Maybe hijack the current buffer. +---Open the tree, initialising as needed. Maybe hijack the current buffer. ---@param opts ApiTreeOpenOpts|string|nil legacy case opts is path string function M.open(opts) opts = opts or {} @@ -165,7 +164,7 @@ function M.open(opts) view.open_in_current_win() renderer.draw() elseif opts.current_window then - view.open_in_current_win({ hijack_current_buf = false, resize = false }) + view.open_in_current_win { hijack_current_buf = false, resize = false } renderer.draw() else open_view_and_draw() From 5ad817fffa5a076b0b65310c096f83d7f6081ab5 Mon Sep 17 00:00:00 2001 From: Alexander Courtis Date: Sun, 22 Jan 2023 16:52:01 +1100 Subject: [PATCH 4/5] doc: api.tree.* --- doc/nvim-tree-lua.txt | 112 ++++++++++++++++++++++++++++++++++-------- lua/nvim-tree/api.lua | 21 ++++++++ 2 files changed, 112 insertions(+), 21 deletions(-) diff --git a/doc/nvim-tree-lua.txt b/doc/nvim-tree-lua.txt index b60dafba0a0..5da5994b86e 100644 --- a/doc/nvim-tree-lua.txt +++ b/doc/nvim-tree-lua.txt @@ -1238,7 +1238,7 @@ that injects the node from the cursor position in the tree when calling the function. It will use the node you pass as an argument in priority if it exists. -api.tree.open({opts}) *nvim-tree.api.tree.open()* +api.tree.open({opts}) *nvim-tree.api.tree.open()* Open the tree, focusing it if already open. Parameters: ~ @@ -1248,7 +1248,7 @@ api.tree.open({opts}) *nvim-tree.api.tree.ope • {path} (string) root directory for the tree • {current_window} (boolean) open the tree in the current window -api.tree.toggle({opts}) *nvim-tree.api.tree.toggle()* +api.tree.toggle({opts}) *nvim-tree.api.tree.toggle()* Open or close the tree. Parameters: ~ @@ -1261,25 +1261,95 @@ api.tree.toggle({opts}) *nvim-tree.api.tree.toggl • {find_file} (boolean) find the current buffer • {update_root} (boolean) see |nvim-tree.update_focused_file.update_root| -- api.tree: *nvim-tree.api.tree* - - close - - focus - - reload - - change_root `(path: string)` - - change_root_to_node - - change_root_to_parent - - get_node_under_cursor - - get_nodes - - find_file `(filename: string)` - - search_node - - collapse_all `(keep_buffers?: bool)` - - expand_all - - toggle_gitignore_filter - - toggle_git_clean_filter - - toggle_no_buffer_filter - - toggle_custom_filter - - toggle_hidden_filter - - toggle_help +api.tree.close() *nvim-tree.api.tree.close()* + Close the tree, affecting all tabs as per |nvim-tree.tab.sync.close| + +api.tree.close_in_this_tab() *nvim-tree.api.tree.close_in_this_tab()* + Close the tree in this tab only. + +api.tree.close_in_all_tabs() *nvim-tree.api.tree.close_in_all_tabs()* + Close the tree in all tabs. + +api.tree.focus() *nvim-tree.api.tree.focus()* + Focus the tree, opening it if necessary. + +api.tree.reload() *nvim-tree.api.tree.focus()* + Refresh the tree. Does nothing if closed. + +api.tree.change_root({path}) *nvim-tree.api.tree.change_root()* + Change the tree's root to a path. + + Parameters: ~ + • {path} (string) absolute or relative path + + *nvim-tree.api.tree.change_root_to_node()* +api.tree.change_root_to_node({node}) + Change the tree's root to a folder node or the parent of a file node. + + Parameters: ~ + • {node} (Node) folder or file + + *nvim-tree.api.tree.change_root_to_parent()* +api.tree.change_root_to_parent({node}) + Change the tree's root to the parent of a node. + + Parameters: ~ + • {node} (Node) folder or file + + +api.tree.get_node_under_cursor() *nvim-tree.api.tree.get_node_under_cursor()* + Retrieve the currently focused node. + + Return: ~ + node or nil if tree is not visible + +api.tree.get_nodes() *nvim-tree.api.tree.get_nodes()* + Retrieve a hierarchical list of all the nodes. This is a cloned list for + reference purposes only and should not be passed into other API functions. + + Return: ~ + table of nodes + +api.tree.find_file({path}) *nvim-tree.api.tree.find_file()* + Find and focus a file or folder in the tree. + + Parameters: ~ + • {path} (string) absolute path + +api.tree.search_node() *nvim-tree.api.tree.search_node()* + Open the search dialogue as per the search_node action. + +api.tree.collapse_all({keep_buffers}) *nvim-tree.api.tree.collapse_all()* + Collapse the tree. + + Parameters: ~ + • {keep_buffers} (boolean) do not collapse nodes with open buffers. + +api.tree.expand_all({keep_buffers}) *nvim-tree.api.tree.expand_all()* + Expand all nodes in the tree. + + *nvim-tree.api.tree.toggle_gitignore_filter()* +api.tree.toggle_gitignore_filter() + Toggle |nvim-tree.git.ignore| filter. + + *nvim-tree.api.tree.toggle_git_clean_filter()* +api.tree.toggle_git_clean_filter() + Toggle |nvim-tree.filters.git_clean| filter. + + *nvim-tree.api.tree.toggle_no_buffer_filter()* +api.tree.toggle_no_buffer_filter() + Toggle |nvim-tree.filters.no_buffer| filter. + + *nvim-tree.api.tree.toggle_custom_filter()* +api.tree.toggle_custom_filter() + Toggle |nvim-tree.filters.custom| filter. + + *nvim-tree.api.tree.toggle_hidden_filter()* +api.tree.toggle_hidden_filter() + Toggle |nvim-tree.filters.dotfiles| filter. + +api.tree.toggle_help() *nvim-tree.api.tree.toggle_help()* + Toggle help view. - api.fs: *nvim-tree.api.fs* - create diff --git a/lua/nvim-tree/api.lua b/lua/nvim-tree/api.lua index 6b528eccf4f..679acec17d9 100644 --- a/lua/nvim-tree/api.lua +++ b/lua/nvim-tree/api.lua @@ -30,12 +30,19 @@ Api.tree.open = require("nvim-tree").open ---@field update_root boolean|nil Api.tree.toggle = require("nvim-tree").toggle + Api.tree.close = require("nvim-tree.view").close + Api.tree.close_in_this_tab = require("nvim-tree.view").close_this_tab_only + Api.tree.close_in_all_tabs = require("nvim-tree.view").close_all_tabs + Api.tree.focus = require("nvim-tree").focus + Api.tree.reload = require("nvim-tree.actions.reloaders.reloaders").reload_explorer + Api.tree.change_root = require("nvim-tree").change_dir + Api.tree.change_root_to_node = inject_node(function(node) if node.name == ".." then require("nvim-tree.actions.root.change-dir").fn ".." @@ -43,20 +50,34 @@ Api.tree.change_root_to_node = inject_node(function(node) require("nvim-tree.actions.root.change-dir").fn(require("nvim-tree.lib").get_last_group_node(node).absolute_path) end end) + Api.tree.change_root_to_parent = inject_node(require("nvim-tree.actions.root.dir-up").fn) + Api.tree.get_node_under_cursor = require("nvim-tree.lib").get_node_at_cursor + Api.tree.get_nodes = require("nvim-tree.lib").get_nodes + Api.tree.find_file = require("nvim-tree.actions.finders.find-file").fn + Api.tree.search_node = require("nvim-tree.actions.finders.search-node").fn + Api.tree.collapse_all = require("nvim-tree.actions.tree-modifiers.collapse-all").fn + Api.tree.expand_all = inject_node(require("nvim-tree.actions.tree-modifiers.expand-all").fn) + Api.tree.toggle_gitignore_filter = require("nvim-tree.actions.tree-modifiers.toggles").git_ignored + Api.tree.toggle_git_clean_filter = require("nvim-tree.actions.tree-modifiers.toggles").git_clean + Api.tree.toggle_no_buffer_filter = require("nvim-tree.actions.tree-modifiers.toggles").no_buffer + Api.tree.toggle_custom_filter = require("nvim-tree.actions.tree-modifiers.toggles").custom + Api.tree.toggle_hidden_filter = require("nvim-tree.actions.tree-modifiers.toggles").dotfiles + Api.tree.toggle_help = require("nvim-tree.actions.tree-modifiers.toggles").help + Api.fs.create = inject_node(require("nvim-tree.actions.fs.create-file").fn) Api.fs.remove = inject_node(require("nvim-tree.actions.fs.remove-file").fn) Api.fs.trash = inject_node(require("nvim-tree.actions.fs.trash").fn) From 6f883d2f27a4768674b6ed44babf19919167b0ff Mon Sep 17 00:00:00 2001 From: Alexander Courtis Date: Sun, 22 Jan 2023 16:53:21 +1100 Subject: [PATCH 5/5] doc: api.tree.* --- lua/nvim-tree/api.lua | 1 - 1 file changed, 1 deletion(-) diff --git a/lua/nvim-tree/api.lua b/lua/nvim-tree/api.lua index 679acec17d9..84f37937b5f 100644 --- a/lua/nvim-tree/api.lua +++ b/lua/nvim-tree/api.lua @@ -77,7 +77,6 @@ Api.tree.toggle_hidden_filter = require("nvim-tree.actions.tree-modifiers.toggle Api.tree.toggle_help = require("nvim-tree.actions.tree-modifiers.toggles").help - Api.fs.create = inject_node(require("nvim-tree.actions.fs.create-file").fn) Api.fs.remove = inject_node(require("nvim-tree.actions.fs.remove-file").fn) Api.fs.trash = inject_node(require("nvim-tree.actions.fs.trash").fn)