add 'touch', 'rm', & read methods

Author: jamestrew

lua/plenary/path2.lua

@@ -524,9 +524,9 @@ end
 --- Will throw error if path doesn't exist.
 ---@return uv.aliases.fs_stat_table
 function Path:stat()
-  local res, _, err_msg = uv.fs_stat(self:absolute())
+  local res, err = uv.fs_stat(self:absolute())
   if res == nil then
-    error(err_msg)
+    error(err)
   end
   return res
 end
@@ -541,9 +541,9 @@ end
 --- Will throw error if path doesn't exist.
 ---@return uv.aliases.fs_stat_table
 function Path:lstat()
-  local res, _, err_msg = uv.fs_lstat(self:absolute())
+  local res, err = uv.fs_lstat(self:absolute())
   if res == nil then
-    error(err_msg)
+    error(err)
   end
   return res
 end
@@ -797,7 +797,6 @@ end
 
 --- Create directory
 ---@param opts plenary.Path2.mkdirOpts?
----@return boolean success
 function Path:mkdir(opts)
   opts = opts or {}
   opts.mode = vim.F.if_nil(opts.mode, 511)
@@ -812,18 +811,18 @@ function Path:mkdir(opts)
 
   local ok, err_msg, err_code = uv.fs_mkdir(abs_path, opts.mode)
   if ok then
-    return true
+    return
   end
   if err_code == "EEXIST" then
-    return true
+    return
   end
   if err_code == "ENOENT" then
     if not opts.parents or self.parent == self then
       error(err_msg)
     end
     self:parent():mkdir { mode = opts.mode }
     uv.fs_mkdir(abs_path, opts.mode)
-    return true
+    return
   end
 
   error(err_msg)
@@ -850,7 +849,6 @@ end
 --- 'touch' file.
 --- If it doesn't exist, creates it including optionally, the parent directories
 ---@param opts plenary.Path2.touchOpts?
----@return boolean success
 function Path:touch(opts)
   opts = opts or {}
   opts.mode = vim.F.if_nil(opts.mode, 438)
@@ -861,29 +859,192 @@ function Path:touch(opts)
   if self:exists() then
     local new_time = os.time()
     uv.fs_utime(abs_path, new_time, new_time)
-    return true
+    return
   end
 
   if not not opts.parents then
-    local mode = type(opts.parents) == "number" and opts.parents ---@cast mode number?
+    local mode = type(opts.parents) == "number" and opts.parents or nil ---@cast mode number?
     _ = Path:new(self:parent()):mkdir { mode = mode, parents = true }
   end
 
-  local fd, _, err_msg = uv.fs_open(self:absolute(), "w", opts.mode)
+  local fd, err = uv.fs_open(self:absolute(), "w", opts.mode)
   if fd == nil then
-    error(err_msg)
+    error(err)
   end
 
   local ok
-  ok, _, err_msg = uv.fs_close(fd)
+  ok, err = uv.fs_close(fd)
   if not ok then
-    error(err_msg)
+    error(err)
   end
-
-  return true
 end
 
+---@class plenary.Path2.rmOpts
+---@field recursive boolean? remove directories and their content recursively (defaul: `false`)
+
+--- rm file or optional recursively remove directories and their content recursively
+---@param opts plenary.Path2.rmOpts?
 function Path:rm(opts)
