factories for all nodes, add RootNode

Author: alex-courtis

lua/nvim-tree/core.lua

@@ -15,7 +15,7 @@ function M.init(foldername)
   if TreeExplorer then
     TreeExplorer:destroy()
   end
-  TreeExplorer = require("nvim-tree.explorer"):new(foldername)
+  TreeExplorer = require("nvim-tree.explorer"):create(foldername)
   if not first_init_done then
     events._dispatch_ready()
     first_init_done = true

lua/nvim-tree/explorer/init.lua

@@ -5,8 +5,7 @@ local utils = require "nvim-tree.utils"
 local view = require "nvim-tree.view"
 local node_factory = require "nvim-tree.node.factory"
 
-local BaseNode = require "nvim-tree.node"
-local DirectoryNode = require "nvim-tree.node.directory"
+local RootNode = require "nvim-tree.node.root"
 local Watcher = require "nvim-tree.watcher"
 
 local Iterator = require "nvim-tree.iterators.node-iterator"
@@ -23,19 +22,20 @@ local FILTER_REASON = require("nvim-tree.enum").FILTER_REASON
 
 local config
 
----@class (exact) Explorer: DirectoryNode
+---@class (exact) Explorer: RootNode
 ---@field opts table user options
 ---@field renderer Renderer
 ---@field filters Filters
 ---@field live_filter LiveFilter
 ---@field sorters Sorter
 ---@field marks Marks
 ---@field clipboard Clipboard
-local Explorer = BaseNode.new(DirectoryNode) -- TODO do not inherit, add a root node to separate Explorer and Node
+local Explorer = RootNode:new()
 
----@param path string|nil
----@return Explorer|nil
-function Explorer:new(path)
+---Static factory method
+---@param path string?
+---@return Explorer?
+function Explorer:create(path)
   local err
 
   if path then
@@ -45,19 +45,19 @@ function Explorer:new(path)
   end
   if not path then
     notify.error(err)
-    return
+    return nil
   end
 
   ---@type Explorer
-  local placeholder = nil
+  local explorer_placeholder
 
-  local o = DirectoryNode.new(self, placeholder, nil, path, "..", nil)
-  ---@cast o Explorer
+  local o = RootNode.create(self, explorer_placeholder, path, "..", nil) --[[@as Explorer]]
 
   o.explorer = o
-  o.open = true
 
+  o.open = true
   o.opts = config
+
   o.sorters = Sorters:new(config)
   o.renderer = Renderer:new(config, o)
   o.filters = Filters:new(config, o)
@@ -121,7 +121,7 @@ function Explorer:reload(node, git_status)
   })
 
   while true do
-    local name, _ = vim.loop.fs_scandir_next(handle)
+    local name, t = vim.loop.fs_scandir_next(handle)
     if not name then
       break
     end
@@ -134,22 +134,19 @@ function Explorer:reload(node, git_status)
     if filter_reason == FILTER_REASON.none then
       remain_childs[abs] = true
 
-      -- Type must come from fs_stat and not fs_scandir_next to maintain sshfs compatibility
-      local type = stat and stat.type or nil
-
       -- Recreate node if type changes.
       if nodes_by_path[abs] then
         local n = nodes_by_path[abs]
 
-        if n.type ~= type then
+        if n.type ~= t then
           utils.array_remove(node.nodes, n)
           n:destroy()
           nodes_by_path[abs] = nil
         end
       end
 
       if not nodes_by_path[abs] then
-        local new_child = node_factory.create_node(self, node, abs, stat, name)
+        local new_child = node_factory.create_node(self, node, abs, t, stat, name)
         if new_child then
           table.insert(node.nodes, new_child)
           nodes_by_path[abs] = new_child
@@ -340,21 +337,21 @@ function Explorer:populate_children(handle, cwd, node, git_status, parent)
   })
 
   while true do
-    local name, _ = vim.loop.fs_scandir_next(handle)
+    local name, t = vim.loop.fs_scandir_next(handle)
     if not name then
       break
     end
 
     local abs = utils.path_join { cwd, name }
 
     if Watcher.is_fs_event_capable(abs) then
-      local profile = log.profile_start("populate_children %s", abs)
+      local profile = log.profile_start("explore populate_children %s", abs)
 
       ---@type uv.fs_stat.result|nil
       local stat = vim.loop.fs_stat(abs)
       local filter_reason = parent.filters:should_filter_as_reason(abs, stat, filter_status)
       if filter_reason == FILTER_REASON.none and not nodes_by_path[abs] then
-        local child = node_factory.create_node(self, node, abs, stat, name)
+        local child = node_factory.create_node(self, node, abs, t, stat, name)
         if child then
           table.insert(node.nodes, child)
           nodes_by_path[child.absolute_path] = true

lua/nvim-tree/node/directory.lua

