Use the LSP when available to fix references after (or before?) a file is moved or renamed.

https://github.com/jose-elias-alvarez/nvim-lsp-ts-utils/blob/main/lua/nvim-lsp-ts-utils/rename-file.lua

Great plugin - thank you!

Is there a way to disable relative line numbers from appearing within the neo-tree window automatically?

Support showing neo-tree as a floating window, as an alternative option to showing as a sidebar.

The following may be problematic:

1. One issue is that the window is currently named split, and should be renamed to something more generic like window.
2. Another issue is that the "open" commands assume it is a sidebar and choose the window to the left/right of the tree.
3. Finally, there may be issues with the other pop-up windows being used, when there are pop-ups on another pop-up.

Hi!

Just updated to the latest main (b580e39) and NeoTreeShow command seems to be broken. NeoTreeReveal still works and NeoTreeShowToggle is still correctly closing the side-panel.

Best,
Ivan

quickly toggle it through a shortcut key using it

Hey!

First of all, thanks for lightning-fast bugfixes! I have another one for you: neo-tree behaves inconsistenly when I switch the project using Telescope project. How to reproduce:

1. Open any file in a git directory, for example, your neovim config and toggle neo-tree.
2. Lauch Telescope proejct. As you start typing, Telescope will bring the closest matching project as the current selection under the cursor and neo-tree will detect this change and will automatically switch the root directory on the fly (WOW!)
3. Select a new project and then a file in this project by pressing Enter. This confuses neo-tree for some reason an it displays the old project root but without any content of the old project directory (screenshot below).

Best,
Ivan

Would you be interested in a pull request adding a component for showing the target of symbolic links?

This is one feature I miss from nvim-tree.

This is how it would currently look:

