refactor!: convert all content types to string

**WIP**

`fzf_exec` now converts all content types (tables/funcs) to shell
command strings this greatly simplifies the code as all picker
inputs are now shell commands which can be used in fzf's reload,
execute-silent, etc.

This will also enable us to combine pickers easily with semicolon
or logical and, e.g. `cmd1; cmd2` or `cmd1 && cmd2`.

Fixes #2058 and prepares the ground for #1879, #2058.

Author: ibhagwan

README.md

@@ -1175,7 +1175,7 @@ previewers = {
   },
   quickfix = {
     file_icons        = true,
-    only_valid        = false, -- select among only the valid quickfix entries
+    valid_only        = false, -- select among only the valid quickfix entries
   },
   quickfix_stack = {
     prompt = "Quickfix Stack> ",

lua/fzf-lua/actions.lua

@@ -347,6 +347,33 @@ local sel_to_qf = function(selected, opts, is_loclist)
   end
 end
 
+M.list_del = function(selected, opts)
+  local winid = opts.__CTX.winid
+  local list = opts.is_loclist and vim.fn.getloclist(winid) or vim.fn.getqflist()
+
+  local buf_del = (function()
+    local ret = {}
+    for _, s in ipairs(selected) do
+      local b = s:match("%[(%d+)%]")
+      ret[b] = true
+    end
+    return ret
+  end)()
+
+  local newlist = {}
+  for _, l in ipairs(list) do
+    if not buf_del[tostring(l.bufnr)] then
+      table.insert(newlist, l)
+    end
+  end
+
+  if opts.is_loclist then
+    vim.fn.setloclist(winid, newlist, "r")
+  else
+    vim.fn.setqflist(newlist, "r")
+  end
+end
+
 M.file_sel_to_qf = function(selected, opts)
   sel_to_qf(selected, opts)
 end

lua/fzf-lua/config.lua

@@ -1021,6 +1021,7 @@ M._action_to_helpstr = {
   [actions.tmux_buf_set_reg]     = "set-register",
   [actions.paste_register]       = "paste-register",
   [actions.set_qflist]           = "set-{qf|loc}list",
+  [actions.list_del]             = "list-delete",
   [actions.apply_profile]        = "apply-profile",
   [actions.complete]             = "complete",
   [actions.dap_bp_del]           = "dap-bp-delete",

lua/fzf-lua/core.lua

@@ -72,6 +72,7 @@ M.ACTION_DEFINITIONS = {
   },
   [actions.buf_del]           = { "close" },
   [actions.arg_del]           = { "delete" },
+  [actions.list_del]          = { "delete" },
   [actions.dap_bp_del]        = { "delete" },
   [actions.cs_delete]         = { "uninstall" },
   [actions.cs_update]         = { "[down|re]-load" },
@@ -146,29 +147,31 @@ end
 ---@param contents content
 ---@param opts? {fn_reload: string|function, fn_transform: function, __fzf_init_cmd: string, _normalized: boolean}
 M.fzf_exec = function(contents, opts)
-  if type(contents) == "table" and type(contents[1]) == "table" then
-    contents = contents_from_arr(contents)
-  end
   if not opts or not opts._normalized then
     opts = config.normalize_opts(opts or {}, {})
     if not opts then return end
   end
-  -- save a copy of cprovider info in the opts, we later use it for better named
-  -- quickfix lists, use `pcall` because we will circular ref main object (#776)
-  _, opts.__INFO = pcall(loadstring("return require'fzf-lua'.get_info()"))
+  if type(contents) == "table" and type(contents[1]) == "table" then
+    contents = contents_from_arr(contents)
+  end
+  -- Save a copy of provider info in the opts, we will
+  -- later use it for better named quickfix lists (#776)
+  opts.__INFO = FzfLua.get_info()
+  -- Default fzf exit callback acts upon the selected items
   opts.fn_selected = opts.fn_selected or function(selected, o)
     actions.act(selected, o)
   end
-  -- wrapper for command transformer
-  if type(contents) == "string" and (opts.fn_transform or opts.fn_preprocess) then
-    contents = libuv.spawn_nvim_fzf_cmd({
-        cmd = contents,
-        cwd = opts.cwd,
-        cb_pid = function(pid) opts.__pid = pid end,
-      },
-      opts.fn_transform or function(x) return x end,
-      opts.fn_preprocess)
-  end
+  -- Contents sent to fzf can only be nil or a shell command (string)
+  -- the API accepts both tables and functions which we "stringify"
+  if contents ~= nil and type(contents) ~= "string" and not opts.__stringified then
+    opts.__contents = contents
+    local cmd, id = shell.stringify(opts)
+    -- Protect function ptr from being overwritten in the circular buffer
+    -- NOTE: will be cleared when a new picker is opened (not a resume)
+    shell.set_protected(id)
+    contents = cmd
+  end
+  assert(contents == nil or type(contents) == "string", "contents must be of type string")
   -- setup as "live": disables fuzzy matching and reload the content
   -- every keystroke (query changed), utilizes fzf's 'change:reload'
   -- event trigger or skim's "interactive" mode
@@ -428,7 +431,7 @@ M.fzf = function(contents, opts)
   local fzf_bufnr = fzf_win:create()
   -- convert "reload" actions to fzf's `reload` binds
   -- convert "exec_silent" actions to fzf's `execute-silent` binds
-  opts = M.convert_reload_actions(opts.__reload_cmd or contents, opts)
+  opts = M.convert_reload_actions(contents, opts)
   opts = M.convert_exec_silent_actions(opts)
   local selected, exit_code = fzf.raw_fzf(contents, M.build_fzf_cli(opts, fzf_win),
     {
@@ -898,22 +901,19 @@ M.mt_cmd_wrapper = function(opts)
     end
     return cmd
   else
-    assert(not opts.__mt_transform or type(opts.__mt_transform) == "function")
-    assert(not opts.__mt_preprocess or type(opts.__mt_preprocess) == "function")
-    assert(not opts.__mt_postprocess or type(opts.__mt_postprocess) == "function")
-    return libuv.spawn_nvim_fzf_cmd(opts,
-      function(x)
-        return opts.__mt_transform
-            and opts.__mt_transform(x, opts)
-            or make_entry.file(x, opts)
-      end,
-      function(o)
-        -- setup opts.cwd and git diff files
-        return opts.__mt_preprocess
-            and opts.__mt_preprocess(o)
-            or make_entry.preprocess(o)
-      end,
-      opts.__mt_postprocess and function(o) return opts.__mt_postprocess(o) end or nil)
+    assert(not opts.__fn_transform or type(opts.__fn_transform) == "function")
+    assert(not opts.__fn_preprocess or type(opts.__fn_preprocess) == "function")
+    assert(not opts.__fn_postprocess or type(opts.__fn_postprocess) == "function")
+    opts.__fn_transform = opts.__fn_transform == nil
+        and function(x) return make_entry.file(x, opts) end
+        or opts.__fn_transform
+    opts.__fn_preprocess = opts.__fn_preprocess == nil
+        and function(o) return make_entry.preprocess(o) end
+        or opts.__fn_preprocess
+    opts.__contents = opts.cmd
+    local cmd, id = shell.stringify(opts)
+    shell.set_protected(id)
+    return cmd
   end
 end
 
@@ -1431,7 +1431,7 @@ M.setup_fzf_interactive_wrap = function(opts)
 
   -- neovim shell wrapper for parsing the query and loading contents
   local fzf_field_expression = M.fzf_field_expression(opts)
-  local command = shell.reload_action_cmd(opts, fzf_field_expression)
+  local command = shell.stringify(opts, fzf_field_expression)
   return M.setup_fzf_interactive_flags(command, fzf_field_expression, opts)
 end
 

lua/fzf-lua/defaults.lua

@@ -580,8 +580,13 @@ M.defaults.quickfix             = {
   file_icons  = 1,
   color_icons = true,
   git_icons   = false,
-  only_valid  = false,
-  fzf_opts    = { ["--multi"] = true },
+  valid_only  = false,
+  fzf_opts    = {
+    ["--multi"]     = true,
+    ["--delimiter"] = "[\\]:]",
+    ["--with-nth"]  = "2..",
+  },
+  actions     = { ["ctrl-x"] = { fn = actions.list_del, reload = true } },
   _actions    = function() return M.globals.actions.files end,
   _treesitter = true,
   _cached_hls = { "path_colnr", "path_linenr" },
@@ -600,8 +605,13 @@ M.defaults.loclist              = {
   file_icons  = 1,
   color_icons = true,
   git_icons   = false,
-  only_valid  = false,
-  fzf_opts    = { ["--multi"] = true },
+  valid_only  = false,
+  fzf_opts    = {
+    ["--multi"]     = true,
+    ["--delimiter"] = "[\\]:]",
+    ["--with-nth"]  = "2..",
+  },
+  actions     = { ["ctrl-x"] = { fn = actions.list_del, reload = true } },
   _actions    = function() return M.globals.actions.files end,
   _treesitter = true,
   _cached_hls = { "path_colnr", "path_linenr" },
@@ -828,7 +838,7 @@ M.defaults.awesome_colorschemes = {
   actions      = {
     ["enter"]  = actions.colorscheme,
     ["ctrl-g"] = { fn = actions.toggle_bg, exec_silent = true },
-    ["ctrl-r"] = { fn = actions.cs_update, reload = true },
+    ["ctrl-d"] = { fn = actions.cs_update, reload = true },
     ["ctrl-x"] = { fn = actions.cs_delete, reload = true },
   }
 }

lua/fzf-lua/previewer/builtin.lua

@@ -1833,7 +1833,7 @@ function Previewer.nvim_options:populate_preview_buf(entry_str)
 
   -- get_help_text might be slow. pcall to prevent errors when scrolling the list too quickly
   pcall(function()
-    local lines = vim.list_extend(header, self:get_help_text(entry.name))
+    local lines = vim.list_extend(header, self:get_help_text(entry.name) or {})
     vim.api.nvim_buf_set_lines(tmpbuf, 0, -1, false, lines)
     self:set_preview_buf(tmpbuf)
   end)

lua/fzf-lua/providers/buffers.lua

@@ -187,30 +187,23 @@ M.buffers = function(opts)
   opts = config.normalize_opts(opts, "buffers")
   if not opts then return end
 
-  opts.__fn_reload = opts.__fn_reload or function(_)
-    return function(cb)
-      local filtered, _, max_bufnr = filter_buffers(opts, core.CTX().buflist)
-
-      if next(filtered) then
-        local buffers = populate_buffer_entries(opts, filtered)
-        for _, bufinfo in pairs(buffers) do
-          local ok, entry = pcall(gen_buffer_entry, opts, bufinfo, max_bufnr)
-          assert(ok and entry)
-          cb(entry)
-        end
+  local contents = function(cb)
+    local filtered, _, max_bufnr = filter_buffers(opts, core.CTX().buflist)
+
+    if next(filtered) then
+      local buffers = populate_buffer_entries(opts, filtered)
+      for _, bufinfo in pairs(buffers) do
+        local ok, entry = pcall(gen_buffer_entry, opts, bufinfo, max_bufnr)
+        assert(ok and entry)
+        cb(entry)
       end
-      cb(nil)
     end
+    cb(nil)
   end
 
-  -- build the "reload" cmd and remove '-- {+}' from the initial cmd
-  local contents, id = shell.reload_action_cmd(opts, "")
-  opts.__reload_cmd = contents
-
   -- get current tab/buffer/previous buffer
   -- save as a func ref for resume to reuse
   opts._fn_pre_fzf = function()
-    shell.set_protected(id)
     core.CTX({ includeBuflist = true }) -- include `nvim_list_bufs` in context
   end
 
@@ -409,79 +402,65 @@ M.tabs = function(opts)
       end, "", opts.debug))
   end
 
-  opts.__fn_reload = opts.__fn_reload or function(_)
-    -- we do not return the populate function with cb directly to avoid
-    -- E5560: nvim_exec must not be called in a lua loop callback
-    local entries = {}
-    local populate = function(cb)
-      local max_bufnr = (function()
-        local ret = 0
-        for _, t in ipairs(vim.api.nvim_list_tabpages()) do
-          for _, w in ipairs(vim.api.nvim_tabpage_list_wins(t)) do
-            local b = vim.api.nvim_win_get_buf(w)
-            if b > ret then ret = b end
-          end
+  local contents = function(cb)
+    local max_bufnr = (function()
+      local ret = 0
+      for _, t in ipairs(vim.api.nvim_list_tabpages()) do
+        for _, w in ipairs(vim.api.nvim_tabpage_list_wins(t)) do
+          local b = vim.api.nvim_win_get_buf(w)
+          if b > ret then ret = b end
         end
-        return ret
-      end)()
+      end
+      return ret
+    end)()
 
-      for tabnr, tabh in ipairs(vim.api.nvim_list_tabpages()) do
-        (function()
-          if opts.current_tab_only and tabh ~= core.CTX().tabh then return end
-
-          local tab_cwd = vim.fn.getcwd(-1, tabnr)
-          local tab_cwd_tilde = path.HOME_to_tilde(tab_cwd)
-          local title, fn_title_hl = opt_hl(tabnr, "tab_title",
-            function(s)
-              return string.format("%s%s#%d%s", s, utils.nbsp, tabnr,
-                (uv.cwd() == tab_cwd and "" or string.format(": %s", tab_cwd_tilde)))
-            end,
-            utils.ansi_codes[opts.hls.tab_title])
-
-          local marker, fn_marker_hl = opt_hl(tabnr, "tab_marker",
-            function(s) return s end,
-            utils.ansi_codes[opts.hls.tab_marker])
-
-          local tab_cwd_tilde_base64 = base64.encode(tab_cwd_tilde)
-          if not opts.current_tab_only then
-            cb(string.format("%s:%d:%d:0)%s%s  %s",
-              tab_cwd_tilde_base64,
-              tabnr,
-              tabh,
-              utils.nbsp,
-              fn_title_hl(title),
-              (tabh == core.CTX().tabh) and fn_marker_hl(marker) or ""))
-          end
+    for tabnr, tabh in ipairs(vim.api.nvim_list_tabpages()) do
+      (function()
+        if opts.current_tab_only and tabh ~= core.CTX().tabh then return end
+
+        local tab_cwd = vim.fn.getcwd(-1, tabnr)
+        local tab_cwd_tilde = path.HOME_to_tilde(tab_cwd)
+        local title, fn_title_hl = opt_hl(tabnr, "tab_title",
+          function(s)
+            return string.format("%s%s#%d%s", s, utils.nbsp, tabnr,
+              (uv.cwd() == tab_cwd and "" or string.format(": %s", tab_cwd_tilde)))
+          end,
+          utils.ansi_codes[opts.hls.tab_title])
+
+        local marker, fn_marker_hl = opt_hl(tabnr, "tab_marker",
+          function(s) return s end,
+          utils.ansi_codes[opts.hls.tab_marker])
+
+        local tab_cwd_tilde_base64 = base64.encode(tab_cwd_tilde)
+        if not opts.current_tab_only then
+          cb(string.format("%s:%d:%d:0)%s%s  %s",
+            tab_cwd_tilde_base64,
+            tabnr,
+            tabh,
+            utils.nbsp,
+            fn_title_hl(title),
+            (tabh == core.CTX().tabh) and fn_marker_hl(marker) or ""))
+        end
 
-          for _, w in ipairs(vim.api.nvim_tabpage_list_wins(tabh)) do
-            if tabh ~= core.CTX().tabh or core.CTX().curtab_wins[tostring(w)] then
-              local b = filter_buffers(opts, { vim.api.nvim_win_get_buf(w) })[1]
-              if b then
-                local prefix = string.format("%s:%d:%d:%d)%s%s%s",
-                  tab_cwd_tilde_base64, tabnr, tabh, w, utils.nbsp, utils.nbsp, utils.nbsp)
-                local bufinfo = populate_buffer_entries({}, { b }, w)[1]
-                cb(gen_buffer_entry(opts, bufinfo, max_bufnr, tab_cwd, prefix))
-              end
+        for _, w in ipairs(vim.api.nvim_tabpage_list_wins(tabh)) do
+          if tabh ~= core.CTX().tabh or core.CTX().curtab_wins[tostring(w)] then
+            local b = filter_buffers(opts, { vim.api.nvim_win_get_buf(w) })[1]
+            if b then
+              local prefix = string.format("%s:%d:%d:%d)%s%s%s",
+                tab_cwd_tilde_base64, tabnr, tabh, w, utils.nbsp, utils.nbsp, utils.nbsp)
+              local bufinfo = populate_buffer_entries({}, { b }, w)[1]
+              cb(gen_buffer_entry(opts, bufinfo, max_bufnr, tab_cwd, prefix))
             end
           end
-        end)()
-      end
-      cb(nil)
+        end
+      end)()
     end
-    populate(function(e)
-      if e then table.insert(entries, e) end
-    end)
-    return entries
+    cb(nil)
   end
 
-  -- build the "reload" cmd and remove '-- {+}' from the initial cmd
-  local contents, id = shell.reload_action_cmd(opts, "")
-  opts.__reload_cmd = contents
-
   -- get current tab/buffer/previous buffer
   -- save as a func ref for resume to reuse
   opts._fn_pre_fzf = function()
-    shell.set_protected(id)
     core.CTX({ includeBuflist = true }) -- include `nvim_list_bufs` in context
   end