feat: async rename and create file

Author: yioneko

doc/nvim-tree-lua.txt

@@ -394,6 +394,12 @@ Subsequent calls to setup will replace the previous configuration.
           watcher = false,
         },
       },
+      experimental = {
+        async = {
+          create_file = false,
+          rename_file = false,
+        }
+      }
     } -- END_DEFAULT_OPTS
 <
 
@@ -1134,6 +1140,20 @@ Configuration for diagnostic logging.
         |nvim-tree.filesystem_watchers| processing, verbose.
           Type: `boolean`, Default: `false`
 
+*nvim-tree.experimental*
+Configuration for experimental features.
+
+    *nvim-tree.experimental.async*
+    Control experimental async behavior.
+
+        *nvim-tree.experimental.async.create_file*
+        Toggle async behavior of create file operation.
+          Type: `boolean`, Default: `false`
+
+        *nvim-tree.experimental.async.rename_file*
+        Toggle async behavior of rename file operation.
+          Type: `boolean`, Default: `false`
+
 ==============================================================================
  4.1 VINEGAR STYLE                                         *nvim-tree-vinegar*
 

lua/nvim-tree.lua

@@ -702,6 +702,12 @@ local DEFAULT_OPTS = { -- BEGIN_DEFAULT_OPTS
       watcher = false,
     },
   },
+  experimental = {
+    async = {
+      create_file = false,
+      rename_file = false,
+    },
+  },
 } -- END_DEFAULT_OPTS
 
 local function merge_options(conf)

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

@@ -5,32 +5,28 @@ 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 = {}
 
+---@async
 local function create_and_notify(file)
-  local ok, fd = pcall(vim.loop.fs_open, file, "w", 420)
-  if not ok then
+  local fd, err
+  if M.enable_async then
+    err, fd = async.call(vim.loop.fs_open, file, "w", 420)
+  else
+    fd, err = vim.loop.fs_open(file, "w", 420)
+  end
+  if err then
     notify.error("Couldn't create file " .. file)
     return
   end
-  vim.loop.fs_close(fd)
-  events._dispatch_file_created(file)
-end
-
-local function create_file(file)
-  if utils.file_exists(file) then
-    local prompt_select = "Overwrite " .. file .. " ?"
-    local prompt_input = prompt_select .. " y/n: "
-    lib.prompt(prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" }, function(item_short)
-      utils.clear_prompt()
-      if item_short == "y" then
-        create_and_notify(file)
-      end
-    end)
+  if M.enable_async then
+    async.call(vim.loop.fs_close, fd)
   else
-    create_and_notify(file)
+    vim.loop.fs_close(fd)
   end
+  events._dispatch_file_created(file)
 end
 
 local function get_num_nodes(iter)
@@ -41,6 +37,67 @@ local function get_num_nodes(iter)
   return i
 end
 
