Integration issues with other major Neovim Git plugins

[esmuellert]

I would also add that diffview.nvim is more "integrated" with other tools. As an example it can be opened from a folder view of oil.nvim while this one can't find the git root on that situation. Also as well allows to use fugitive or git signs commands as it is using just regular buffers. I just do :Git add % to stage the current buffer. Those tricks doesn't work with this plugin.

Still kudos for it, the diffing is really great per se and it's still early stages.

Edit: Git add % kinda works, but I have to focus the overview panel of changes to refresh, it doesn't auto refresh. Custom regular mappings from other plugins don't work

Originally posted by @RaulCote in #63

Thanks for providing the information about the plugin's integration with other major Git plugins. I actually would like to improve this area a bit more, but I personally don't use other plugins a lot (Lazygit + this plugin fulfills most of my needs). So, if possible, could you list a few more integration issues that this plugin has with other plugins? I would like to open this new issue to track comprehensively. From your last reply, I can see the following:

• Integration with oil.nvim (like opening from a folder view)
• fugitive commands like Git add %. Actually for this one, I feel it should work when you just have unstaged changes and do CodeDiff. The right diff buffer should support such operations because it is also a normal buffer.

Please let me know if you spot more integration issues, thanks!

[RaulCote]

Hi! thanks for be open minded about suggestions.

I can't really say more. I guess the main issue is that the tree showing staged / unstaged changes is not re-rendering when git changes happens, only re-renders when it's focused. When I do :Git add % or :Gitsigns stage_buffer, the tree doesn't show the new git status until I focus it. I guess the tree shouldn't "think" on particular git plugins, but it should be able to sync with proper git operations when they are fired and update inmediately.

Regarding the oil.nvim issue, it should be thought as well in a more generic way. vscode-diff.nvim should be able to get the git root dir without really checking the current buffer if the buffer doesn't have the info. It should be able to bubble up and find the git root dir by using proper git without looking at where it is right now. diffview.nvim looks like it does:

https://github.com/sindrets/diffview.nvim/blob/4516612fe98ff56ae0415a259ff6361a89419b0a/lua/diffview/vcs/adapters/git/init.lua#L183-L202

[oshevtsov]

@RaulCote I use gitsigns.nvim too and wanted to have the behavior you describe - when I stage a hunk or buffer, I want the vscode-diff explorer to update the git status. It turns out it is quite simple with the public API that vscode-diff already exposes.