+  opts = opts or {}
+  opts.recursive = vim.F.if_nil(opts.recursive, false)
+
+  if not opts.recursive or not self:is_dir() then
+    local ok, err = uv.fs_unlink(self:absolute())
+    if ok then
+      return
+    end
+    if self:is_dir() then
+      error(string.format("Cannnot rm director '%s'.", self:absolute()))
+    end
+    error(err)
+  end
+
+  for p, dirs, files in self:walk(false) do
+    for _, file in ipairs(files) do
+      print("delete file", file, (p / file):absolute())
+      local _, err = uv.fs_unlink((p / file):absolute())
+      if err then
+        error(err)
+      end
+    end
+
+    for _, dir in ipairs(dirs) do
+      print("delete dir", dir, (p / dir):absolute())
+      local _, err = uv.fs_rmdir((p / dir):absolute())
+      if err then
+        error(err)
+      end
+    end
+  end
+
+  self:rmdir()
+end
+
+--- read file synchronously or asynchronously
+---@param callback fun(data: string)? callback to use for async version, nil for default
+---@return string? data
+function Path:read(callback)
+  if not self:is_file() then
+    error(string.format("'%s' is not a file", self:absolute()))
+  end
+
+  if callback == nil then
+    return self:_read_sync()
+  end
+  return self:_read_async(callback)
+end
+
+---@private
+---@return string
+function Path:_read_sync()
+  local fd, err = uv.fs_open(self:absolute(), "r", 438)
+  if fd == nil then
+    error(err)
+  end
+
+  local stat = self:stat()
+  local data
+  data, err = uv.fs_read(fd, stat.size, 0)
+  if data == nil then
+    error(err)
+  end
+  return data
+end
+
+---@private
+---@param callback fun(data: string) callback to use for async version, nil for default
+function Path:_read_async(callback)
+  uv.fs_open(self:absolute(), "r", 438, function(err_open, fd)
+    if err_open then
+      error(err_open)
+    end
+
+    uv.fs_fstat(fd, function(err_stat, stat)
+      if err_stat or stat == nil then
+        error(err_stat)
+      end
+
+      uv.fs_read(fd, stat.size, 0, function(err_read, data)
+        if err_read or data == nil then
+          error(err_read)
+        end
+        callback(data)
+      end)
+    end)
+  end)
+end
+
+--- read lines of a file into a list
+---@return string[]
+function Path:readlines()
+  local data = assert(self:read())
+  return vim.split(data, "\r?\n")
+end
+
+--- get an iterator for lines text in a file
+---@return fun(): string?
+function Path:iter_lines()
+  local data = assert(self:read())
+  return vim.gsplit(data, "\r?\n")
+end
+
+---@param top_down boolean? walk from current path down (default: `true`)
+---@return fun(): plenary.Path2?, string[]?, string[]? # iterator which yields (dirpath, dirnames, filenames)
+function Path:walk(top_down)
+  top_down = vim.F.if_nil(top_down, true)
+
+  local queue = { self } ---@type plenary.Path2[]
+  local curr_fs = nil ---@type uv_fs_t?
+  local curr_path = nil ---@type plenary.Path2
+
+  local rev_res = {} ---@type [plenary.Path2, string[], string[]]
+
+  return function()
+    while #queue > 0 or curr_fs do
+      if curr_fs == nil then
+        local p = table.remove(queue, 1)
+        local fs, err = uv.fs_scandir(p:absolute())
+
+        if fs == nil then
+          error(err)
+        end
+        curr_path = p
+        curr_fs = fs
+      end
+
+      if curr_fs then
+        local dirs = {}
+        local files = {}
+        while true do
+          local name, ty = uv.fs_scandir_next(curr_fs)
+          if name == nil then
+            curr_fs = nil
+            break
+          end
+
+          if ty == "directory" then
+            table.insert(queue, Path:new { curr_path, name })
+            table.insert(dirs, name)
+          else
+            table.insert(files, name)
+          end
+        end
+
+        if top_down then
+          return curr_path, dirs, files
+        else
+          table.insert(rev_res, { curr_path, dirs, files })
+        end
+      end
+    end
+
+    if not top_down and #rev_res > 0 then
+      local res = table.remove(rev_res)
+      return res[1], res[2], res[3]
+    end
+
+    return nil
+  end
 end
 
 return Path

tests/plenary/path2_spec.lua

@@ -1,7 +1,8 @@
 local Path = require "plenary.path2"
 local path = Path.path
 local compat = require "plenary.compat"
-local iswin = vim.loop.os_uname().sysname == "Windows_NT"
+local uv = vim.loop
+local iswin = uv.os_uname().sysname == "Windows_NT"
 
 local hasshellslash = vim.fn.exists "+shellslash" == 1
 
