Rewrite recursive expand to use plenary.async

Author: ghostbuster91

lua/neo-tree/git/ignored.lua

@@ -113,8 +113,7 @@ M.mark_ignored = function(state, items, callback)
         enabled_recording = true,
         writer = folder_items,
         on_start = function()
-          log.debug("IGNORED: Running async git with args: ", args)
-          log.debug("IGNORED: folder items: ", folder_items)
+          log.trace("IGNORED: Running async git with args: ", args)
         end,
         on_exit = function(self, code, _)
           local result
@@ -128,7 +127,6 @@ M.mark_ignored = function(state, items, callback)
           progress = progress + 1
           if progress == #jobs then
             finalize(all_results)
-            log.debug("calling master callback all git_ignored finished")
             callback(all_results)
           end
         end,

lua/neo-tree/sources/common/commands.lua

@@ -11,6 +11,7 @@ local popups = require("neo-tree.ui.popups")
 local log = require("neo-tree.log")
 local help = require("neo-tree.sources.common.help")
 local Preview = require("neo-tree.sources.common.preview")
+local async = require("plenary.async")
 
 ---Gets the node parent folder
 ---@param state table to look for nodes
@@ -109,27 +110,18 @@ M.add_directory = function(state, callback)
   fs_actions.create_directory(in_directory, callback, using_root_directory)
 end
 
