[mini.pick] Shorten file picker paths

[diego-velez]

I started working on a huge codebase recently, and whenever I used the builtin files picker for mini.pick the entries would overflow the window. So I made a show function that shortens each file's path.

Code:

-- Shorten file directory
-- E.g. one/two/three/README.md -> o/t/t/README.md
local show_files = function(buf_id, entries, query, opts)
  for line, entry in ipairs(entries) do
    local new_entry = ''
    local _, directory_len = string.gsub(entry, '/', '/')
    directory_len = directory_len + 1

    local dir_i = 1
    for dir in string.gmatch(entry, '[^/]+') do
      -- Skip if only 1 file in directory
      if directory_len == 1 then
        new_entry = entry
        goto continue
      end

      -- Do not shorten last file/folder
      if dir_i == directory_len then
        new_entry = new_entry .. dir
        goto continue
      end

      -- If folder starts with . then show first two characters
      -- E.g. .config -> .c instead of just .
      if string.sub(dir, 1, 1) == '.' then
        new_entry = new_entry .. string.sub(dir, 1, 2) .. '/'
      else
        new_entry = new_entry .. string.sub(dir, 1, 1) .. '/'
      end

      ::continue::
      dir_i = dir_i + 1
    end

    entries[line] = new_entry
  end

  MiniPick.default_show(buf_id, entries, query, opts)
end

require('mini.pick').builtin.files({}, {
  source = { show = show_files },
})

Maybe would be nice to only shorten the entries that overflow the window somehow.

[echasnovski]

Thanks for sharing!

I personally find it really confusing and very hard to quickly identify files when parent directories are this short. Only recently I found it more or less bearable in shell prompt for current working directory, but only because it is something I manually adjust and it doesn't change that often.

Here is a more compact version of showing short parent directories:

local parent_dir_pattern = vim.fn.has('win32') == 1 and '([^\\/]+)([\\/])' or '([^/]+)(/)'
local shorten_dirname = function(name, path_sep)
  local first = vim.fn.strcharpart(name, 0, 1)
  first = first == '.' and vim.fn.strcharpart(name, 0, 2) or first
  return first .. path_sep
end
local make_short_path = function(path) return path:gsub(parent_dir_pattern, shorten_dirname) end

local show_short_files = function(buf_id, items_to_show, query)
  local short_items_to_show = vim.tbl_map(make_short_path, items_to_show)
  MiniPick.default_show(buf_id, short_items_to_show, query)
end

MiniPick.registry.files = function() MiniPick.builtin.files({}, { source = { show = show_short_files } }) end

Some important differences:

• It doesn't use goto which should not be used in Neovim's Lua. Because it is not present in Lua 5.1. specification (which all Neovim's Lua code should follow, see :h lua-compat) and only works by coincidence because LuaJIT supports it.
• It should work with both Windows and Unix paths and for multibyte characters in directory names.

Although using MiniPick.default_show() allows to show query matches, there are severe shortcomings:

• This visualization of matched characters is broken (because "true" matched characters might not be shown). Thankfully, shortening shown items doesn't affect matching (i.e. typing characters in query would still match inside full parent directories).
• There is no icons.

So to overcome both of these issues, full custom show function is required. Studying default_show() code might help here.

---

But the real solution to the problem of navigating too wide matches is the horizontal scroll. By default it is <C-l> to scroll right and <C-h> to scroll left. The scroll is preserved (as best as possible, because it depends on the width of the current item) when navigating up and down.

[diego-velez]

Thanks for the compact version!

I agree, I also find it confusing, but I prefer it to using horizontal scroll. As for a custom show function, I will definitely get to that once I have more time. 😅

I updated your code to shorten the path only whenever it does not fit in the buffer.

-- Use proper slash depending on OS
local parent_dir_pattern = vim.fn.has 'win32' == 1 and '([^\\/]+)([\\/])' or '([^/]+)(/)'

-- Returns the width of the buffer
local buffer_width = function(buf_id)
  for _, win in ipairs(vim.api.nvim_list_wins()) do
    if vim.api.nvim_win_get_buf(win) == buf_id then
      return vim.api.nvim_win_get_width(win)
    end
  end
  return nil
end

-- Shorten a folder's name
local shorten_dirname = function(name, path_sep)
  local first = vim.fn.strcharpart(name, 0, 1)
  first = first == '.' and vim.fn.strcharpart(name, 0, 2) or first
  return first .. path_sep
end

-- Shorten one path
local make_short_path = function(buf_width)
  return function(path)
    -- Do not shorten the path if it is not needed
    if #path < buf_width then
      return path
    end

    local shortened_path = path:gsub(parent_dir_pattern, shorten_dirname)
    -- Return only the filename when the shorten path still overflows
    if #shortened_path >= buf_width then
      return shortened_path:match(parent_dir_pattern)
    end

    return shortened_path
  end
end

-- Show function to shorten all entries
local show_short_files = function(buf_id, items_to_show, query)
  local buf_width = buffer_width(buf_id)
  local short_items_to_show = vim.tbl_map(make_short_path(buf_width), items_to_show)
  -- TODO: Instead of using default show, replace in order to highlight proper folder and add icons back
  MiniPick.default_show(buf_id, short_items_to_show, query)
end

require('mini.pick').builtin.files({}, {
  source = { show = show_short_files },
})

[echasnovski]

I agree, I also find it confusing, but I prefer it to using horizontal scroll. As for a custom show function, I will definitely get to that once I have more time. 😅

Sure, if that suits your needs better.

-- Returns the width of the buffer

As realistically you'd use this only when displaying in the picker's window, you can get limiting width more directly:

local win_id = MiniPick.get_picker_state().windows.main
local win_width = vim.api.nvim_win_get_width(win_id)

Or alternatively you can use local win_id = vim.fn.win_findbuf(buf_id)[1].

#path < buf_width

And again, this won't work with multibyte characters, as both #path and path:len() return number of bytes while width is the number of terminal cells. You can use vim.fn.strchars(path) to account for that.