feat: auto load popups and auto populate help popup

lua/neogit/lib/buffer.lua

@@ -9,7 +9,7 @@ local Ui = require("neogit.lib.ui")
 
 ---@class Buffer
 ---@field handle number
----@field mmanager any
+---@field mmanager MappingsManager
 ---@field ui Ui
 ---@field kind string
 local Buffer = {

lua/neogit/lib/mappings_manager.lua

@@ -1,6 +1,17 @@
 local managers = {}
 
-local function invoke(id, map_id)
+---@alias Mapping string|function|MappingTable
+
+---@class MappingTable
+---@field [1] string mode
+---@field [2] string|function func
+---@field [3] boolean Escape visual mode
+
+---@class MappingsManager
+---@field mappings table<string, Mapping>
+local MappingsManager = {}
+
+function MappingsManager.invoke(id, map_id)
   local manager = managers[id]
   local k = manager.map_id_to_key[map_id]
   local mapping = manager.mappings[k]
@@ -12,11 +23,16 @@ local function invoke(id, map_id)
   end
 end
 
-local function build_call_string(id, k)
+function MappingsManager.build_call_string(id, k)
   return string.format([[<cmd>lua require 'neogit.lib.mappings_manager'.invoke(%d, %d)<CR>]], id, k)
 end
 
-local function new(id)
+function MappingsManager.delete(id)
+  managers[id] = nil
+end
+
+---@return MappingsManager
+function MappingsManager.new(id)
   local mappings = {}
   local map_id_to_key = {}
   local manager = {
@@ -26,7 +42,7 @@ local function new(id)
     register = function()
       for k, mapping in pairs(mappings) do
         local map_id = #map_id_to_key + 1
-        local f_call = build_call_string(id, map_id)
+        local f_call = MappingsManager.build_call_string(id, map_id)
         if type(mapping) == "table" then
           for _, m in pairs(vim.split(mapping[1], "")) do
             if type(mapping[2]) == "string" then
@@ -61,13 +77,4 @@ local function new(id)
   return manager
 end
 
-local function delete(id)
-  managers[id] = nil
-end
-
-return {
-  new = new,
-  build_call_string = build_call_string,
-  delete = delete,
-  invoke = invoke,
-}
+return MappingsManager

lua/neogit/lib/popup.lua

@@ -78,8 +78,10 @@ end
 
 -- Closes the popup buffer
 function M:close()
-  self.buffer:close()
-  self.buffer = nil
+  if self.buffer then
+    self.buffer:close()
+    self.buffer = nil
+  end
 end
 
 -- Determines the correct highlight group for a switch based on it's state.

lua/neogit/popups/echo/actions.lua

@@ -0,0 +1,7 @@
+local M = {}
+function M.echo(value)
+  local notification = require("neogit.lib.notification")
+  notification.create("Echo: " .. value)
+end
+
+return M

lua/neogit/popups/echo/init.lua

@@ -0,0 +1,22 @@
+local popup = require("neogit.lib.popup")
+local actions = require("neogit.popups.echo.actions")
+
+local M = {}
+
+function M.create(...)
+  local args = { ... }
+  local p = popup.builder():name("NeogitEchoPopup")
+  for k, v in ipairs(args) do
+    p:action(tostring(k), tostring(v), function()
+      actions.echo(v)
+    end)
+  end
+
+  local p = p:build()
+
+  p:show()
+
+  return p
+end
+
+return M

lua/neogit/popups/help/actions.lua

@@ -9,6 +9,11 @@ local function present(commands)
   local presenter = util.map(commands, function(command)
     local cmd, name, fn = unpack(command)
 
+    --- Handle the longer table mapping form (mode, func, esc)
+    if type(fn) == "table" then
+      fn = fn[2]
+    end
+
     return { name = name, key = status_mappings[cmd], fn = fn }
   end)
 
@@ -19,40 +24,22 @@ local function present(commands)
   return presenter
 end
 
-M.popups = function(env)
+M.popups = function()
   local popups = require("neogit.popups")
 
-  return present {
-    { "HelpPopup", "Help", popups.help.create },
-    { "DiffPopup", "Diff", popups.diff.create },
-    { "PullPopup", "Pull", popups.pull.create },
-    { "RebasePopup", "Rebase", popups.rebase.create },
-    { "MergePopup", "Merge", popups.merge.create },
-    { "PushPopup", "Push", popups.push.create },
-    { "CommitPopup", "Commit", popups.commit.create },
-    { "LogPopup", "Log", popups.log.create },
-    { "CherryPickPopup", "Apply", popups.cherry_pick.create },
-    { "BranchPopup", "Branch", popups.branch.create },
-    { "FetchPopup", "Fetch", popups.fetch.create },
-    { "ResetPopup", "Reset", popups.reset.create },
-    { "RevertPopup", "Revert", popups.revert.create },
-    { "RemotePopup", "Remote", popups.remote.create },
-    { "InitRepo", "Init", require("neogit.lib.git").init.init_repo },
-    {
-      "StashPopup",
-      "Stash",
-      function()
-        popups.stash.create(env.get_stash())
-      end,
-    },
+  local items = vim.list_extend({
     {
+
       "CommandHistory",
       "History",
       function()
         require("neogit.buffers.git_command_history"):new():show()
       end,
     },
-  }
+    { "InitRepo", "Init", require("neogit.lib.git").init.init_repo },
+  }, popups.mappings_table())
+
+  return present(items)
 end
 
 M.actions = function()

lua/neogit/popups/help/init.lua

@@ -7,7 +7,7 @@ local M = {}
 function M.create(env)
   local p = popup.builder():name("NeogitHelpPopup"):group_heading("Commands")
 
-  local popups = actions.popups(env)
+  local popups = actions.popups()
   for i, cmd in ipairs(popups) do
     p = p:action(cmd.key, cmd.name, cmd.fn)
 

lua/neogit/popups/init.lua

@@ -0,0 +1,109 @@
+local M = {}
+
+---@param name string
+---@param f nil|fun(create: fun(...)): any
+--- Creates a curried function which will open the popup with the given name when called
+function M.open(name, f)
+  f = f or function(f)
+    f()
+  end
+
+  return function()
+    local ok, value = pcall(require, "neogit.popups." .. name)
+    if ok then
+      assert(value, "popup is not nil")
+      assert(value.create, "popup has create function")
+
+      f(value.create)
+    else
+      local notification = require("neogit.lib.notification")
+      notification.create(string.format("No such popup: %q", name), vim.log.levels.ERROR)
+    end
+  end
+end
+
+--- Returns an array useful for creating mappings for the available popups
+---@return table<string, Mapping>
+function M.mappings_table()
+  local config = require("neogit.config")
+  local async = require("plenary.async")
+  return {
+    {
+      "HelpPopup",
+      "Help",
+      M.open("help", function(f)
+        f {
+          use_magit_keybindings = config.values.use_magit_keybindings,
+        }
+      end),
+    },
+    { "DiffPopup", "Diff", M.open("diff") },
+    { "PullPopup", "Pull", M.open("pull") },
+    {
+      "RebasePopup",
+      "Rebase",
+      M.open("rebase", function(f)
+        local status = require("neogit.status")
+        local line = status.status_buffer:get_current_line()
+        f { line[1]:match("^(%x%x%x%x%x%x%x+)") }
+      end),
+    },
+    { "MergePopup", "Merge", M.open("merge") },
+    { "PushPopup", "Push", M.open("push") },
+    { "CommitPopup", "Commit", M.open("commit") },
+    { "LogPopup", "Log", M.open("log") },
+    {
+      "CherryPickPopup",
+      "Cherry Pick",
+      {
+        "nv",
+        M.open(
+          "cherry_pick",
+          async.void(function(f)
+            local selection = nil
+
+            if vim.api.nvim_get_mode().mode == "V" then
+              local status = require("neogit.status")
+              selection = status.get_selected_commits()
+            end
+
+            f { commits = selection }
+          end)
+        ),
+        true,
+      },
+    },
+    { "BranchPopup", "Branch", M.open("branch") },
+    { "FetchPopup", "Fetch", M.open("fetch") },
+    { "ResetPopup", "Reset", M.open("reset") },
+    {
+      "RevertPopup",
+      "Revert",
+      M.open("revert", function(f)
+        local status = require("neogit.status")
+        local line = status.status_buffer:get_current_line()
+        f { commits = { line[1]:match("^(%x%x%x%x%x%x%x+)") } }
+      end),
+    },
+    { "RemotePopup", "Remote", M.open("remote") },
+    {
+      "StashPopup",
+      "Stash",
+      M.open("stash", function(f)
+        local status = require("neogit.status")
+        local line = status.status_buffer:get_current_line()
+        f {
+          name = line[1]:match("^(stash@{%d+})"),
+        }
+      end),
+    },
+  }
+end
+
+function M.test()
+  M.open("echo", function(f)
+    f("a", "b")
+  end)()
+end
+
+return M