-M.expand_all_nodes = function(state)
-  local async = require("plenary.async")
-
-  local expand_node = function(node, _callback)
-    log.debug("load directory ".. node:get_id())
-    fs.load_directory_async(state,node,_callback)
-  end
-
-  local tasks = {}
-  for _, node in ipairs(state.tree:get_nodes()) do
-    local task = async.wrap(function (callback)
-        log.debug("async expand node" .. node.name)
-        expand_node(node, callback)
-    end, 1)
-    table.insert(tasks, task)
-  end
-    log.debug("run all on top " .. #tasks)
-    async.util.run_all(
-      tasks,
+---Expand all nodes
+---@param state table The state of the source
+---@param node table A node to expand
+M.expand_all_nodes = function(state, node)
+  log.debug("Expanding all nodes under " .. node:get_id())
+  local task = function ()
+    fs.expand_directory(state, node)
+  end
+  async.run(
+      task,
       function ()
-        log.debug("run all on top - finish")
+        log.debug("All nodes expanded - redrawing")
         vim.schedule_wrap(function()
           renderer.redraw(state)
         end)

lua/neo-tree/sources/filesystem/commands.lua

@@ -68,7 +68,7 @@ M.delete_visual = function(state, selected_nodes)
 end
 
 M.expand_all_nodes = function(state)
-  cc.expand_all_nodes(state)
+  cc.expand_all_nodes(state, state.tree:get_node(state.path))
 end
 
 ---Shows the filter input, which will filter the tree.

lua/neo-tree/sources/filesystem/init.lua

@@ -10,6 +10,7 @@ local log = require("neo-tree.log")
 local manager = require("neo-tree.sources.manager")
 local git = require("neo-tree.git")
 local glob = require("neo-tree.sources.filesystem.lib.globtopattern")
+local async = require("plenary.async")
 
 local M = {
   name = "filesystem",
@@ -406,7 +407,7 @@ M.toggle_directory = function(state, node, path_to_reveal, skip_redraw, recursiv
     local id = node:get_id()
     state.explicitly_opened_directories[id] = true
     renderer.position.set(state, nil)
-    fs_scan.get_items(state, id, path_to_reveal, callback, true, recursive)
+    fs_scan.get_items(state, id, path_to_reveal, callback, false, recursive)
   elseif node:has_children() then
     local updated = false
     if node:is_expanded() then
@@ -428,69 +429,76 @@ M.toggle_directory = function(state, node, path_to_reveal, skip_redraw, recursiv
   end
 end
 
-local function expand_loaded_rec(node, state, to_load)
-    if node.loaded==false then
-        table.insert(to_load, node)
-    else
-        if not node:is_expanded() then
-          node:expand()
-          state.explicitly_opened_directories[node:get_id()] = true
+--- Recursively expand all loaded nodes under the given node
+--- returns table with all discovered nodes that need to be loaded 
+---@param node table a node to expand
+---@param state table current state of the source
+---@return table discovered nodes that need to be loaded
+local function expand_loaded(node, state)
+    local function rec(_node, to_load)
+      if _node.loaded == false then
+        table.insert(to_load, _node)
+      else
+        if not _node:is_expanded() then
+          _node:expand()
+          state.explicitly_opened_directories[_node:get_id()] = true
         end
-        local children = state.tree:get_nodes(node:get_id())
-        log.debug("children of " .. node.name .. " - "  .. #children)
-        if children then
-          log.debug("children of " .. node.name .. " - "  .. #children)
-          for _, child in ipairs(children) do
-            if child.type == "directory" then
-               expand_loaded_rec(child, state, to_load)
-            else
-              log.debug("skipping child " .. vim.inspect(child.name))
-            end
+        local children = state.tree:get_nodes(_node:get_id())
+        log.debug("Expanding childrens of " .. _node:get_id())
+        for _, child in ipairs(children) do
+          if child.type == "directory" then
+             rec(child, to_load)
+          else
+            log.trace("Child: " .. child.name .. " is not a directory, skipping")
           end
-        else
-          log.debug("no kids")
         end
+      end
     end
+
+    local to_load = {}
+    rec(node, to_load)
+    return to_load
 end
 
-local function call_rec(node, state, to_load, progress, root_callback)
-    log.debug("call_rec ".. vim.inspect(node) .. "toload: " .. vim.inspect(to_load) .. " progress:" .. progress)
-    expand_loaded_rec(node, state, to_load)
-    progress=progress+1
-    if progress <= #to_load then
-        M.load_directory_async(state, to_load[progress], function ()
-            call_rec(to_load[progress], state, to_load, progress, root_callback)
-        end)
-    else
-        root_callback()
+--- Recursively expands all nodes under the given node
+--- loading nodes if necessary.
+--- asyn method
+---@param node table a node to expand
+---@param state table current state of the source
+local function expand_and_load(node, state)
+    local function rec(to_load, progress)
+      local to_load_current = expand_loaded(node, state)
+      for _,v in ipairs(to_load_current) do
+        table.insert(to_load, v)
+      end
+      if progress <= #to_load then
+        M.expand_directory(state, to_load[progress])
+        rec(to_load, progress + 1)
+      end
     end
+    rec({}, 1)
 end
 
----Expands or collapses the current node.
-M.load_directory_async = function(state, node, callback)
-  log.debug("load_directory_async " .. vim.inspect(node))
-  local async = require("plenary.async")
+---Expands given node recursively loading all descendant nodes if needed
+---async method
+---@param state table current state of the source
+---@param node table a node to expand
+M.expand_directory = function(state, node)
+  log.debug("Expanding directory " .. node:get_id())
   if node.type ~= "directory" then
-    callback()
+    return
   end
   state.explicitly_opened_directories = state.explicitly_opened_directories or {}
   if node.loaded == false then
     local id = node:get_id()
     state.explicitly_opened_directories[id] = true
     renderer.position.set(state, nil)
-    async.run(function ()
-        fs_scan.get_items_2(state, id, true)
-    end, function ()
-        expand_loaded_rec(node ,state, {})
-        callback()
-    end)
+    fs_scan.get_dir_items_async(state, id, true)
+    -- ignore results as we know here that all descendant nodes have been already loaded
+    expand_loaded(node ,state)
   else
-    local to_load = {}
-    local progress = 1
-    call_rec(node, state, to_load, progress, callback)
+    expand_and_load(node, state)
   end
 end
 
-
-
 return M