If I open the tree with :NeoTreeFloatToggle, it will show the current file (which I'm not sure if is intended or not). If I move somewhere else in the tree, hide the tree, then show it again, I am returned to where the file that was focused when first opening the tree rather than the file that I had previously navigated to before closing it.

For example:

where I first open the tree and it focuses the current buffer (whether or intended or not). I then change it to focus on another node, close the tree, then when I re-open it the focus is not on the same node as I closed it with

Filing for later, will likely poke at this myself.

After deleting a file in the tree (floating state), if the buffer deleted is the only other window open, we get an error noting the title of this issue.

At least as how I would expect it to.

The plenary.scandir respect_gitignore flag filters out entries in the current scan IFF a .gitignore file is present in the root of the path it scans. The do_scan function in fs_scan.lua scans with a depth of 1, so each time a folder is opened, a new scan is done with the path of that directory, which has the effect that a .gitignore in the root directory isn't picked up.

An example would be

.config/nvim/
|- lua/
   |- packer_compiled.lua
|- .gitignore 

with .gitignore containing lua/packer_compiled.lua; packer_compiled.lua is still visible in the tree.

One solution is to create a gitignore filter in fs_scan.lua and do the filtering there. This can easily be done by just copying the method plenary.scandir uses.

Another one is just scan the whole tree at once and on any refresh and so on, but that might be detrimental when there are a lot of files.

I have implemented the first solution and it works well. Another benefit of doing it that way is that ignored files could be highlighted differently.

Hi!

The steps to reproduce are the following:

1. Open a file in a git directory.
2. Call :NeotreeShowToggle to reveal neo-tree.
3. Call it one more time to hide it.
4. From now on calling it will give you a stack trace below.

I am using the latest main branch.

Best,
Ivan

Add the ability to enable indent guides like this:

I have some developments, so I can open a pull request, if you think it's worth adding this feature.

Currently calling :NeoTreeFloat twice in a row will try to render it again. I think it would make a lot more sense if it just toggled the floating tree, especially considering the fact that you cannot close it directly with either "Ctrl+w_c" or "Ctrl+w_q" as this results in the following:
Initial state:

After "Ctrl+w_c" or "Ctrl+w_q"

Say that I am in a node like this:

Being able to press a key and change the tree to this:

(so close the node that the cursor is currently inside of) would be a nice feature to have, similar to how nvim-tree.lua has close_node.

packer.nvim: Error running config for neo-tree.nvim: ...acker/start/neo-tree.nvim/lua/neo-tree/ui/highlights.lua:68: Vim(highlight):E411: highlight
group not found: NeoTreeNormal

NVIM version: v0.6.1

  use {
    "nvim-neo-tree/neo-tree.nvim",
    branch = "v1.x",
    requires = { "MunifTanjim/nui.nvim" },
    config = function ()
      require("neo-tree").setup()
    end
  }

Instead of making people override before_render, we can add config options to turn these off if they will not be used.

In the existing filesystem source. This would be just like the git_status, with a utility function called in the default before_render, and a built-in component that renders it.

This will enable auto updating of git status like we have with diagnostics. I think we can just watch project_root/.git/index and refresh the status whenever that changes.

it's possible?

Any time I attempt to filter the tree I get

Error executing luv callback:
...neo-tree.nvim/lua/neo-tree/sources/common/file-items.lua:51: attempt to index field 'name' (a nil value)
stack traceback:
        [builtin#36]: at 0x562387a7d900

I added a check for item.name's presence. The error is gone, but the filtering doesn't yield any results.

Any idea of what I'm doing wrong?

Cheers

Hi,
thanks for your amazing plugin. I'm currently seeing blue backgrounds behind the tree folder-arrows when using the theme Toyko Night (dark).

Essentially ls in tree form. The question is, should it be

• filtered to the current tab like BufExplorer can do
• grouped by tab (tab the buffers were last shown in)
• filtered to the cwd
• or show all open buffers without filters?

What about using stylua? This makes it easier to contribute in one style.

You (or I in a PR) could just add a stylua.toml file in the base of the repo.

In addition, you can create coding style checks before committing (stylua --check for example).

Github branch protection does not seem to cover this situation. I want to ensure that all PRs must be targeting the main branch and only the main branch. I can easily forget to check and accidentally merge a PR directly to a release branch.

Using the float implementation, if I open the tree using something like :NeoTreeFloatToggle it will open with the current buffer focused, as expected. If I hit <Esc> to close the NeoTree window, I then have to use :NeoTreeFloatToggle twice to get it to show up again.

Here is an example:

If using :NeoTreeFloatToggle when the window is visible to hide the the window, it opens on the first repeat of this command as expected.

I want to use / to search text as done in vim instead of the filter now being done. Changing key to "F" does not remove default keymap. Instead it maps both "/" and "F" to filter.

In the configuration section, the line containing ["gc"] = "git_commit" has a missing comma.

Steps to reproduce:

• open any file
• :NeoTreeReveal
• select that same file in the tree and delete it with d (the opened file then closes and the only window left is NeoTree)
• select another file and open it with Enter (this closes the NeoTree window, not sure why)
• :NeoTreeReveal

Expected behaviour: tree viewer should open
Actual behavior: nothing happens, presumably because NeoTree thinks it's already open even though it's not in the buffer list anymore

My config is the default one (an empty table passed to setup). Let me know if you need any further info.

User supplied mappings are not overriding the default ones.

EDIT: To be more precise, mappings with special characters, that may have multiple forms or are case insensitive, could create conflicts with default mappings. For example, a mapping of <BS> would not overwite the default mapping of <bs>, so both would be applied in an unknown order with unpredictable results.

The fix is to normalize those types of mapping to make sure that user supplied versions properly overwrite the default ones.

Hey, guys!

First, many thanks for your work on this plugin. I am a big fan: this is perhaps the most fluid and intuitive tree plugin to date.

Second, I've noticed that git status next to a file is being rendered despite being explicitly disabled by me in the config. Please see the screenshot attached:

On the right you can see the relevant part of my config. As you can notice, I explicitly restrict file renderer to being an icon and a name only. However, in the left panel I see that my config was modified. I believe this is an inconsistency of some sorts.

Best,
Ivan

Currently Ctrl-w will go into Normal mode instead of deleting the previous word, which would be the usual Insert mode behavior.

I tried customizing the Filesystem mappings in the following way:

      mappings = {
        ["<2-LeftMouse>"] = "open",
        ["<cr>"] = "open",
        ["<C-x>"] = "open_split",
        ["<C-v>"] = "open_vsplit",
        ["<C-w>"] = function()
          vim.cmd([[normal! bcw]])
        end,
...

However I believe this does not work because this mapping is not available inside the "Enter Filter Pattern" popup. Although if it did work, it would also cause problems for when wanting to use Ctrl-w in NeoTreeFloat outside of the filter pattern situation.

Basically, is it possible to restore the normal Ctrl-w behavior inside "Enter Filter Pattern" or allow the user to properly customize the keybindings within that particular situation?

One potential avenue that Telescope is using, is to allow different mappings for different modes:

    mappings = {
      i = {
        -- To disable a keymap, put [map] = false
        -- So, to not map "<C-n>", just put
        -- ["<c-x>"] = false,
        ["<esc>"] = actions.close,
        ["<C-w>"] = function()
          vim.cmd([[normal! bcw]])
        end,
        -- Otherwise, just set the mapping to the function that you want it to be.
        -- ["<C-i>"] = actions.select_horizontal,

        -- Add up multiple actions
        -- ["<CR>"] = actions.select_default + actions.center

        -- You can perform as many actions in a row as you like
        -- ["<CR>"] = actions.select_default + actions.center + my_cool_custom_action,
      },
      n = {
        --[[ ["<C-j>"] = actions.move_selection_next,
        ["<C-k>"] = actions.move_selection_previous,
        ["<C-q>"] = actions.smart_send_to_qflist + actions.open_qflist, ]]
        -- ["<C-i>"] = my_cool_custom_action,
      },
    },
  },

How it looks like

Possible implementaion

neo-tree/sources/filesystem/commands.lua

M.open = function(state)
-   cc.open(state, fs.toggle_directory)
+   cc.open(state, fs.toggle_directory, fs.close)
end

- M.open_split = function(state) cc.open_split(state, fs.toggle_directory) end
+ M.open_split = function(state) cc.open_split(state, fs.toggle_directory, fs.close) end

- M.open_vsplit = function(state) cc.open_vsplit(state, fs.toggle_directory) end
+ M.open_vsplit = function(state) cc.open_vsplit(state, fs.toggle_directory, fs.close) end

neo-tree/sources/common/commands.lua

- local open_with_cmd = function(state, open_cmd, toggle_directory)
+ local open_with_cmd = function(state, open_cmd, toggle_directory, close_window)
  ...
  if ...
    ...
  else
    ...
+     local auto_close = utils.resolve_config_option(state, "auto_close", false)
+     if auto_close then
+         close_window()
+     end
  end
end

- M.open = function(state, toggle_directory)
+ M.open = function(state, toggle_directory, close_window)
-   open_with_cmd(state, "e", toggle_directory)
+   open_with_cmd(state, "e", toggle_directory, close_window)
end

- M.open_split = function(state, toggle_directory)
+ M.open_split = function(state, toggle_directory, close_window)
-   open_with_cmd(state, "split", toggle_directory)
+   open_with_cmd(state, "split", toggle_directory, close_window)
end

- M.open_vsplit = function(state, toggle_directory)
+ M.open_vsplit = function(state, toggle_directory, close_window)
-   open_with_cmd(state, "vsplit", toggle_directory)
+   open_with_cmd(state, "vsplit", toggle_directory, close_window)
end

In 1.0, sources only had to implement a few simple methods and there was no real shared functionality. Now we have gotten to the point where there is, or should be, a lot of shared code between them.

Most of my life this would mean "extract a base class and/or interface", but I'm not sure if that's the right way to go here. Partly because lua has a pretty shoddy class and type system, but also because this was simply not designed in an OOP fashion from the start.

This issue exists to let others know this refactor is happening and to collect any discussion that may happen around this work. This may or may not create breaking changes that requires a 2.x branch.

Using the following configuration:

require("neo-tree").setup({
  filesystem = {
    window = {
      mappings = {
        ["<CR>"] = "open",
        ["<C-x>"] = "open_split",
        ["<C-v>"] = "open_vsplit",
        [".."] = "navigate_up",
        ["<BS>"] = "close_node",
        ["<C-]>"] = "set_root",
        ["H"] = "toggle_hidden",
        ["I"] = "toggle_gitignore",
        ["R"] = "refresh",
        ["/"] = "filter_as_you_type",
        ["f"] = "filter_on_submit",
        ["<C-l>"] = "clear_filter",
        ["o"] = "add",
        ["dd"] = "delete",
        ["r"] = "rename",
        ["yy"] = "copy_to_clipboard",
        ["x"] = "cut_to_clipboard",
        ["p"] = "paste_from_clipboard",
      },
      position = "float",
      popup = {
        border = {
          top = "",
          style = "rounded",
        },
        size = {
          width = 35,
          height = "100%",
        },
        position = {
          row = "0%",
          col = "0%",
        },
      },
    },
    bind_to_cwd = true,
    filters = {
      show_hidden = true,
      respect_gitignore = false,
    },
    before_render = function(_)
      return
    end,
    components = {
      user_icon = require("user.pack.config.tree.components").user_icon,
    },
    renderers = {
      directory = {
        {
          "user_icon",
          folder_closed = "",
          folder_open = "",
          folder_empty_closed = "",
          folder_empty_open = "",
          padding = " ",
        },
        { "current_filter" },
        { "name" },
        {
          "clipboard",
          highlight = highlights.DIM_TEXT,
        },
      },
    },
  },
})

I observe that when trying to try to expand a node for a directory that contains only hidden files with <CR>, nothing is expanded. The behavior of:

    filters = {
      show_hidden = true,
      respect_gitignore = false,
    },

is strictly related to filters (e.g. /), correct? Or is there a bug there and setting show_hidden = true should actually do what is noted here? As it stands right now, without using the (default) mapping of H, there is no other way to have this directory (containing only hidden files) expand. From what I can tell, this might just be a matter of things being copied over to the current state correctly, but I' not entirely sure how things are intended to behave.

This behavior is shown below:

Love the plugin :)

When I open the float panel in a buffer not pointing to a file, the popup will show with an invisible cursor

I can move around, open and close folders, but cursor is hidden.

You can see here, when I open on a file that exists on the fs, the cursor exists (over the icon of snippets.lua)

However, in the above case, cursorline does not seem to be set (you can see cursorline highlight in the window the float popped over.

Basic usage is OK, but we need much better documentation on how to customize Neo-tree. I think the wiki is the place for this.

Things to document include:

• Basic overview of all the ways it can be customized, with example use cases for each one
• List all built-in components along with their config options
• Full explanation of components and renderers
• Full explanation of mappings to custom functions (or defining commands)
• Full explanation of events (the vim doc is pretty good, maybe just copy to the wiki)
• Add some Recipes for custom components
• Add some Recipes for mapping to a custom function
• Add some recipes for event_handler usage
• LINK TO THE WIKI IN THE README!
• Remove README in lua/sources/filesystem, it's just a maintenance problem

If there is anything else you feel needs to be added or have any ideas at all on this subject, please add a comment. Also, if anything here seems like a particular priority, let me know what you think that order should be.

The is due to the "use last window" behavior. If the last window was in another tab, that's where the file opens. The behavior should be use the last window for the current tab, or open a new one.

Currently, this is handled using Buf* autocmds to detect when a file is changed in vim, but that misses events initiated outside outside of vim buffers, such as git actions.

It looks like nvim exposes a proper file watcher that we can use instead:
http://docs.libuv.org/en/v1.x/fs_event.html

:h watch-file

Hey!

Is there a way to make neo-tree automatically expand the directory nodes to the currently edited file? For example:

1. neo-tree is showing ~/.config/nvim with all directories collapsed. The currently edited file is init.nvim
2. I open a new file with :e after/ftplugin/html.vim
3. neo-tree automatically expands the directories after and ftplugin to show the currently edited file.

Ideally, this should also remember the manually expanded subdirectories. So if I have some other subdirectory my/other/subdir expanded by hand, then automatic expansion of after/ftplugin should not affect it; likewise, nothing opened previously by hand should not be automatically collapsed once I switch out of this subdirectory.

Best,
Ivan

The plugin does not display open buffers after starting a session.

NeoTree buffers. (Left)
Telescope buffers. (Front float)

Open nvim session, run any this command
(
:NeoTreeShow buffers
:NeoTreeFocus buffers
:NeoTreeFloat buffers
)
only 1 buffer.

Run
:Telescope buffers

you can see that there are many more buffers.

This is just a thought right now that needs to be fleshed out. Please comment if you have ideas or suggestions.

Right now the way to customize the behavior of Neo-tree is to override built-in commands or add your own. This works but it requires the user to find and understand the internal implementation, which takes more time than they may want to devote to this. A better, and perhaps safer way would be to create an event system, and they can just add event handlers to their config. Something like:

      require("neo-tree").setup({
        event_handlers = {
          {
            event = "before_render",
            handler = function (state)
              local utils = require("neo-tree.utils")
              state.git_status_lookup = utils.get_git_status()
              state.diagnostics_lookup = utils.get_diagnostic_counts()
            end
          },
          {
            event = "file_opened",
            handler = function(state, file_path)
              --auto close
              require("neo-tree").close(state.name)
            end
          },
          {
            event = "rename",
            handler = function(state, old_file_path, new_file_path)
              -- fix references to file
            end
          },
          {
            event = "move",
            handler = function(state, old_file_path, new_file_path)
              -- fix references to file
            end
          },
        }
      })

Hi!

I've found another issue with vim-rooter on the most recent main branch. The sidebar is not feeling well if you jump between the panes that belong to different projects. Here's how to reproduce it:

1. In a fresh nvim session split your window into two vertical splits and toggle neo-tree sidebar.
2. In the first split open a file from project P1 (let's say .config/nvim/init.vim). In the second split open a file from P2 (let's say .local/share/nvim/plugged/neo-tree).
3. You are now in the second split. Your cwd is set to P2 by vim-rooter. Switch to the first split. cwd is set to P1 and the tree is updated. Switch back to the second split. cwd is set back to P2, but the tree is still showing P1's cwd, but now collapsed.

This time I don't think it's related to debouncing and it happens if I wait for 10 seconds before each consequetive switch.

As usual, let me know if you need additional info.

Best,
Ivan

We really need to add a full suite of tests to this project, which can be run both locally and as a merge check. A handful of tests were created in #61 using plenary, which looks pretty good.

What needs to be tested?

• Every documented config option should do what it says
• Every bug fix should include a regression test (maybe just for future fixes?)
• All variations of vim commands (:NeoTree...) should do what the documentation says.

I really need to have NeoTree open the file I need in the window that was focused when NeoTree was toggled. Is this something that can be configured?

Thanks a lot!

Hi :)

I got this intermittently before, now it is constant #32

other icons seem fine.

When I got it intermittently, a second PackerCompile would confusingly make it go away (I would think that would be deterministic). Now it is sticking around

Just to show all modified files in the current repo. This will always look at the git project root of whatever the cwd is in, and therefore won't have any navigation commands or bind_to_cwd option.

It would also be nice to add some stage/unstage/revert commands in this view.

My configuration:

require("neo-tree").setup({
    enable_git_status = true,
    enable_diagnostics = true,
})

Actual behavior: