chore: migrate to classic (#2991)

* add classic, migrating nodes classes

* add mixins to classic

* typechecked optargs constructors for nodes

* typechecked optargs constructors for watcher and event

* luacheck

* typechecked optargs constructors for GitRunner

* typechecked optargs constructors for Sorter

* typechecked optargs constructors for decorators, WIP

* typechecked optargs constructors for decorators, WIP

* typechecked optargs constructors for decorators

* remove class

* replace enums with named maps

* Renderer and Builder use classic, tidy opts

* LiveFilter uses classic, tidy opts

* Filter uses classic, tidy opts

* add FilterTypes named map

* move toggles into filters

* Marks uses classic, tidy opts

* Sorter uses classic, tidy opts

* Clipboard uses classic, tidy opts

* use supers for node methods

* HighlightDisplay uses classic

* protected :new

* Watcher tidy

* Revert "use supers for node methods"

This reverts commit 9fc7a866ec.

* Watcher tidy

* format

* format

* Filters private methods

* format

* Sorter type safety

* Sorter type safety

* Sorter type safety

* Sorter type safety

* Sorter type safety

* Sorter type safety

* tidy Runner

* tidy hi-test name

lua/nvim-tree/node/directory-link.lua

@@ -2,35 +2,29 @@ local git_utils = require("nvim-tree.git.utils")
 local utils = require("nvim-tree.utils")
 
 local DirectoryNode = require("nvim-tree.node.directory")
+local LinkNode = require("nvim-tree.node.link")
 
----@class (exact) DirectoryLinkNode: DirectoryNode
----@field link_to string absolute path
----@field private fs_stat_target uv.fs_stat.result
-local DirectoryLinkNode = DirectoryNode:new()
+---@class (exact) DirectoryLinkNode: DirectoryNode, LinkNode
+local DirectoryLinkNode = DirectoryNode:extend()
+DirectoryLinkNode:implement(LinkNode)
 
----Static factory method
----@param explorer Explorer
----@param parent DirectoryNode
----@param absolute_path string
----@param link_to string
----@param name string
----@param fs_stat uv.fs_stat.result?
----@param fs_stat_target uv.fs_stat.result
----@return DirectoryLinkNode? nil on vim.loop.fs_realpath failure
-function DirectoryLinkNode:create(explorer, parent, absolute_path, link_to, name, fs_stat, fs_stat_target)
-  -- create DirectoryNode with the target path for the watcher
-  local o = DirectoryNode:create(explorer, parent, link_to, name, fs_stat)
+---@class DirectoryLinkNode
+---@overload fun(args: LinkNodeArgs): DirectoryLinkNode
 
-  o = self:new(o)
+---@protected
+---@param args LinkNodeArgs
+function DirectoryLinkNode:new(args)
+  LinkNode.new(self, args)
+
+  -- create DirectoryNode with watcher on link_to
+  local absolute_path = args.absolute_path
+  args.absolute_path = args.link_to
+  DirectoryLinkNode.super.new(self, args)
+
+  self.type          = "link"
 
   -- reset absolute path to the link itself
-  o.absolute_path = absolute_path
-
-  o.type = "link"
-  o.link_to = link_to
-  o.fs_stat_target = fs_stat_target
-
-  return o
+  self.absolute_path = absolute_path
 end
 
 function DirectoryLinkNode:destroy()
@@ -54,10 +48,10 @@ function DirectoryLinkNode:highlighted_icon()
 
   if self.open then
     str = self.explorer.opts.renderer.icons.glyphs.folder.symlink_open
-    hl = "NvimTreeOpenedFolderIcon"
+    hl  = "NvimTreeOpenedFolderIcon"
   else
     str = self.explorer.opts.renderer.icons.glyphs.folder.symlink
-    hl = "NvimTreeClosedFolderIcon"
+    hl  = "NvimTreeClosedFolderIcon"
   end
 
   return { str = str, hl = { hl } }
@@ -70,8 +64,9 @@ function DirectoryLinkNode:highlighted_name()
 
   if self.explorer.opts.renderer.symlink_destination then
     local link_to = utils.path_relative(self.link_to, self.explorer.absolute_path)
-    name.str = string.format("%s%s%s", name.str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
-    name.hl = { "NvimTreeSymlinkFolderName" }
+
+    name.str      = string.format("%s%s%s", name.str, self.explorer.opts.renderer.icons.symlink_arrow, link_to)
+    name.hl       = { "NvimTreeSymlinkFolderName" }
   end
 
   return name
@@ -82,7 +77,6 @@ end
 function DirectoryLinkNode:clone()
   local clone = DirectoryNode.clone(self) --[[@as DirectoryLinkNode]]
 
-  clone.type = self.type
   clone.link_to = self.link_to
   clone.fs_stat_target = self.fs_stat_target
 

lua/nvim-tree/node/directory.lua

@@ -1,6 +1,7 @@
 local git_utils = require("nvim-tree.git.utils")
 local icons = require("nvim-tree.renderer.components.devicons")
 local notify = require("nvim-tree.notify")
+
 local Node = require("nvim-tree.node")
 
 ---@class (exact) DirectoryNode: Node
@@ -10,45 +11,28 @@ local Node = require("nvim-tree.node")
 ---@field open boolean
 ---@field hidden_stats table? -- Each field of this table is a key for source and value for count
 ---@field private watcher Watcher?
-local DirectoryNode = Node:new()
+local DirectoryNode = Node:extend()
 
----Static factory method
----@param explorer Explorer
----@param parent DirectoryNode?
----@param absolute_path string
----@param name string
----@param fs_stat uv.fs_stat.result|nil
----@return DirectoryNode
-function DirectoryNode:create(explorer, parent, absolute_path, name, fs_stat)
-  local handle = vim.loop.fs_scandir(absolute_path)
+---@class DirectoryNode
+---@overload fun(args: NodeArgs): DirectoryNode
+
+---@protected
+---@param args NodeArgs
+function DirectoryNode:new(args)
+  DirectoryNode.super.new(self, args)
+
+  local handle       = vim.loop.fs_scandir(args.absolute_path)
   local has_children = handle and vim.loop.fs_scandir_next(handle) ~= nil or false
 
-  ---@type DirectoryNode
-  local o = {
-    type = "directory",
-    explorer = explorer,
-    absolute_path = absolute_path,
-    executable = false,
-    fs_stat = fs_stat,
-    git_status = nil,
-    hidden = false,
-    name = name,
-    parent = parent,
-    watcher = nil,
-    diag_status = nil,
-    is_dot = false,
+  self.type          = "directory"
 
-    has_children = has_children,
-    group_next = nil,
-    nodes = {},
-    open = false,
-    hidden_stats = nil,
-  }
-  o = self:new(o)
+  self.has_children  = has_children
+  self.group_next    = nil
+  self.nodes         = {}
+  self.open          = false
+  self.hidden_stats  = nil
 
-  o.watcher = require("nvim-tree.explorer.watch").create_watcher(o)
-
-  return o
+  self.watcher       = require("nvim-tree.explorer.watch").create_watcher(self)
 end
 
 function DirectoryNode:destroy()
@@ -289,12 +273,12 @@ end
 ---Create a sanitized partial copy of a node, populating children recursively.
 ---@return DirectoryNode cloned
 function DirectoryNode:clone()
-  local clone = Node.clone(self) --[[@as DirectoryNode]]
+  local clone        = Node.clone(self) --[[@as DirectoryNode]]
 
   clone.has_children = self.has_children
-  clone.group_next = nil
-  clone.nodes = {}
-  clone.open = self.open
+  clone.group_next   = nil
+  clone.nodes        = {}
+  clone.open         = self.open
   clone.hidden_stats = nil
 
   for _, child in ipairs(self.nodes) do

lua/nvim-tree/node/factory.lua

@@ -7,38 +7,38 @@ local Watcher = require("nvim-tree.watcher")
 local M = {}
 
 ---Factory function to create the appropriate Node
----@param explorer Explorer
----@param parent DirectoryNode
----@param absolute_path string
----@param stat uv.fs_stat.result? -- on nil stat return nil Node
----@param name string
+---nil on invalid stat or invalid link target stat
+---@param args NodeArgs
 ---@return Node?
-function M.create_node(explorer, parent, absolute_path, stat, name)
-  if not stat then
+function M.create(args)
+  if not args.fs_stat then
     return nil
   end
 
-  if stat.type == "directory" then
+  if args.fs_stat.type == "directory" then
     -- directory must be readable and enumerable
-    if vim.loop.fs_access(absolute_path, "R") and Watcher.is_fs_event_capable(absolute_path) then
-      return DirectoryNode:create(explorer, parent, absolute_path, name, stat)
+    if vim.loop.fs_access(args.absolute_path, "R") and Watcher.is_fs_event_capable(args.absolute_path) then
+      return DirectoryNode(args)
     end
-  elseif stat.type == "file" then
-    -- any file
-    return FileNode:create(explorer, parent, absolute_path, name, stat)
-  elseif stat.type == "link" then
+  elseif args.fs_stat.type == "file" then
+    return FileNode(args)
+  elseif args.fs_stat.type == "link" then
     -- link target path and stat must resolve
-    local link_to = vim.loop.fs_realpath(absolute_path)
+    local link_to = vim.loop.fs_realpath(args.absolute_path)
     local link_to_stat = link_to and vim.loop.fs_stat(link_to)
     if not link_to or not link_to_stat then
       return
     end
 
+    ---@cast args LinkNodeArgs
+    args.link_to        = link_to
+    args.fs_stat_target = link_to_stat
+
     -- choose directory or file
     if link_to_stat.type == "directory" then
-      return DirectoryLinkNode:create(explorer, parent, absolute_path, link_to, name, stat, link_to_stat)
+      return DirectoryLinkNode(args)
     else
-      return FileLinkNode:create(explorer, parent, absolute_path, link_to, name, stat, link_to_stat)
+      return FileLinkNode(args)
     end
   end
 

lua/nvim-tree/node/file-link.lua

@@ -2,31 +2,22 @@ local git_utils = require("nvim-tree.git.utils")
 local utils = require("nvim-tree.utils")
 
 local FileNode = require("nvim-tree.node.file")
+local LinkNode = require("nvim-tree.node.link")
 
----@class (exact) FileLinkNode: FileNode
----@field link_to string absolute path
----@field private fs_stat_target uv.fs_stat.result
-local FileLinkNode = FileNode:new()
+---@class (exact) FileLinkNode: FileNode, LinkNode
+local FileLinkNode = FileNode:extend()
+FileLinkNode:implement(LinkNode)
 
----Static factory method
----@param explorer Explorer
----@param parent DirectoryNode
----@param absolute_path string
----@param link_to string
----@param name string
----@param fs_stat uv.fs_stat.result?
----@param fs_stat_target uv.fs_stat.result
----@return FileLinkNode? nil on vim.loop.fs_realpath failure
-function FileLinkNode:create(explorer, parent, absolute_path, link_to, name, fs_stat, fs_stat_target)
-  local o = FileNode:create(explorer, parent, absolute_path, name, fs_stat)
+---@class FileLinkNode
+---@overload fun(args: LinkNodeArgs): FileLinkNode
 
-  o = self:new(o)
+---@protected
+---@param args LinkNodeArgs
+function FileLinkNode:new(args)
+  LinkNode.new(self, args)
+  FileLinkNode.super.new(self, args)
 
-  o.type = "link"
-  o.link_to = link_to
-  o.fs_stat_target = fs_stat_target
-
-  return o
+  self.type = "link"
 end
 
 function FileLinkNode:destroy()
@@ -71,7 +62,6 @@ end
 function FileLinkNode:clone()
   local clone = FileNode.clone(self) --[[@as FileLinkNode]]
 
-  clone.type = self.type
   clone.link_to = self.link_to
   clone.fs_stat_target = self.fs_stat_target
 

lua/nvim-tree/node/file.lua

@@ -15,35 +15,19 @@ local PICTURE_MAP = {
 
 ---@class (exact) FileNode: Node
 ---@field extension string
-local FileNode = Node:new()
+local FileNode = Node:extend()
 
----Static factory method
----@param explorer Explorer
----@param parent DirectoryNode
----@param absolute_path string
----@param name string
----@param fs_stat uv.fs_stat.result?
----@return FileNode
-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,
-    git_status = nil,
-    hidden = false,
-    name = name,
-    parent = parent,
-    diag_status = nil,
-    is_dot = false,
+---@class FileNode
+---@overload fun(args: NodeArgs): FileNode
 
-    extension = string.match(name, ".?[^.]+%.(.*)") or "",
-  }
-  o = self:new(o)
+---@protected
+---@param args NodeArgs
+function FileNode:new(args)
+  FileNode.super.new(self, args)
 
-  return o
+  self.type       = "file"
+  self.extension  = string.match(args.name, ".?[^.]+%.(.*)") or ""
+  self.executable = utils.is_executable(args.absolute_path)
 end
 
 function FileNode:destroy()

lua/nvim-tree/node/init.lua

@@ -1,9 +1,8 @@
-local Class = require("nvim-tree.class")
+local Class = require("nvim-tree.classic")
 
 ---Abstract Node class.
----Uses the abstract factory pattern to instantiate child instances.
 ---@class (exact) Node: Class
----@field type NODE_TYPE
+---@field type "file" | "directory" | "link" uv.fs_stat.result.type
 ---@field explorer Explorer
 ---@field absolute_path string
 ---@field executable boolean
@@ -14,7 +13,29 @@ local Class = require("nvim-tree.class")
 ---@field parent DirectoryNode?
 ---@field diag_status DiagStatus?
 ---@field private is_dot boolean cached is_dotfile
-local Node = Class:new()
+local Node = Class:extend()
+
+---@class (exact) NodeArgs
+---@field explorer Explorer
+---@field parent DirectoryNode?
+---@field absolute_path string
+---@field name string
+---@field fs_stat uv.fs_stat.result?
+
+---@protected
+---@param args NodeArgs
+function Node:new(args)
+  self.explorer      = args.explorer
+  self.absolute_path = args.absolute_path
+  self.executable    = false
+  self.fs_stat       = args.fs_stat
+  self.git_status    = nil
+  self.hidden        = false
+  self.name          = args.name
+  self.parent        = args.parent
+  self.diag_status   = nil
+  self.is_dot        = false
+end
 
 function Node:destroy()
 end
@@ -104,17 +125,17 @@ function Node:clone()
 
   ---@type Node
   local clone = {
-    type = self.type,
-    explorer = explorer_placeholder,
+    type          = self.type,
+    explorer      = explorer_placeholder,
     absolute_path = self.absolute_path,
-    executable = self.executable,
-    fs_stat = self.fs_stat,
-    git_status = self.git_status,
-    hidden = self.hidden,
-    name = self.name,
-    parent = nil,
-    diag_status = nil,
-    is_dot = self.is_dot,
+    executable    = self.executable,
+    fs_stat       = self.fs_stat,
+    git_status    = self.git_status,
+    hidden        = self.hidden,
+    name          = self.name,
+    parent        = nil,
+    diag_status   = nil,
+    is_dot        = self.is_dot,
   }
 
   return clone

lua/nvim-tree/node/link.lua

@@ -0,0 +1,19 @@
+local Class = require("nvim-tree.classic")
+
+---@class (exact) LinkNode: Class
+---@field link_to string
+---@field protected fs_stat_target uv.fs_stat.result
+local LinkNode = Class:extend()
+
+---@class (exact) LinkNodeArgs: NodeArgs
+---@field link_to string
+---@field fs_stat_target uv.fs_stat.result
+
+---@protected
+---@param args LinkNodeArgs
+function LinkNode:new(args)
+  self.link_to = args.link_to
+  self.fs_stat_target = args.fs_stat_target
+end
+
+return LinkNode

lua/nvim-tree/node/root.lua

@@ -1,20 +1,15 @@
 local DirectoryNode = require("nvim-tree.node.directory")
 
 ---@class (exact) RootNode: DirectoryNode
-local RootNode = DirectoryNode:new()
+local RootNode = DirectoryNode:extend()
 
----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)
+---@class RootNode
+---@overload fun(args: NodeArgs): RootNode
 
-  o = self:new(o)
-
-  return o
+---@protected
+---@param args NodeArgs
+function RootNode:new(args)
+  RootNode.super.new(self, args)
 end
 
 ---Root is never a dotfile