refactor: simplify serialization

Author: phanen

lua/fzf-lua/lib/base64.lua

@@ -1,3 +1,8 @@
+if vim.base64 then
+  return vim.base64
+end
+
+---@format disable
 --[[
 
 Source: https://github.com/iskolbin/lbase64

lua/fzf-lua/libuv.lua

@@ -329,46 +329,43 @@ end
 -- Coroutine version of spawn so we can use queue
 M.async_spawn = coroutinify(M.spawn)
 
----@param opts table|string
----@param fn_transform_str string
----@param fn_preprocess_str string
----@param fn_postprocess_str string
----@return uv.uv_process_t, integer
-M.spawn_stdio = function(opts, fn_transform_str, fn_preprocess_str, fn_postprocess_str)
-  -- attempt base64 decoding on all params
-  ---@param str string|table
-  ---@return string|table
-  local base64_conditional_decode = function(str)
-    if opts._base64 == false or type(str) ~= "string" then return str end
-    local ok, decoded = pcall(base64.decode, str)
-    return ok and decoded or str
-  end
-
-  ---@param fn_str string
-  ---@return function?
-  local function load_fn(fn_str)
-    if type(fn_str) ~= "string" then return end
-    local fn_loaded = nil
-    local fn = loadstring(fn_str)
-    if fn then fn_loaded = fn() end
-    if type(fn_loaded) ~= "function" then
-      fn_loaded = nil
-    end
-    return fn_loaded
-  end
+---@param obj table
+---@param b64? boolean
+---@return string, boolean -- boolean used for ./scripts/headless_fd.sh
+M.serialize = function(obj, b64)
+  local str = serpent.line(obj, { comment = false, sortkeys = false })
+  str = b64 ~= false and base64.encode(str) or str
+  return "return [==[" .. str .. "]==]", (b64 ~= false and true or false)
+end
 
-  -- conditionally base64 decode, if not a base64 string, returns original value
-  opts = base64_conditional_decode(opts)
-  fn_transform_str = base64_conditional_decode(fn_transform_str)
-  fn_preprocess_str = base64_conditional_decode(fn_preprocess_str)
-  fn_postprocess_str = base64_conditional_decode(fn_postprocess_str)
+---@param str string
+---@param b64? boolean
+---@return table
+M.deserialize = function(str, b64)
+  local res = loadstring(str)()
+  if type(res) == "table" then return res --[[@as table]] end -- ./scripts/headless_fd.sh
+  res = b64 ~= false and base64.decode(res) or res
+  local _, obj = serpent.load(res)
+  assert(type(obj) == "table")
+  return obj
+end
 
-  -- opts must be a table, if opts is a string deserialize
-  if type(opts) == "string" then
-    _, opts = serpent.load(opts)
-    assert(type(opts) == "table")
+---@param fn_str string
+---@return function?
+M.load_fn = function(fn_str)
+  if type(fn_str) ~= "string" then return end
+  local fn_loaded = nil
+  local fn = loadstring(fn_str)
+  if fn then fn_loaded = fn() end
+  if type(fn_loaded) ~= "function" then
+    fn_loaded = nil
   end
+  return fn_loaded
+end
 
+---@param opts table
+---@return uv.uv_process_t, integer
+M.spawn_stdio = function(opts)
   local EOL = opts.multiline and "\0" or "\n"
 
   -- stdin/stdout are already buffered, not stderr. This means
@@ -398,10 +395,13 @@ M.spawn_stdio = function(opts, fn_transform_str, fn_preprocess_str, fn_postproce
   -- err with "fzf-lua fatal: '_G._fzf_lua_server', '_G._devicons_path' both nil"
   pcall(require, "fzf-lua.make_entry")
 
-  local fn_transform = load_fn(fn_transform_str)
-  local fn_preprocess = load_fn(fn_preprocess_str)
-  local fn_postprocess = load_fn(fn_postprocess_str)
+  local fn_transform_str = opts.fn_transform
+  local fn_preprocess_str = opts.fn_preprocess
+  local fn_postprocess_str = opts.fn_postprocess
 
+  local fn_transform = M.load_fn(opts.fn_transform)
+  local fn_preprocess = M.load_fn(opts.fn_preprocess)
+  local fn_postprocess = M.load_fn(opts.fn_postprocess)
 
   -- run the preprocessing fn
   if fn_preprocess then fn_preprocess(opts) end
@@ -568,6 +568,9 @@ end
 --
 -- this function is a better fit for utils but we're
 -- trying to avoid having any 'require' in this file
+---@param s string
+---@param win_style integer|string? 1=classic, 2=caret
+---@return string
 M.shellescape = function(s, win_style)
   if _is_win or win_style then
     if tonumber(win_style) == 1 then

lua/fzf-lua/shell.lua

@@ -2,8 +2,6 @@ local uv = vim.uv or vim.loop
 local utils = require "fzf-lua.utils"
 local path = require "fzf-lua.path"
 local libuv = require "fzf-lua.libuv"
-local base64 = require "fzf-lua.lib.base64"
-local serpent = require "fzf-lua.lib.serpent"
 
 -- path to current file
 local __FILE__ = debug.getinfo(1, "S").source:gsub("^@", "")
@@ -197,7 +195,9 @@ M.stringify_mt = function(cmd, opts)
       "exec_empty_query",
       "file_ignore_patterns",
       "rg_glob",
-      "_base64",
+      "fn_transform",
+      "fn_preprocess",
+      "fn_postprocess",
       utils.__IS_WINDOWS and "__FZF_VERSION" or nil,
     }
     -- caller requested rg with glob support
@@ -225,22 +225,6 @@ M.stringify_mt = function(cmd, opts)
     return t
   end
 
-  ---@param obj table|string
-  ---@return string
-  local serialize = function(obj)
-    local str = type(obj) == "table"
-        and serpent.line(obj, { comment = false, sortkeys = false })
-        or tostring(obj)
-    if opts._base64 ~= false then
-      -- by default, base64 encode all arguments
-      return "[==[" .. base64.encode(str) .. "]==]"
-    else
-      -- if not encoding, don't string wrap the table
-      return type(obj) == "table" and str
-          or "[==[" .. str .. "]==]"
-    end
-  end
-
   -- `multiprocess=1` is "optional" if no opt which requires processing
   -- is present we return the command as is to be piped to fzf "natively"
   if opts.multiprocess == 1
@@ -287,12 +271,7 @@ M.stringify_mt = function(cmd, opts)
         opts.fn_preprocess = [[return require("fzf-lua.make_entry").preprocess]]
       end
     end
-    local spawn_cmd = M.wrap_spawn_stdio(
-      serialize(filter_opts(opts)),
-      serialize(opts.fn_transform or "nil"),
-      serialize(opts.fn_preprocess or "nil"),
-      serialize(opts.fn_postprocess or "nil")
-    )
+    local spawn_cmd = M.wrap_spawn_stdio(filter_opts(opts))
     if opts.argv_expr then
       -- prefix the query with `--` so we can support `--fixed-strings` (#781)
       spawn_cmd = string.format("%s -- %s", spawn_cmd, FzfLua.core.fzf_query_placeholder)
@@ -315,27 +294,12 @@ M.stringify = function(contents, opts, fzf_field_index)
   assert(not opts.__stringified, "twice stringified")
   opts.__stringified = true
 
-  ---@param fn_str string
-  ---@return function?
-  local function load_fn(fn_str)
-    if type(fn_str) ~= "string" then return end
-    local fn_loaded = nil
-    local fn = loadstring(fn_str)
-    if fn then fn_loaded = fn() end
-    if type(fn_loaded) ~= "function" then
-      fn_loaded = nil
-    end
-    return fn_loaded
-  end
-
   -- Convert string callbacks to callback functions
   for _, k in ipairs({ "fn_transform", "fn_preprocess", "fn_postprocess" }) do
     local v = opts[k]
-    opts[k] = load_fn(opts[k]) or v
+    opts[k] = libuv.load_fn(opts[k]) or v
   end
 
-  assert(not opts.fn_reload or type(contents) == "function", "fn_reload must be of type function")
-
   local cmd, id = M.pipe_wrap_fn(function(pipe, ...)
     local args = { ... }
     -- Contents could be dependent or args, e.g. live_grep which
@@ -548,20 +512,16 @@ M.stringify_data2 = function(fn, opts, field_index)
   end, opts, field_index)
 end
 
----@param opts string
----@param fn_transform string
----@param fn_preprocess string
----@param fn_postprocess string
+---@param opts table
 ---@return string
-M.wrap_spawn_stdio = function(opts, fn_transform, fn_preprocess, fn_postprocess)
+M.wrap_spawn_stdio = function(opts)
   local is_win = utils.__IS_WINDOWS
   local nvim_bin = os.getenv("FZF_LUA_NVIM_BIN") or vim.v.progpath
   local cmd_str = ("%s -u NONE -l %s %s"):format(
     libuv.shellescape(is_win and vim.fs.normalize(nvim_bin) or nvim_bin),
     libuv.shellescape(vim.fn.fnamemodify(is_win and vim.fs.normalize(__FILE__) or __FILE__, ":h") ..
       "/spawn.lua"),
-    libuv.shellescape(("return %s,%s,%s,%s"):format(opts, fn_transform, fn_preprocess, fn_postprocess))
-  )
+    libuv.shellescape((libuv.serialize(opts, true))))
   return cmd_str
 end
 

lua/fzf-lua/spawn.lua

@@ -32,7 +32,8 @@ end
 
 -- global var indicating a headless instance
 _G._fzf_lua_is_headless = true
-local _, pid = require("fzf-lua.libuv").spawn_stdio(loadstring(_G.arg[1])())
+local opts = require("fzf-lua.libuv").deserialize(_G.arg[1])
+local _, pid = require("fzf-lua.libuv").spawn_stdio(opts)
 -- while vim.uv.run() do end -- os.exit in spawn_stdio
 while uv.os_getpriority(pid) do
   vim.wait(100, function() return uv.os_getpriority(pid) == nil end)

scripts/headless_fd.sh

@@ -140,20 +140,17 @@ nvim -u NONE -l ${BASEDIR}/../lua/fzf-lua/spawn.lua "return
       _devicons_path = [[${ICONS_PATH}]],
       _devicons_setup = [[${ICONS_SETUP}]],
     },
-    _base64 = false,
     debug = [[$debug]] == [[v]] and [[v]] or $debug,
     file_icons = [[${file_icons}]] == true or [[${file_icons}]],
     git_icons = ${git_icons},
     color_icons = ${color_icons},
     cmd = [[${cmd:-fd --color=never}]],
     cwd = vim.fn.expand([[${cwd:-$BASEDIR}]]),
-  },
-  -- fn_transform
-  [==[
-    return require(\"fzf-lua.make_entry\").file
-  ]==],
-  -- fn_preprocess
-  [==[
-    return require(\"fzf-lua.make_entry\").preprocess
-  ]==]
+    fn_transform = [==[
+      return require(\"fzf-lua.make_entry\").file
+    ]==],
+    fn_preprocess = [==[
+      return require(\"fzf-lua.make_entry\").preprocess
+    ]==]
+  }
 "