feat: Allow to expand until certain condition is met

lua/nvim-tree/actions/tree/modifiers/expand-all.lua

@@ -3,6 +3,7 @@ local renderer = require "nvim-tree.renderer"
 local Iterator = require "nvim-tree.iterators.node-iterator"
 local notify = require "nvim-tree.notify"
 local lib = require "nvim-tree.lib"
+local git = require "nvim-tree.git"
 
 local M = {}
 
@@ -18,42 +19,56 @@ local function to_lookup_table(list)
 end
 
 ---@param node Node
-local function expand(node)
-  node = lib.get_last_group_node(node)
-  node.open = true
+local function populate_node(node)
+  -- noop if it is a file
+  if node.nodes == nil then
+    return
+  end
   if #node.nodes == 0 then
-    core.get_explorer():expand(node)
+    local cwd = node.link_to or node.absolute_path
+    local handle = vim.loop.fs_scandir(cwd)
+    if not handle then
+      return
+    end
+    local status = git.load_project_status(cwd)
+    core.get_explorer():expand(node, status)
   end
 end
 
 ---@param expansion_count integer
 ---@param node Node
+---@param populate_node function
 ---@return boolean
-local function should_expand(expansion_count, node)
+-- luacheck: push ignore populate_node
+local function expand_until_max_or_empty(expansion_count, node, populate_node)
   local should_halt = expansion_count >= M.MAX_FOLDER_DISCOVERY
   local should_exclude = M.EXCLUDE[node.name]
-  return not should_halt and node.nodes and not node.open and not should_exclude
+  local result = not should_halt and node.nodes and not node.open and not should_exclude
+  return result
 end
+-- luacheck: pop
 
-local function gen_iterator()
+local function gen_iterator(should_expand_fn)
   local expansion_count = 0
 
   return function(parent)
-    if parent.parent and parent.nodes and not parent.open then
-      expansion_count = expansion_count + 1
-      expand(parent)
-    end
+    populate_node(parent)
+    parent.open = true
 
-    Iterator.builder(parent.nodes)
+    Iterator.builder({ parent })
       :hidden()
       :applier(function(node)
-        if should_expand(expansion_count, node) then
+        local should_expand = should_expand_fn(expansion_count, node, populate_node)
+        if should_expand then
           expansion_count = expansion_count + 1
-          expand(node)
+          populate_node(node)
+          node = lib.get_last_group_node(node)
+          node.open = true
         end
       end)
       :recursor(function(node)
-        return expansion_count < M.MAX_FOLDER_DISCOVERY and (node.group_next and { node.group_next } or (node.open and node.nodes))
+        local should_recurse = should_expand_fn(expansion_count - 1, node, populate_node)
+        return expansion_count < M.MAX_FOLDER_DISCOVERY and (should_recurse and node.open and node.nodes)
       end)
       :iterate()
 
@@ -64,9 +79,10 @@ local function gen_iterator()
 end
 
 ---@param base_node table
-function M.fn(base_node)
+function M.fn(base_node, expand_until)
+  expand_until = expand_until or expand_until_max_or_empty
   local node = base_node.nodes and base_node or core.get_explorer()
-  if gen_iterator()(node) then
+  if gen_iterator(expand_until)(node) then
     notify.warn("expansion iteration was halted after " .. M.MAX_FOLDER_DISCOVERY .. " discovered folders")
   end
   renderer.draw()

lua/nvim-tree/explorer/node.lua

@@ -36,7 +36,7 @@ end
 ---@param node Node
 ---@return boolean
 function M.has_one_child_folder(node)
-  return #node.nodes == 1 and node.nodes[1].nodes and vim.loop.fs_access(node.nodes[1].absolute_path, "R") or false
+  return node.nodes ~= nil and #node.nodes == 1 and node.nodes[1].nodes and vim.loop.fs_access(node.nodes[1].absolute_path, "R") or false
 end
 
 ---@param node Node