@@ -3,40 +3,46 @@ local watch = require "nvim-tree.explorer.watch"
 local BaseNode = require "nvim-tree.node"
 
 ---@class (exact) DirectoryNode: BaseNode
----@field has_children boolean -- TODO remove this and just test nodes
----@field group_next Node|nil -- If node is grouped, this points to the next child dir/link node
+---@field has_children boolean
+---@field group_next Node? -- If node is grouped, this points to the next child dir/link node
 ---@field nodes Node[]
 ---@field open boolean
----@field hidden_stats table -- Each field of this table is a key for source and value for count
+---@field hidden_stats table? -- Each field of this table is a key for source and value for count
 local DirectoryNode = BaseNode:new()
 
+---Static factory method
 ---@param explorer Explorer
------@param parent DirectoryNode    -- TODO  #2871 #2886
+---@param parent Node?
 ---@param absolute_path string
 ---@param name string
 ---@param fs_stat uv.fs_stat.result|nil
 ---@return DirectoryNode
-function DirectoryNode:new(explorer, parent, absolute_path, name, fs_stat)
+function DirectoryNode:create(explorer, parent, absolute_path, name, fs_stat)
   local handle = vim.loop.fs_scandir(absolute_path)
-  local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
+  local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil or false
 
-  local o = BaseNode.new(self, {
+  ---@type DirectoryNode
+  local o = {
     type = "directory",
     explorer = explorer,
     absolute_path = absolute_path,
     executable = false,
     fs_stat = fs_stat,
+    git_status = nil,
     hidden = false,
     is_dot = false,
     name = name,
     parent = parent,
+    watcher = nil,
+    diag_status = nil,
 
     has_children = has_children,
     group_next = nil,
     nodes = {},
     open = false,
-  })
-  ---@cast o DirectoryNode
+    hidden_stats = nil,
+  }
+  o = self:new(o) --[[@as DirectoryNode]]
 
   o.watcher = watch.create_watcher(o)
 

lua/nvim-tree/node/factory.lua

@@ -5,26 +5,25 @@ local Watcher = require "nvim-tree.watcher"
 
 local M = {}
 
+---Factory function to create the appropriate Node
 ---@param explorer Explorer
------@param parent DirectoryNode    -- TODO #2871 #2886
+---@param parent Node
 ---@param abs string
----@param stat uv.fs_stat.result|nil
+---@param t string? type from vim.loop.fs_scandir_next as stat.type is incorrectly reported as a file for links
+---@param stat uv.fs_stat.result?
 ---@param name string
----@return Node|nil
-function M.create_node(explorer, parent, abs, stat, name)
+---@return Node?
+function M.create_node(explorer, parent, abs, t, stat, name)
   if not stat then
     return nil
   end
 
-  if stat.type == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
-    return DirectoryNode:new(explorer, parent, abs, name, stat)
-  elseif stat.type == "file" then
-    return FileNode:new(explorer, parent, abs, name, stat)
-  elseif stat.type == "link" then
-    local link = LinkNode:new(explorer, parent, abs, name, stat)
-    if link.link_to ~= nil then
-      return link
-    end
+  if t == "directory" and vim.loop.fs_access(abs, "R") and Watcher.is_fs_event_capable(abs) then
+    return DirectoryNode:create(explorer, parent, abs, name, stat)
+  elseif t == "file" then
+    return FileNode:create(explorer, parent, abs, name, stat)
+  elseif t == "link" then
+    return LinkNode:create(explorer, parent, abs, name, stat)
   end
 
   return nil

lua/nvim-tree/node/file.lua

@@ -6,27 +6,32 @@ local BaseNode = require "nvim-tree.node"
 ---@field extension string
 local FileNode = BaseNode:new()
 
+---Static factory method
 ---@param explorer Explorer
------@param parent DirectoryNode    -- TODO #2871 #2886
+---@param parent Node
 ---@param absolute_path string
 ---@param name string
----@param fs_stat uv.fs_stat.result|nil
+---@param fs_stat uv.fs_stat.result?
 ---@return FileNode
-function FileNode:new(explorer, parent, absolute_path, name, fs_stat)
-  local o = BaseNode.new(self, {
+function FileNode:create(explorer, parent, absolute_path, name, fs_stat)
+  ---@type FileNode
+  local o = {
     type = "file",
     explorer = explorer,
     absolute_path = absolute_path,
     executable = utils.is_executable(absolute_path),
     fs_stat = fs_stat,
-    name = name,
-    parent = parent,
+    git_status = nil,
     hidden = false,
     is_dot = false,
+    name = name,
+    parent = parent,
+    watcher = nil,
+    diag_status = nil,
 
     extension = string.match(name, ".?[^.]+%.(.*)") or "",
-  })
-  ---@cast o FileNode
+  }
+  o = self:new(o) --[[@as FileNode]]
 
   return o
 end

