chore(windows): adjust for fzf changes (>=v0.51)

Author: ibhagwan

lua/fzf-lua/config.lua

@@ -466,9 +466,11 @@ function M.normalize_opts(opts, globals, __resume_key)
   opts._is_skim = opts.fzf_bin:find("sk") ~= nil
 
   -- enforce fzf minimum requirements
+  vim.g.fzf_lua_fzf_version = nil
   if not opts._is_skim then
     local FZF_VERSION, rc, err = utils.fzf_version(opts)
     opts.__FZF_VERSION = FZF_VERSION
+    vim.g.fzf_lua_fzf_version = FZF_VERSION
     if not opts.__FZF_VERSION then
       utils.err(string.format(
         "'fzf --version' failed with error %s: %s", rc, err))

lua/fzf-lua/core.lua

@@ -699,6 +699,7 @@ M.mt_cmd_wrapper = function(opts)
       "file_ignore_patterns",
       "rg_glob",
       "_base64",
+      utils.__IS_WINDOWS and "__FZF_VERSION" or nil,
     }
     -- caller requested rg with glob support
     if o.rg_glob then
@@ -1134,8 +1135,10 @@ M.setup_fzf_interactive_flags = function(command, fzf_field_expression, opts)
     -- use `true` as $FZF_DEFAULT_COMMAND instead (#510)
     opts.__fzf_init_cmd = utils.shell_nop()
     if opts.exec_empty_query or (opts.query and #opts.query > 0) then
+      local q = not utils.__IS_WINDOWS and opts.query
+          or libuv.escape_fzf(opts.query, opts.__FZF_VERSION)
       -- gsub doesn't like single % on rhs
-      local escaped_q = libuv.shellescape(libuv.escape_fzf(opts.query)):gsub("%%", "%%%%")
+      local escaped_q = libuv.shellescape(q):gsub("%%", "%%%%")
       opts.__fzf_init_cmd = initial_command:gsub(fzf_field_expression, escaped_q)
     end
     if opts.__FZF_VERSION >= 0.25 then

lua/fzf-lua/libuv.lua

@@ -669,10 +669,12 @@ end
 
 -- Windows fzf oddities, fzf's {q} will send escaped blackslahes,
 -- but only when the backslash prefixes another character which
--- isn't a backslash
-M.unescape_fzf = function(s, is_win)
+-- isn't a backslash, test with:
+-- fzf --disabled --height 30% --preview-window up --preview "echo {q}"
+M.unescape_fzf = function(s, fzf_version, is_win)
   if is_win == nil then is_win = _is_win end
   if not is_win then return s end
+  if tonumber(fzf_version) and tonumber(fzf_version) >= 0.52 then return s end
   local ret = s:gsub("\\+[^\\]", function(x)
     local bslash_num = #x:match([[\+]])
     return string.rep([[\]],
@@ -686,9 +688,10 @@ end
 -- doing weird extra escaping with {q},  we use this to simulate
 -- {q} being sent via the reload action as the initial command
 -- TODO: better solution for these stupid hacks (upstream issues?)
-M.escape_fzf = function(s, is_win)
+M.escape_fzf = function(s, fzf_version, is_win)
   if is_win == nil then is_win = _is_win end
   if not is_win then return s end
+  if tonumber(fzf_version) and tonumber(fzf_version) >= 0.52 then return s end
   local ret = s:gsub("\\+[^\\]", function(x)
     local bslash_num = #x:match([[\+]])
     return string.rep([[\]], bslash_num * 2) .. x:sub(-1)

lua/fzf-lua/make_entry.lua

@@ -76,8 +76,8 @@ M.get_diff_files = function(opts)
   local ok, status, err = pcall(utils.io_systemlist, path.git_cwd(cmd, opts))
   local seconds = os.time() - start
   if seconds >= 3 and opts.silent ~= true then
-    local exec_str = string.format([[require"fzf-lua".utils.warn(]]
-      .. [["`git status` took %d seconds, consider using `:FzfLua files git_icons=false` in this repository.")]]
+    local exec_str = string.format([[require"fzf-lua".utils.warn(]] ..
+      [["`git status` took %d seconds, consider using `:FzfLua files git_icons=false` in this repository.")]]
       , seconds)
     if not vim.g.fzf_lua_is_headless then
       loadstring(exec_str)()
@@ -173,7 +173,7 @@ M.preprocess = function(opts)
       io.stdout:write(("[DEBUGV]: raw_argv(%d) = %s\n"):format(idx, arg))
     end
     if utils.__IS_WINDOWS then
-      arg = libuv.unescape_fzf(arg)
+      arg = libuv.unescape_fzf(arg, opts.__FZF_VERSION)
     end
     if debug == "v" or debug == "verbose" then
       io.stdout:write(("[DEBUGV]: esc_argv(%d) = %s\n"):format(idx, libuv.shellescape(arg)))

lua/fzf-lua/shell.lua

@@ -55,8 +55,10 @@ function M.raw_async_action(fn, fzf_field_expression, debug)
     local pipe = uv.new_pipe(false)
     local args = { ... }
     -- unescape double backslashes on windows
-    if type(args[1]) == "table" then
-      args[1] = vim.tbl_map(function(x) return libuv.unescape_fzf(x) end, args[1])
+    if utils.__IS_WINDOWS and type(args[1]) == "table" then
+      args[1] = vim.tbl_map(function(x)
+        return libuv.unescape_fzf(x, vim.g.fzf_lua_fzf_version)
+      end, args[1])
     end
     -- save selected item in main module's __INFO
     -- use loadstring to avoid circular require

tests/libuv_spec.lua

@@ -90,29 +90,55 @@ describe("Testing libuv module", function()
     assert.are.same(libuv.shellescape([[foo\\\^^^"]], 2), [[^"foo\\\^^^^^^\^"^"]])
   end)
 
-  it("escape {q} (win)", function()
-    assert.are.same(libuv.escape_fzf([[]], true), [[]])
-    assert.are.same(libuv.escape_fzf([[\]], true), [[\]])
-    assert.are.same(libuv.escape_fzf([[\\]], true), [[\\]])
-    assert.are.same(libuv.escape_fzf([[foo]], true), [[foo]])
-    assert.are.same(libuv.escape_fzf([[\foo]], true), [[\\foo]])
-    assert.are.same(libuv.escape_fzf([[\\foo]], true), [[\\\\foo]])
-    assert.are.same(libuv.escape_fzf([[\\\foo]], true), [[\\\\\\foo]])
-    assert.are.same(libuv.escape_fzf([[\\\\foo]], true), [[\\\\\\\\foo]])
-    assert.are.same(libuv.escape_fzf([[foo\]], true), [[foo\]])
-    assert.are.same(libuv.escape_fzf([[foo\\]], true), [[foo\\]])
+  it("escape {q} (win, fzf v0.50)", function()
+    assert.are.same(libuv.escape_fzf([[]], 0.50, true), [[]])
+    assert.are.same(libuv.escape_fzf([[\]], 0.50, true), [[\]])
+    assert.are.same(libuv.escape_fzf([[\\]], 0.50, true), [[\\]])
+    assert.are.same(libuv.escape_fzf([[foo]], 0.50, true), [[foo]])
+    assert.are.same(libuv.escape_fzf([[\foo]], 0.50, true), [[\\foo]])
+    assert.are.same(libuv.escape_fzf([[\\foo]], 0.50, true), [[\\\\foo]])
+    assert.are.same(libuv.escape_fzf([[\\\foo]], 0.50, true), [[\\\\\\foo]])
+    assert.are.same(libuv.escape_fzf([[\\\\foo]], 0.50, true), [[\\\\\\\\foo]])
+    assert.are.same(libuv.escape_fzf([[foo\]], 0.50, true), [[foo\]])
+    assert.are.same(libuv.escape_fzf([[foo\\]], 0.50, true), [[foo\\]])
   end)
 
-  it("unescape {q} (win)", function()
-    assert.are.same(libuv.unescape_fzf([[]], true), [[]])
-    assert.are.same(libuv.unescape_fzf([[\]], true), [[\]])
-    assert.are.same(libuv.unescape_fzf([[\\]], true), [[\\]])
-    assert.are.same(libuv.unescape_fzf([[foo]], true), [[foo]])
-    assert.are.same(libuv.unescape_fzf([[\foo]], true), [[\foo]])
-    assert.are.same(libuv.unescape_fzf([[\\foo]], true), [[\foo]])
-    assert.are.same(libuv.unescape_fzf([[\\\foo]], true), [[\foo]])
-    assert.are.same(libuv.unescape_fzf([[\\\\foo]], true), [[\\foo]])
-    assert.are.same(libuv.unescape_fzf([[foo\]], true), [[foo\]])
-    assert.are.same(libuv.unescape_fzf([[foo\\]], true), [[foo\\]])
+  it("unescape {q} (win, fzf v0.50)", function()
+    assert.are.same(libuv.unescape_fzf([[]], 0.50, true), [[]])
+    assert.are.same(libuv.unescape_fzf([[\]], 0.50, true), [[\]])
+    assert.are.same(libuv.unescape_fzf([[\\]], 0.50, true), [[\\]])
+    assert.are.same(libuv.unescape_fzf([[foo]], 0.50, true), [[foo]])
+    assert.are.same(libuv.unescape_fzf([[\foo]], 0.50, true), [[\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\foo]], 0.50, true), [[\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\\foo]], 0.50, true), [[\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\\\foo]], 0.50, true), [[\\foo]])
+    assert.are.same(libuv.unescape_fzf([[foo\]], 0.50, true), [[foo\]])
+    assert.are.same(libuv.unescape_fzf([[foo\\]], 0.50, true), [[foo\\]])
+  end)
+
+  it("escape {q} (win, fzf v0.52)", function()
+    assert.are.same(libuv.escape_fzf([[]], 0.52, true), [[]])
+    assert.are.same(libuv.escape_fzf([[\]], 0.52, true), [[\]])
+    assert.are.same(libuv.escape_fzf([[\\]], 0.52, true), [[\\]])
+    assert.are.same(libuv.escape_fzf([[foo]], 0.52, true), [[foo]])
+    assert.are.same(libuv.escape_fzf([[\foo]], 0.52, true), [[\foo]])
+    assert.are.same(libuv.escape_fzf([[\\foo]], 0.52, true), [[\\foo]])
+    assert.are.same(libuv.escape_fzf([[\\\foo]], 0.52, true), [[\\\foo]])
+    assert.are.same(libuv.escape_fzf([[\\\\foo]], 0.52, true), [[\\\\foo]])
+    assert.are.same(libuv.escape_fzf([[foo\]], 0.52, true), [[foo\]])
+    assert.are.same(libuv.escape_fzf([[foo\\]], 0.52, true), [[foo\\]])
+  end)
+
+  it("unescape {q} (win, fzf v0.52)", function()
+    assert.are.same(libuv.unescape_fzf([[]], 0.52, true), [[]])
+    assert.are.same(libuv.unescape_fzf([[\]], 0.52, true), [[\]])
+    assert.are.same(libuv.unescape_fzf([[\\]], 0.52, true), [[\\]])
+    assert.are.same(libuv.unescape_fzf([[foo]], 0.52, true), [[foo]])
+    assert.are.same(libuv.unescape_fzf([[\foo]], 0.52, true), [[\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\foo]], 0.52, true), [[\\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\\foo]], 0.52, true), [[\\\foo]])
+    assert.are.same(libuv.unescape_fzf([[\\\\foo]], 0.52, true), [[\\\\foo]])
+    assert.are.same(libuv.unescape_fzf([[foo\]], 0.52, true), [[foo\]])
+    assert.are.same(libuv.unescape_fzf([[foo\\]], 0.52, true), [[foo\\]])
   end)
 end)