Here is an example configuration for lazy.nvim, where I combine keybindings for gitsigns with the refresh callback written using vscode-diff API (see refresh_diff_git_status function):

  return {
    "lewis6991/gitsigns.nvim",
    dependencies = {
      {
        "esmuellert/vscode-diff.nvim",
        dependencies = {
          "MunifTanjim/nui.nvim",
        },
        cmd = "CodeDiff",
      },
    },
    config = function()
      require("gitsigns").setup({
        on_attach = function(bufnr)
          local gitsigns = require("gitsigns")

          local function map(mode, l, r, opts)
            opts = opts or {}
            opts.buffer = bufnr
            vim.keymap.set(mode, l, r, opts)
          end

          -- Navigation
          map("n", "]c", function()
            if vim.wo.diff then
              vim.cmd.normal({ "]c", bang = true })
            else
              gitsigns.nav_hunk("next")
            end
          end)

          map("n", "[c", function()
            if vim.wo.diff then
              vim.cmd.normal({ "[c", bang = true })
            else
              gitsigns.nav_hunk("prev")
            end
          end)

          local refresh_diff_git_status = function()
            local curr_buf = vim.api.nvim_get_current_buf()
            local diff_lifecycle = require("vscode-diff.render.lifecycle")
            local tabpage = diff_lifecycle.find_tabpage_by_buffer(curr_buf)

            if tabpage ~= nil then
              local session = diff_lifecycle.get_session(tabpage)
              if session ~= nil then
                if session.mode == "explorer" then
                  local diff_explorer = require("vscode-diff.render.explorer")
                  local explorer = diff_lifecycle.get_explorer(tabpage)
                  diff_explorer.refresh(explorer)
                end
              end
            end
          end

          -- Actions
          map("n", "<leader>bs", function()
            gitsigns.stage_buffer(refresh_diff_git_status)
          end, { desc = "Stage Git buffer" })

          map("n", "<leader>bu", function()
            gitsigns.reset_buffer_index(refresh_diff_git_status)
          end, { desc = "Unstage Git buffer" })

          map("n", "<leader>br", function()
            gitsigns.reset_buffer()
            refresh_diff_git_status()
          end, { desc = "Reset Git buffer" })

          map("n", "<leader>hs", function()
            gitsigns.stage_hunk(nil, nil, refresh_diff_git_status)
          end, { desc = "Stage/Unstage Git hunk" })

          map("n", "<leader>hr", function()
            gitsigns.reset_hunk(nil, nil, refresh_diff_git_status)
          end, { desc = "Reset Git hunk" })

          map("v", "<leader>hs", function()
            gitsigns.stage_hunk({ vim.fn.line("."), vim.fn.line("v") }, nil, refresh_diff_git_status)
          end, { desc = "Stage/Unstage Git hunk (visual mode)" })

          map("v", "<leader>hr", function()
            gitsigns.reset_hunk({ vim.fn.line("."), vim.fn.line("v") }, nil, refresh_diff_git_status)
          end, { desc = "Reset Git hunk (visual mode)" })

          map("n", "<leader>hp", gitsigns.preview_hunk, { desc = "Preview Git hunk" })
          map("n", "<leader>hi", gitsigns.preview_hunk_inline, { desc = "Preview Git hunk inline" })

          map("n", "<leader>lb", function()
            gitsigns.blame_line({ full = true })
          end, { desc = "Blame Git line" })
          map("n", "<leader>tb", gitsigns.toggle_current_line_blame, { desc = "Toggle blame Git line" })
        end,
      })

      vim.api.nvim_create_user_command("D", "CodeDiff", { desc = "Open CodeDiff Tab" })
    end,
  }

I hope this helps.

[CKolkey]

There's a branch to integrate this with neogit: NeogitOrg/neogit#1883

I'll try to push it across the finish line soon.

[kocv59]

Does gitsigns integration have to be done in codediff or gitsigns?

@oshevtsov Do you have to put the gitsigns config inside the codediff config function or can you put it a separate file?

[oshevtsov]

Does gitsigns integration have to be done in codediff or gitsigns?

@oshevtsov Do you have to put the gitsigns config inside the codediff config function or can you put it a separate file?

Well, I am sure you can structure it in many different ways. The example for lazy package manager I posted above is how I do it. In that case I made vscode-diff a dependency of gitsigns since I want it to be available when I configure gitsigns. The gitsigns config (keymaps) on the other hand relies on a callback function I created based on the vscode-diff public API. It just seemed to be a logical way to do it.

[esmuellert]

Hi! thanks for be open minded about suggestions.

I can't really say more. I guess the main issue is that the tree showing staged / unstaged changes is not re-rendering when git changes happens, only re-renders when it's focused. When I do :Git add % or :Gitsigns stage_buffer, the tree doesn't show the new git status until I focus it. I guess the tree shouldn't "think" on particular git plugins, but it should be able to sync with proper git operations when they are fired and update inmediately.

Regarding the oil.nvim issue, it should be thought as well in a more generic way. vscode-diff.nvim should be able to get the git root dir without really checking the current buffer if the buffer doesn't have the info. It should be able to bubble up and find the git root dir by using proper git without looking at where it is right now. diffview.nvim looks like it does:

https://github.com/sindrets/diffview.nvim/blob/4516612fe98ff56ae0415a259ff6361a89419b0a/lua/diffview/vcs/adapters/git/init.lua#L183-L202

For the hot reload or git status refreshment issue, this PR #151 started listening .git folder and it seems to work very well to refresh the explorer list at real time for any file changes in working tree. So I feel this problem is solved from root level?

For git repo detection issue, it seems to be a real bug that if you open a git folder, but open a buffer in another folder, it can't detect the current cwd as git root. Now I fixed it in #164 and seems like it can always use cwd as git root. So I feel the issue with oil.nvim is also fixed?

[oshevtsov]

Works well for me, thank you for looking into this.