Better "Open file but keep neo-tree focused"

[mwinters0]

My workflow

I have to edit groups of files spread across a huge codebase fairly often, and I realized that the only reason I ever really bounce over to GUI editors is for their persistent file browsers which make this easier. I wanted what I had there:

• It's easy to hunt for and open files across many locations.
  • With a keyboard, this means "don't auto-switch me into editing when I'm still hunting".
• It's easy to switch between "hunting" and "editing".
  • Editing -> Hunting is helped by a persistent file browser "drawer", so my eyes don't have to re-parse the screen when I switch.
  • Switching in either direction should be one keystroke.

Keep Neotree focused when opening files

I came up with this before finding other people's solutions. I thought I'd share since some people have reported "blink" issues with the existing approaches.

With my bindings:

• s = split
• v = vsplit
• Ctrl-s = split but keep focus in NeoTree
• Ctrl-v = vsplit but keep focus in NeoTree
• etc

      commands = {
        open_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_tabnew_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_tabnew"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_split_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_split"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_vsplit_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_vsplit"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
      }, -- commands
      window = {
        mappings = {
          ["<C-CR>"] = "open_keepfocus",
          ["<C-t>"] = "open_tabnew_keepfocus",
          ["<C-s>"] = "open_split_keepfocus",
          ["<C-v>"] = "open_vsplit_keepfocus",
          -- We can't do Ctrl-Shift mappings reliably to add a _keepfocus binding
          -- for "S", so we move open_vsplit to "v" to keep things consistent:
          ["v"] = "open_vsplit",
          ["s"] = "open_split",
          ["S"] = nil,
        }, -- mappings
      }, -- window

Hunting -> editing

With the above fix I could easily open files, but there wasn't a good way to return focus to editing when done. With this config, I can press | to toggle focus between my current editing window and the file browser.

In my global mappings:

vim.keymap.set('n', '|',
  function()
    -- Save current window before focusing neo-tree, so that we can return
    -- "here" (wherever that is) with a binding within Neotree.
    _G.neo_tree_previous_win = vim.api.nvim_get_current_win()
    vim.cmd('Neotree focus')
  end,
  { desc = 'Focus Neo-tree' }
)

In my Neotree config:

      commands = {
        return_focus = function(state)
          -- Toggle back to the previous window
          if _G.neo_tree_previous_win and vim.api.nvim_win_is_valid(_G.neo_tree_previous_win) then
            vim.api.nvim_set_current_win(_G.neo_tree_previous_win)
            _G.neo_tree_previous_win = nil
          end
        end,
      },
      window = {
        mappings = {
          ["|"] = "return_focus",
        }
      }

Fin

Combined config

      commands = {
        open_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_tabnew_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_tabnew"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_split_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_split"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        open_vsplit_keepfocus = function(state)
          local neo_tree_win = vim.api.nvim_get_current_win()
          local node = state.tree:get_node()
          if node.type == "file" then
            state.commands["open_vsplit"](state)
            vim.api.nvim_set_current_win(neo_tree_win)
          end
        end,
        return_focus = function(state)
          -- Toggle back to the previous window
          if _G.neo_tree_previous_win and vim.api.nvim_win_is_valid(_G.neo_tree_previous_win) then
            vim.api.nvim_set_current_win(_G.neo_tree_previous_win)
            _G.neo_tree_previous_win = nil
          end
        end,
      }, -- commands
      window = {
        mappings = {
          ["<C-CR>"] = "open_keepfocus",
          ["<C-t>"] = "open_tabnew_keepfocus",
          ["<C-s>"] = "open_split_keepfocus",
          ["<C-v>"] = "open_vsplit_keepfocus",
          -- We can't do Ctrl-Shift mappings reliably, so we move some
          -- defaults to keep things consistent between "normal" and
          -- their "keepfocus" versions:
          -- DEFAULT         -> NEW
          -- S (open_split)  -> s
          -- s (open_vsplit) -> v
          ["v"] = "open_vsplit",
          ["s"] = "open_split",
          ["S"] = nil,
          ["|"] = "return_focus",
        }, -- mappings

If / when I need the screen space, I can just focus Neotree and q.

TODO

• I wanted to swap the bindings so that all of the default keys such as <CR> are the _keepfocus versions, but it seems that <CR> is a special case? I can't seem to rebind it correctly. If anyone has any tips on that, I'd appreciate it!
• Do all the same for persistent Neotree buffer browser.