@@ -411,6 +412,12 @@ describe("Path2", function()
   end
 
   describe("mkdir / rmdir", function()
+    after_each(function()
+      uv.fs_rmdir "_dir_not_exist"
+      uv.fs_rmdir "impossible/dir"
+      uv.fs_rmdir "impossible"
+    end)
+
     it_cross_plat("can create and delete directories", function()
       local p = Path:new "_dir_not_exist"
 
@@ -467,52 +474,75 @@ describe("Path2", function()
   end)
 
   describe("touch/rm", function()
-    it("can create and delete new files", function()
+    after_each(function()
+      uv.fs_unlink "test_file.lua"
+      uv.fs_unlink "nested/nested2/test_file.lua"
+      uv.fs_rmdir "nested/nested2"
+      uv.fs_unlink "nested/asdf/.hidden"
+      uv.fs_rmdir "nested/asdf"
+      uv.fs_unlink "nested/dir/.hidden"
+      uv.fs_rmdir "nested/dir"
+      uv.fs_rmdir "nested"
+    end)
+
+    it_cross_plat("can create and delete new files", function()
       local p = Path:new "test_file.lua"
-      assert(pcall(p.touch, p))
-      assert(p:exists())
+      assert.not_error(function()
+        p:touch()
+      end)
+      assert.is_true(p:exists())
 
-      p:rm()
-      assert(not p:exists())
+      assert.not_error(function()
+        p:rm()
+      end)
+      assert.is_true(not p:exists())
     end)
 
-    it("does not effect already created files but updates last access", function()
+    it_cross_plat("does not effect already created files but updates last access", function()
       local p = Path:new "README.md"
-      local last_atime = p:stat().atime.sec
-      local last_mtime = p:stat().mtime.sec
-
       local lines = p:readlines()
 
-      assert(pcall(p.touch, p))
-      print(p:stat().atime.sec > last_atime)
-      print(p:stat().mtime.sec > last_mtime)
-      assert(p:exists())
+      assert.no_error(function()
+        p:touch()
+      end)
 
+      assert.is_true(p:exists())
       assert.are.same(lines, p:readlines())
     end)
 
-    it("does not create dirs if nested in none existing dirs and parents not set", function()
+    it_cross_plat("does not create dirs if nested in none existing dirs and parents not set", function()
       local p = Path:new { "nested", "nested2", "test_file.lua" }
-      assert(not pcall(p.touch, p, { parents = false }))
-      assert(not p:exists())
+      assert.has_error(function()
+        p:touch { parents = false }
+      end)
+      assert.is_false(p:exists())
     end)
 
-    it("does create dirs if nested in none existing dirs", function()
+    it_cross_plat("does create dirs if nested in none existing dirs", function()
       local p1 = Path:new { "nested", "nested2", "test_file.lua" }
       local p2 = Path:new { "nested", "asdf", ".hidden" }
       local d1 = Path:new { "nested", "dir", ".hidden" }
-      assert(pcall(p1.touch, p1, { parents = true }))
-      assert(pcall(p2.touch, p2, { parents = true }))
-      assert(pcall(d1.mkdir, d1, { parents = true }))
-      assert(p1:exists())
-      assert(p2:exists())
-      assert(d1:exists())
-
-      Path:new({ "nested" }):rm { recursive = true }
-      assert(not p1:exists())
-      assert(not p2:exists())
-      assert(not d1:exists())
-      assert(not Path:new({ "nested" }):exists())
+
+      assert.no_error(function()
+        p1:touch { parents = true }
+      end)
+      assert.no_error(function()
+        p2:touch { parents = true }
+      end)
+      assert.no_error(function()
+        d1:mkdir { parents = true }
+      end)
+      assert.is_true(p1:exists())
+      assert.is_true(p2:exists())
+      assert.is_true(d1:exists())
+
+      assert.no_error(function()
+        Path:new({ "nested" }):rm { recursive = true }
+      end)
+      assert.is_false(p1:exists())
+      assert.is_false(p2:exists())
+      assert.is_false(d1:exists())
+      assert.is_false(Path:new({ "nested" }):exists())
     end)
   end)