feat: make fs actions async

Author: yioneko

lua/nvim-tree/actions/finders/find-file.lua

@@ -1,4 +1,5 @@
 local log = require "nvim-tree.log"
+local async = require "nvim-tree.async"
 local view = require "nvim-tree.view"
 local utils = require "nvim-tree.utils"
 local renderer = require "nvim-tree.renderer"
@@ -37,41 +38,43 @@ function M.fn(fname)
 
   local absolute_paths_searched = {}
 
-  local found = Iterator.builder(core.get_explorer().nodes)
-    :matcher(function(node)
-      return node.absolute_path == fname_real or node.link_to == fname_real
-    end)
-    :applier(function(node)
-      line = line + 1
+  async.exec(function()
+    local found = Iterator.builder(core.get_explorer().nodes)
+      :matcher(function(node)
+        return node.absolute_path == fname_real or node.link_to == fname_real
+      end)
+      :applier(function(node)
+        line = line + 1
 
-      if vim.tbl_contains(absolute_paths_searched, node.absolute_path) then
-        return
-      end
-      table.insert(absolute_paths_searched, node.absolute_path)
-
-      local abs_match = vim.startswith(fname_real, node.absolute_path .. utils.path_separator)
-      local link_match = node.link_to and vim.startswith(fname_real, node.link_to .. utils.path_separator)
-
-      if abs_match or link_match then
-        node.open = true
-        if #node.nodes == 0 then
-          core.get_explorer():expand(node)
+        if vim.tbl_contains(absolute_paths_searched, node.absolute_path) then
+          return
         end
-      end
-    end)
-    :recursor(function(node)
-      return node.open and node.nodes
-    end)
-    :iterate()
+        table.insert(absolute_paths_searched, node.absolute_path)
 
-  if found and view.is_visible() then
-    renderer.draw()
-    view.set_cursor { line, 0 }
-  end
+        local abs_match = vim.startswith(fname_real, node.absolute_path .. utils.path_separator)
+        local link_match = node.link_to and vim.startswith(fname_real, node.link_to .. utils.path_separator)
 
-  running[fname_real] = false
-
-  log.profile_end(ps, "find file %s", fname_real)
+        if abs_match or link_match then
+          node.open = true
+          if #node.nodes == 0 then
+            core.get_explorer():expand(node)
+          end
+        end
+      end)
+      :recursor(function(node)
+        return node.open and node.nodes
+      end)
+      :async_iterate()
+
+    async.schedule()
+    if found and view.is_visible() then
+      renderer.draw()
+      view.set_cursor { line, 0 }
+    end
+  end, function()
+    running[fname_real] = false
+    log.profile_end(ps, "find file %s", fname_real)
+  end)
 end
 
 return M

lua/nvim-tree/actions/fs/copy-paste.lua

@@ -4,6 +4,7 @@ local utils = require "nvim-tree.utils"
 local core = require "nvim-tree.core"
 local events = require "nvim-tree.events"
 local notify = require "nvim-tree.notify"
+local async = require "nvim-tree.async"
 
 local M = {}
 
@@ -12,9 +13,75 @@ local clipboard = {
   copy = {},
 }
 
+local function do_copy_dir(source, destination, mode)
+  errmsg, handle = async.call(function(cb)
+    return vim.loop.fs_opendir(source, cb, 32)
+  end)
+  if not handle then
+    log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, errmsg)
+    return false, errmsg
+  end
+
+  local _, stats = async.call(vim.loop.fs_stat, destination)
+  if stats then
+    errMsg = async.call(vim.loop.fs_chmod, destination, mode)
+    if errMsg then
+      log.line("copy_paste", "do_copy fs_chmod '%s' failed '%s'", destination, errmsg)
+      -- ignore error and continue, the dir exists
+    end
+  else
+    errmsg, success = async.call(vim.loop.fs_mkdir, destination, mode)
+    if not success then
+      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, errmsg)
+      return false, errmsg
+    end
+  end
+
+  while true do
+    local _, entries = async.call(vim.loop.fs_readdir, handle)
+    if not entries or #entries == 0 then
+      break
+    end
+    local cp_tasks = {}
+    for _, entry in pairs(entries) do
+      local name = entry.name
+      local type = entry.type
+      local new_name = utils.path_join { source, name }
+      local new_destination = utils.path_join { destination, name }
+
+      errMsg, stats = async.call(vim.loop.fs_stat, new_name)
+      if errMsg then
+        log.line("copy_paste", "do_copy fs_stat '%s' failed '%s'", new_name, errmsg)
+      else
+        if type == "directory" then
+          success, errmsg = do_copy_dir(new_name, new_destination, stats.mode)
+          if not success then
+            return false, errmsg
+          end
+        else
+          table.insert(cp_tasks, function()
+            errmsg, success = async.call(vim.loop.fs_copyfile, new_name, new_destination, nil)
+            if not success then
+              log.line("copy_paste", "do_copy fs_copyfile failed '%s'", errmsg)
+              return false, errmsg
+            end
+            return true
+          end)
+        end
+      end
+    end
+    for _, result in ipairs(async.all(unpack(cp_tasks))) do
+      success = unpack(result)
+      if not success then
+        return false
+      end
+    end
+  end
+  return true
+end
+
 local function do_copy(source, destination)
