[mini.pick] Expanded Project Picker (persistence, LRU, configuration)

[badosu]

Inspired by the excellent #1141 I managed to get something that satisfies my additional needs.

What I added:

• Allows configuring project detection
• Persists projects when a buffer is created and detected to be present in a project
• Sort by most recently picked or edited
• Cleanup if detection can't find the project anymore (e.g. project removed)

UI is basically the same as the original.

Code

 local pick = require("mini.pick")

local M = {}

local config = {
  detect = function(path)
    return vim.fs.root(path, ".git")
  end,
  state_file = vim.fs.joinpath(vim.fn.stdpath("state"), "projects.json")
}

local projects = {}
local dirty = false
local save_pending = false

local function mark_dirty()
  dirty = true

  if save_pending then
    return
  end

  save_pending = true

  vim.defer_fn(function()
    save_pending = false
    if not dirty then
      return
    end

    dirty = false

    vim.fn.mkdir(vim.fn.fnamemodify(config.state_file, ":h"), "p")
    vim.fn.writefile({ vim.json.encode(projects) }, config.state_file)
  end, 2000)
end

local function load()
  local ok, decoded = pcall(vim.json.decode, vim.fn.readblob(config.state_file))

  if ok and type(decoded) == "table" then
    projects = decoded
  end
end

local function cleanup()
  local changed = false

  for path in pairs(projects) do
    if not config.detect(path) then
      projects[path] = nil
      changed = true
    end
  end

  if changed then
    mark_dirty()
  end
end

local function add(path)
  path = vim.fs.normalize(path)

  if not projects[path] then
    projects[path] = {
      path = path,
      name = vim.fs.basename(path),
    }
  end

  projects[path].last_used = 0

  mark_dirty()
end

---@return boolean touched whether a project was present to be touched
local function touch(path)
  local project = projects[path]
  if not project then
    return false
  end

  project.last_used = os.time()
  mark_dirty()

  return true
end

local function display_name(path)
  local home = vim.fn.expand("~")
  path = vim.fs.normalize(path)

  -- 1. replace home with ~
  if path:sub(1, #home) == home then
    path = "~" .. path:sub(#home + 1)
  end

  path = path:gsub("^/", "")

  return path
end

local function list()
  local items = vim.tbl_values(projects)

  table.sort(items, function(a, b)
    return (a.last_used or 0) > (b.last_used or 0)
  end)

  return vim.tbl_map(function(p)
    return {
      path = p.path,
      text = display_name(p.path),
      last_used = p.last_used,
    }
  end, items)
end

local function check_buffer(arg)
  local file = vim.api.nvim_buf_get_name(arg.buf)
  if file == "" then
    return
  end

  local root = config.detect(file)

  if root and not touch(root) then
    add(root)
  end
end

-- ```lua
-- require("config.project").setup({
--   detect = function(path)
--     return vim.fs.root(path, ".git")
--   end,
--   state_file = vim.fs.joinpath(vim.fn.stdpath("state"), "projects.json")
-- })
-- ```
function M.setup(opts)
  config = vim.tbl_deep_extend("force", config, opts or {})

  load()
  cleanup()

  -- So that we can check buffers opened via cmdline (does not trigger bufreadpost, bufnewfile)
  for _, buf in ipairs(vim.api.nvim_list_bufs()) do
    check_buffer({ buf = buf })
  end

  vim.api.nvim_create_autocmd({ "BufReadPost", "BufNewFile" }, { callback = check_buffer })
end

function M.pick(opts)
  local choose = function(item)
    if not item then
      return
    end

    touch(item.path)
    vim.fn.chdir(item.path)
    vim.schedule(function()
      pick.builtin.files(nil, { source = { cwd = item.path } })
    end)
  end

  local preview = function(buf_id, item)
    if not item then
      return
    end

    local files = {}

    for name, typ in vim.fs.dir(item.path) do
      if typ == "file" and not name:match("^%.") then
        table.insert(files, name)
      end
    end

    table.sort(files)

    vim.api.nvim_buf_set_lines(buf_id, 0, -1, false, files)
  end

  local source = {
    name = "Projects",
    items = list(),
    choose = choose,
    preview = preview,
  }

  opts = vim.tbl_deep_extend("force", {
    source = source,
  }, opts or {})

  return pick.start(opts)
end

function M.add(path)
  path = vim.fs.normalize(path)

  if not projects[path] then
    projects[path] = {
      path = path,
      name = vim.fs.basename(path),
      last_used = os.time(),
    }
    mark_dirty()
  end
end

return M

Configuration

-- Default options below
require("config.project").setup({
  detect = function(path)
    return vim.fs.root(path, ".git")
  end,
  state_file = vim.fs.joinpath(vim.fn.stdpath("state"), "projects.json")
})

-- Example keymap
vim.keymap.set("n", "<leader>p", require("config.project").pick, { desc = "Projects" })

Personally I ignore any project under a dotdirectory in the home directory:

local is_dot_home_project = function(path)
  path = vim.fs.normalize(path)

  local home = vim.fs.normalize(vim.fn.expand("~"))

  -- only apply rule inside home
  if path:sub(1, #home) ~= home then
    return false
  end

  local rel = path:sub(#home + 2) -- strip "$HOME/"

  for part in rel:gmatch("[^/]+") do
    if part:sub(1, 1) == "." then
      return true
    end
  end

  return false
end

require("config.project").setup({
  detect = function(path)
    return not is_dot_home_project(path) and vim.fs.root(path, { ".git" })
  end,
})

[echasnovski]

Thanks for sharing! It looks like this is for 'mini.pick', so I adjusted the title.

Didn't read very thoroughly, but here are some quick observations:

• Instead of doing io.open and friends to write to the file, I'd suggest using vim.fn.writefile() and vim.fn.readblob(). They are fast enough for regular usage and make code much more concise and readable.
• For personal projects it might easier in the long run to not add all the "big plugin project" like boilerplate. Like configurable state path, setup(), etc. But that is more of a personal taste thing.

[badosu]

Hi, thanks for the feedback!

• Adjusted, looks much better now!
• I agree, but the detect configuration is something I absolutely know I'll be editing forever 😄 so I want to have the project snippet in a separate location (works better for my ability to navigate my configuration).

I also don't know yet if I'll have to add a keybinding to remove projects from persistence manually or not, will have to wait and see if the recency makes up for the clutter, so I am leaving the structure for an easy access to project.delete(dir).