lua/nvim-tree/node/init.lua

@@ -1,22 +1,24 @@
 local git = require "nvim-tree.git"
 
+---Abstract Node class.
+---Uses the abstract factory pattern to instantiate child instances.
 ---@class (exact) BaseNode
 ---@field private __index? table
 ---@field type NODE_TYPE
 ---@field explorer Explorer
 ---@field absolute_path string
 ---@field executable boolean
----@field fs_stat uv.fs_stat.result|nil
----@field git_status GitStatus|nil
+---@field fs_stat uv.fs_stat.result?
+---@field git_status GitStatus?
 ---@field hidden boolean
 ---@field is_dot boolean
 ---@field name string
----@field parent DirectoryNode|nil
----@field watcher Watcher|nil
----@field diag_status DiagStatus|nil
+---@field parent Node?
+---@field watcher Watcher?
+---@field diag_status DiagStatus?
 local BaseNode = {}
 
----@alias Node BaseNode|DirectoryNode|FileNode|LinkNode
+---@alias Node RootNode|BaseNode|DirectoryNode|FileNode|LinkNode
 
 ---@param o BaseNode|nil
 ---@return BaseNode

lua/nvim-tree/node/link.lua

@@ -3,36 +3,42 @@ local watch = require "nvim-tree.explorer.watch"
 local BaseNode = require "nvim-tree.node"
 
 ---@class (exact) LinkNode: BaseNode
----@field has_children boolean -- TODO remove this and just test nodes
----@field group_next Node|nil -- If node is grouped, this points to the next child dir/link node
+---@field has_children boolean
+---@field group_next Node? -- If node is grouped, this points to the next child dir/link node
 ---@field link_to string absolute path
+---@field nodes Node[]
+---@field open boolean
 local LinkNode = BaseNode:new()
 
+---Static factory method
 ---@param explorer Explorer
------@param parent DirectoryNode    -- TODO #2871 #2886
+---@param parent Node
 ---@param absolute_path string
 ---@param name string
----@param fs_stat uv.fs_stat.result|nil
----@return LinkNode
-function LinkNode:new(explorer, parent, absolute_path, name, fs_stat)
-  local link_to = vim.loop.fs_realpath(absolute_path)
-  local open, nodes, has_children
-
-  -- TODO-INFO: sometimes fs_realpath returns nil
+---@param fs_stat uv.fs_stat.result?
+---@return LinkNode? nil on vim.loop.fs_realpath failure
+function LinkNode:create(explorer, parent, absolute_path, name, fs_stat)
+  -- INFO: sometimes fs_realpath returns nil
   -- I expect this be a bug in glibc, because it fails to retrieve the path for some
   -- links (for instance libr2.so in /usr/lib) and thus even with a C program realpath fails
   -- when it has no real reason to. Maybe there is a reason, but errno is definitely wrong.
-  -- So we need to check for link_to ~= nil when adding new links to the main tree
+  local link_to = vim.loop.fs_realpath(absolute_path)
+  if not link_to then
+    return nil
+  end
+
+  local open, nodes, has_children
   local is_dir_link = (link_to ~= nil) and vim.loop.fs_stat(link_to).type == "directory"
 
   if is_dir_link and link_to then
     local handle = vim.loop.fs_scandir(link_to)
-    has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil
+    has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil or false
     open = false
     nodes = {}
   end
 
-  local o = BaseNode.new(self, {
+  ---@type LinkNode
+  local o = {
     type = "link",
     explorer = explorer,
     absolute_path = absolute_path,
@@ -42,15 +48,16 @@ function LinkNode:new(explorer, parent, absolute_path, name, fs_stat)
     is_dot = false,
     name = name,
     parent = parent,
-
-    link_to = link_to,
+    watcher = nil,
+    diag_status = nil,
 
     has_children = has_children,
     group_next = nil,
+    link_to = link_to,
     nodes = nodes,
     open = open,
-  })
-  ---@cast o LinkNode
+  }
+  o = self:new(o) --[[@as LinkNode]]
 
   if is_dir_link then
     o.watcher = watch.create_watcher(o)

lua/nvim-tree/node/root.lua

@@ -0,0 +1,20 @@
+local DirectoryNode = require "nvim-tree.node.directory"
+
+---@class (exact) RootNode: DirectoryNode
+local RootNode = DirectoryNode:new()
+
+---Static factory method
+---@param explorer Explorer
+---@param absolute_path string
+---@param name string
+---@param fs_stat uv.fs_stat.result|nil
+---@return RootNode
+function RootNode:create(explorer, absolute_path, name, fs_stat)
+  local o = DirectoryNode:create(explorer, nil, absolute_path, name, fs_stat)
+
+  o = self:new(o) --[[@as RootNode]]
+
+  return o
+end
+
+return RootNode