+local function create_file(new_file_path)
+  -- 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 utils.is_windows 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
+      if M.enable_async then
+        async.schedule()
+      end
+      if utils.file_exists(new_file_path) then
+        local prompt_select = "Overwrite " .. new_file_path .. " ?"
+        local prompt_input = prompt_select .. " y/n: "
+        if M.enable_async then
+          local item_short = async.call(lib.prompt, prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" })
+          utils.clear_prompt()
+          if item_short == "y" then
+            create_and_notify(new_file_path)
+          end
+        else
+          lib.prompt(prompt_input, prompt_select, { "y", "n" }, { "Yes", "No" }, function(item_short)
+            utils.clear_prompt()
+            if item_short == "y" then
+              create_and_notify(new_file_path)
+            end
+          end)
+        end
+      else
+        create_and_notify(new_file_path)
+      end
+    elseif not utils.file_exists(path_to_create) then
+      local err
+      if M.enable_async then
+        err = async.call(vim.loop.fs_mkdir, path_to_create, 493)
+      else
+        _, err = vim.loop.fs_mkdir(path_to_create, 493)
+      end
+      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
+end
+
 local function get_containing_folder(node)
   if node.nodes ~= nil then
     return utils.path_add_trailing(node.absolute_path)
@@ -49,7 +106,8 @@ local function get_containing_folder(node)
   return node.absolute_path:sub(0, -node_name_size - 1)
 end
 
-function M.fn(node)
+--TODO: once async feature is finalized, use `async.wrap` instead of cb param
+function M.fn(node, cb)
   node = node and lib.get_last_group_node(node)
   if not node or node.name == ".." then
     node = {
@@ -74,45 +132,24 @@ function M.fn(node)
       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
+    if M.enable_async then
+      async.exec(create_file, new_file_path, function(err)
+        find_file(utils.path_remove_trailing(new_file_path))
+        if cb then
+          cb(err)
         end
-        events._dispatch_folder_created(new_file_path)
-      end
-    end
-    if not is_error then
-      notify.info(new_file_path .. " was properly created")
+      end)
+    else
+      create_file(new_file_path)
+      -- synchronously refreshes as we can't wait for the watchers
+      find_file(utils.path_remove_trailing(new_file_path))
     end
-
-    -- synchronously refreshes as we can't wait for the watchers
-    find_file(utils.path_remove_trailing(new_file_path))
   end)
 end
 
 function M.setup(opts)
   M.enable_reload = not opts.filesystem_watchers.enable
+  M.enable_async = opts.experimental.async.create_file
 end
 
 return M

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

@@ -2,6 +2,7 @@ local lib = require "nvim-tree.lib"
 local utils = require "nvim-tree.utils"
 local events = require "nvim-tree.events"
 local notify = require "nvim-tree.notify"
+local async = require "nvim-tree.async"
 
 local M = {}
 
@@ -15,26 +16,34 @@ local function err_fmt(from, to, reason)
   return string.format("Cannot rename %s -> %s: %s", from, to, reason)
 end
 
-function M.rename(node, to)
+---@async
+function M.rename(node, to, use_async)
   if utils.file_exists(to) then
-    notify.warn(err_fmt(node.absolute_path, to, "file already exists"))
-    return
+    return notify.warn(err_fmt(node.absolute_path, to, "file already exists"))
   end
 
   events._dispatch_will_rename_node(node.absolute_path, to)
-  local success, err = vim.loop.fs_rename(node.absolute_path, to)
+  local success, err
+  if use_async then
+    err, success = async.call(vim.loop.fs_rename, node.absolute_path, to)
+  else
+    success, err = vim.loop.fs_rename(node.absolute_path, to)
+  end
   if not success then
     return notify.warn(err_fmt(node.absolute_path, to, err))
   end
   notify.info(node.absolute_path .. " ➜ " .. to)
+  if use_async then
+    async.schedule()
+  end
   utils.rename_loaded_buffers(node.absolute_path, to)
   events._dispatch_node_renamed(node.absolute_path, to)
 end
 
 function M.fn(default_modifier)
   default_modifier = default_modifier or ":t"
 
-  return function(node, modifier)
+  return function(node, modifier, cb)
     if type(node) ~= "table" then
       node = lib.get_node_at_cursor()
     end
@@ -76,17 +85,31 @@ function M.fn(default_modifier)
       if not new_file_path then
         return
       end
-
-      M.rename(node, prepend .. new_file_path .. append)
-      if M.enable_reload then
-        require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+      if M.enable_async then
+        async.exec(M.rename, node, prepend .. new_file_path .. append, true, function(err)
+          if err then
+            notify.error(err)
+          end
+          if M.enable_reload then
+            require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+          end
+          if cb then
+            cb(err)
+          end
+        end)
+      else
+        M.rename(node, prepend .. new_file_path .. append, false)
+        if M.enable_reload then
+          require("nvim-tree.actions.reloaders.reloaders").reload_explorer()
+        end
       end
     end)
   end
 end
 
 function M.setup(opts)
   M.enable_reload = not opts.filesystem_watchers.enable
+  M.enable_async = opts.experimental.async.rename_file
 end
 
 return M

lua/nvim-tree/api.lua

@@ -6,6 +6,7 @@ local Api = {
   fs = { copy = {} },
   git = {},
   live_filter = {},
+  async = {},
 }
 
 local function inject_node(f)
@@ -113,6 +114,7 @@ Api.node.navigate.diagnostics.prev = inject_node(require("nvim-tree.actions.move
 Api.git.reload = require("nvim-tree.actions.reloaders.reloaders").reload_git
 
 Api.events.subscribe = require("nvim-tree.events").subscribe
+Api.events.subscribe_async = require("nvim-tree.events").subscribe_async
 Api.events.Event = require("nvim-tree.events").Event
 
 Api.live_filter.start = require("nvim-tree.live-filter").start_filtering
@@ -127,4 +129,12 @@ Api.marks.navigate.next = require("nvim-tree.marks.navigation").next
 Api.marks.navigate.prev = require("nvim-tree.marks.navigation").prev
 Api.marks.navigate.select = require("nvim-tree.marks.navigation").select
 
+Api.async.call = function(...)
+  if not require("nvim-tree.async").in_async() then
+    error "The async call is not triggered in an async context of nvim-tree, please use `api.in_async` to detect beforehand"
+  end
+  require("nvim-tree.async").call(...)
+end
+Api.async.in_async = require("nvim-tree.async").in_async
+
 return Api