Git Actions

[hinell]

nvim-tree.lua/lua/nvim-tree/actions/fs/rename-file.lua

Lines 23 to 40 in aaee4cd

	function M.rename(node, to)
	local notify_from = notify.render_path(node.absolute_path)
	local notify_to = notify.render_path(to)
	if utils.file_exists(to) then
	notify.warn(err_fmt(notify_from, notify_to, "file already exists"))
	return
	end
	events._dispatch_will_rename_node(node.absolute_path, to)
	local success, err = vim.loop.fs_rename(node.absolute_path, to)
	if not success then
	return notify.warn(err_fmt(notify_from, notify_to, err))
	end
	notify.info(notify_from .. "  " .. notify_to)
	utils.rename_loaded_buffers(node.absolute_path, to)
	events._dispatch_node_renamed(node.absolute_path, to)
	end

Describe the solution you'd like

The e and r don't respect git repo: by renaming something we loose track of file path history. I would like to be able to rename filepath by using git mv (instead of system command) in order to keep track of file renames:

git mv <src_path> <dst_path>

Currently, nvim-tree doesn't provide this feature forcing me to rename file by using git manually.

Describe alternatives you've considered

Running !git mv % <path_no_new_name> is rather clunky...
Running !git -A <path_no_new_name> is rather clunky and not something I want...

Can this functionality be implemented utilising API?

NO.

Additional context

I'ts difficult to easily contribute API feature, cause:

1. The runner is not a generic lua wrapper for git:

• it's hard-wired to run only single git subcommand: status
• quite intricate interally - it's hard to extend
• no docs/comments

3. This repo has no dedicated git wrapper for running & handling git output (there is a dedicated fast libgit2 lua bindings btw)
4. Intent of nvim-tree.git is unclear

[alex-courtis]

This comprehensive solution might help you out: Git Stage Unstage Files And Directories From The Tree

I'm using a (dumber) approach for git operations, mapping this one to gu:

local function git_unstage()
  local path, dir = node_path_dir()
  if path and dir then
    vim.fn.system({ "git", "-C", dir, "restore", "--staged", path })
  end
end

Changes to .git/index are be seen and the tree status is updated.

[alex-courtis]

I'll investigate a git wrapper however I can't promise anything.

[hinell]

@alex-courtis For a low-cost solution, you may peek wrappers at (it would be best if all maintainers unite to create unified api):

• gitsigns
• neogit
• diffview

I'm using a (dumber) approach

It's nice to have htis for paths; I usually stick to gitsigns to stage hunk-by-hunk

[alex-courtis]

Unfortunately we can't practically move to libgit2 lua bindings as it requires native compilation. Almost no plugins use that due to installation dramas.

It could be an optional implementation for power users.

[alex-courtis]

For a low-cost solution, you may peek wrappers at (it would be best if all maintainers unite to create unified api):

It would be sensible for many git plugins to use a single abstraction layer. That would be a large task...

[hinell]

Unfortunately we can't practically move

I'm not asking for that. I'm requesting a feture that would take renaming into account in git, so git kees track of it. It's totally fine if we go with something like vim.cmd([[!git mv ... ]]).

[hinell]

I've changed title back. It's all about using git for renaming. Whether to use dedicated libraries or terminal git command or not - is up to implementer.

[alex-courtis]

We do have a mechanism for renaming - the recipe. A git executable call is the only "API" that git provides.

Is there an issue with the renaming? The git watcher should pick up changes immediately.

[hinell]

It's a feature request.

Currently if you rename a file by using nvim-tree in a git repo the git will count it as deleted and the renamed file will be considered as untracked forcing me to make a full circle back to rename it back and then git mv.

It would be nice if nvim-tree avoids this situation by using git mv command for for tracked files so their renames is handled by git and history isn't lost.

[alex-courtis]

I see, no. mv file file.newname results in deleted / untracked as expected. When you stage, git will recognise the rename.

The tools are there, you just need to implement it yourself: as a mapping, or an event handler.

This would be a great opportunity for an extension plugin: https://github.com/nvim-tree/nvim-tree.lua/wiki/Extension-Plugins

[hinell]

When you stage, git will recognise the rename.

It won't unless -A flag is given to git add. Another consideration is that I use gisings for staging from within neovim, not from terminal i.e. to stage hunks, not entire files. Imagine it's already renamed and changes added.

[alex-courtis]

Feature

API additions to allow git mutation. These may be mapped by default.

gu, ga, gr etc. would be intuitive mappings.

Prior Art

• Recipe: Git Stage Unstage Files And Directories From The Tree
• neo-tree
• vim-fugitive

Alternative

Extension Plugin

Scope

Fugitive is stable and mature and interacts seamlessly with nvim-tree. Its mutation feature set would be safe and sufficient.

[hinell]

Well, even if we make an extension, we can't hook into default rename action. Users will have to redefine it.

[alex-courtis]

See #2551 (comment)