-  local source_stats, handle
-  local success, errmsg
+  local source_stats, success, errmsg
 
   source_stats, errmsg = vim.loop.fs_stat(source)
   if not source_stats then
@@ -30,40 +97,16 @@ local function do_copy(source, destination)
   end
 
   if source_stats.type == "file" then
-    success, errmsg = vim.loop.fs_copyfile(source, destination)
+    errmsg, success = async.call(vim.loop.fs_copyfile, source, destination)
     if not success then
       log.line("copy_paste", "do_copy fs_copyfile failed '%s'", errmsg)
       return false, errmsg
     end
-    return true
   elseif source_stats.type == "directory" then
-    handle, errmsg = vim.loop.fs_scandir(source)
-    if type(handle) == "string" then
-      return false, handle
-    elseif not handle then
-      log.line("copy_paste", "do_copy fs_scandir '%s' failed '%s'", source, errmsg)
-      return false, errmsg
-    end
-
-    success, errmsg = vim.loop.fs_mkdir(destination, source_stats.mode)
+    success, errmsg = do_copy_dir(source, destination, source_stats.mode)
     if not success then
-      log.line("copy_paste", "do_copy fs_mkdir '%s' failed '%s'", destination, errmsg)
       return false, errmsg
     end
-
-    while true do
-      local name, _ = vim.loop.fs_scandir_next(handle)
-      if not name then
-        break
-      end
-
-      local new_name = utils.path_join { source, name }
-      local new_destination = utils.path_join { destination, name }
-      success, errmsg = do_copy(new_name, new_destination)
-      if not success then
-        return false, errmsg
-      end
-    end
   else
     errmsg = string.format("'%s' illegal file type '%s'", source, source_stats.type)
     log.line("copy_paste", "do_copy %s", errmsg)
@@ -96,19 +139,17 @@ local function do_single_paste(source, dest, action_type, action_fn)
   if dest_stats then
     local prompt_select = "Overwrite " .. dest .. " ?"
     local prompt_input = prompt_select .. " y/n/r(ename): "
-    lib.prompt(prompt_input, prompt_select, { "y", "n", "r" }, { "Yes", "No", "Rename" }, function(item_short)
+    local item_short = async.call(lib.prompt, prompt_input, prompt_select, { "y", "n", "r" }, { "Yes", "No", "Rename" })
+    utils.clear_prompt()
+    if item_short == "y" then
+      on_process()
+    elseif item_short == "r" then
+      local new_dest = async.call(vim.ui.input, { prompt = "Rename to ", default = dest, completion = "dir" })
       utils.clear_prompt()
-      if item_short == "y" then
-        on_process()
-      elseif item_short == "r" then
-        vim.ui.input({ prompt = "Rename to ", default = dest, completion = "dir" }, function(new_dest)
-          utils.clear_prompt()
-          if new_dest then
-            do_single_paste(source, new_dest, action_type, action_fn)
-          end
-        end)
+      if new_dest then
+        do_single_paste(source, new_dest, action_type, action_fn)
       end
-    end)
+    end
   else
     on_process()
   end
@@ -184,24 +225,24 @@ local function do_cut(source, destination)
     return true
   end
 
-  events._dispatch_will_rename_node(source, destination)
-  local success, errmsg = vim.loop.fs_rename(source, destination)
+  local errmsg, success = async.call(vim.loop.fs_rename, source, destination)
   if not success then
     log.line("copy_paste", "do_cut fs_rename failed '%s'", errmsg)
     return false, errmsg
   end
+  async.schedule()
   utils.rename_loaded_buffers(source, destination)
   events._dispatch_node_renamed(source, destination)
   return true
 end
 
-function M.paste(node)
+M.paste = async.wrap(function(node)
   if clipboard.move[1] ~= nil then
     return do_paste(node, "move", do_cut)
   end
 
   return do_paste(node, "copy", do_copy)
-end
+end)
 
 function M.print_clipboard()
   local content = {}

lua/nvim-tree/actions/fs/create-file.lua

@@ -5,16 +5,17 @@ local core = require "nvim-tree.core"
 local notify = require "nvim-tree.notify"
 
 local find_file = require("nvim-tree.actions.finders.find-file").fn
+local async = require "nvim-tree.async"
 
 local M = {}
 
 local function create_and_notify(file)
-  local ok, fd = pcall(vim.loop.fs_open, file, "w", 420)
-  if not ok then
+  local err, fd = async.call(vim.loop.fs_open, file, "w", 420)
+  if err then
     notify.error("Couldn't create file " .. file)
     return
   end
-  vim.loop.fs_close(fd)
+  async.call(vim.loop.fs_close, fd)
   events._dispatch_file_created(file)
 end
 
@@ -49,7 +50,7 @@ local function get_containing_folder(node)
   return node.absolute_path:sub(0, -node_name_size - 1)
 end
 
-function M.fn(node)
+M.fn = async.wrap(function(node)
   node = node and lib.get_last_group_node(node)
   if not node or node.name == ".." then
     node = {
@@ -63,53 +64,53 @@ function M.fn(node)
 
   local input_opts = { prompt = "Create file ", default = containing_folder, completion = "file" }
 
-  vim.ui.input(input_opts, function(new_file_path)
-    utils.clear_prompt()
-    if not new_file_path or new_file_path == containing_folder then
-      return
-    end
+  local new_file_path = async.call(vim.ui.input, input_opts)
+  utils.clear_prompt()
+  if not new_file_path or new_file_path == containing_folder then
+    return
+  end
 
-    if utils.file_exists(new_file_path) then
-      notify.warn "Cannot create: file already exists"
-      return
-    end
+  if utils.file_exists(new_file_path) then
+    notify.warn "Cannot create: file already exists"
+    return
+  end
 
-    -- create a folder for each path element if the folder does not exist
-    -- if the answer ends with a /, create a file for the last path element
-    local is_last_path_file = not new_file_path:match(utils.path_separator .. "$")
-    local path_to_create = ""
-    local idx = 0
-
-    local num_nodes = get_num_nodes(utils.path_split(utils.path_remove_trailing(new_file_path)))
-    local is_error = false
-    for path in utils.path_split(new_file_path) do
-      idx = idx + 1
-      local p = utils.path_remove_trailing(path)
-      if #path_to_create == 0 and vim.fn.has "win32" == 1 then
-        path_to_create = utils.path_join { p, path_to_create }
-      else
-        path_to_create = utils.path_join { path_to_create, p }
-      end
-      if is_last_path_file and idx == num_nodes then
-        create_file(path_to_create)
-      elseif not utils.file_exists(path_to_create) then
-        local success = vim.loop.fs_mkdir(path_to_create, 493)
-        if not success then
-          notify.error("Could not create folder " .. path_to_create)
-          is_error = true
-          break
-        end
-        events._dispatch_folder_created(new_file_path)
-      end
+  -- create a folder for each path element if the folder does not exist
+  -- if the answer ends with a /, create a file for the last path element
+  local is_last_path_file = not new_file_path:match(utils.path_separator .. "$")
+  local path_to_create = ""
+  local idx = 0
+
+  local num_nodes = get_num_nodes(utils.path_split(utils.path_remove_trailing(new_file_path)))
+  local is_error = false
+  for path in utils.path_split(new_file_path) do
+    idx = idx + 1
+    local p = utils.path_remove_trailing(path)
+    async.schedule()
+    if #path_to_create == 0 and vim.fn.has "win32" == 1 then
+      path_to_create = utils.path_join { p, path_to_create }
+    else
+      path_to_create = utils.path_join { path_to_create, p }
     end
-    if not is_error then
-      notify.info(new_file_path .. " was properly created")
+    if is_last_path_file and idx == num_nodes then
+      create_file(path_to_create)
+    elseif not utils.file_exists(path_to_create) then
+      local err = async.call(vim.loop.fs_mkdir, path_to_create, 493)
+      if err then
+        notify.error("Could not create folder " .. path_to_create .. " :" .. err)
+        is_error = true
+        break
+      end
+      events._dispatch_folder_created(new_file_path)
     end
+  end
+  if not is_error then
+    notify.info(new_file_path .. " was properly created")
+  end
 
-    -- synchronously refreshes as we can't wait for the watchers
-    find_file(utils.path_remove_trailing(new_file_path))
-  end)
-end
+  -- synchronously refreshes as we can't wait for the watchers
+  find_file(utils.path_remove_trailing(new_file_path))
+end)
 
 function M.setup(opts)
   M.enable_reload = not opts.filesystem_watchers.enable