feat: copy directories recursively (#241)

Author: fdschmidt93

lua/plenary/path.lua

@@ -429,11 +429,13 @@ function Path:mkdir(opts)
   local parents = F.if_nil(opts.parents, false, opts.parents)
   local exists_ok = F.if_nil(opts.exists_ok, true, opts.exists_ok)
 
-  if not exists_ok and self:exists() then
+  local exists = self:exists()
+  if not exists_ok and exists then
     error("FileExistsError:" .. self:absolute())
   end
 
-  if not uv.fs_mkdir(self:_fs_filename(), mode) then
+  -- fs_mkdir returns nil if folder exists
+  if not uv.fs_mkdir(self:_fs_filename(), mode) and not exists then
     if parents then
       local dirs = self:_split()
       local processed = ""
@@ -500,20 +502,77 @@ function Path:rename(opts)
   return status
 end
 
+--- Copy files or folders with defaults akin to GNU's `cp`.
+---@param opts table: options to pass to toggling registered actions
+---@field destination string|Path: target file path to copy to
+---@field recursive bool: whether to copy folders recursively (default: false)
+---@field override bool: whether to override files (default: true)
+---@field interactive bool: confirm if copy would override; precedes `override` (default: false)
+---@field respect_gitignore bool: skip folders ignored by all detected `gitignore`s (default: false)
+---@field hidden bool: whether to add hidden files in recursively copying folders (default: true)
+---@field parents bool: whether to create possibly non-existing parent dirs of `opts.destination` (default: false)
+---@field exists_ok bool: whether ok if `opts.destination` exists, if so folders are merged (default: true)
+---@return table {[Path of destination]: bool} indicating success of copy; nested tables constitute sub dirs
 function Path:copy(opts)
   opts = opts or {}
+  opts.recursive = F.if_nil(opts.recursive, false, opts.recursive)
+  opts.override = F.if_nil(opts.override, true, opts.override)
 
+  local dest = opts.destination
   -- handles `.`, `..`, `./`, and `../`
-  if opts.destination:match "^%.%.?/?\\?.+" then
-    opts.destination = {
-      uv.fs_realpath(opts.destination:sub(1, 3)),
-      opts.destination:sub(4, #opts.destination),
+  if not Path.is_path(dest) then
+    if type(dest) == "string" and dest:match "^%.%.?/?\\?.+" then
+      dest = {
+        uv.fs_realpath(dest:sub(1, 3)),
+        dest:sub(4, #dest),
+      }
+    end
+    dest = Path:new(dest)
+  end
+  -- success is true in case file is copied, false otherwise
+  local success = {}
+  if not self:is_dir() then
+    if opts.interactive and dest:exists() then
+      vim.ui.select(
+        { "Yes", "No" },
+        { prompt = string.format("Overwrite existing %s?", dest:absolute()) },
+        function(_, idx)
+          success[dest] = uv.fs_copyfile(self:absolute(), dest:absolute(), { excl = not (idx == 1) }) or false
+        end
+      )
+    else
+      -- nil: not overriden if `override = false`
+      success[dest] = uv.fs_copyfile(self:absolute(), dest:absolute(), { excl = not opts.override }) or false
+    end
+    return success
+  end
+  -- dir
+  if opts.recursive then
+    dest:mkdir {
+      parents = F.if_nil(opts.parents, false, opts.parents),
+      exists_ok = F.if_nil(opts.exists_ok, true, opts.exists_ok),
     }
+    local scan = require "plenary.scandir"
+    local data = scan.scan_dir(self.filename, {
+      respect_gitignore = F.if_nil(opts.respect_gitignore, false, opts.respect_gitignore),
+      hidden = F.if_nil(opts.hidden, true, opts.hidden),
+      depth = 1,
+      add_dirs = true,
+    })
+    for _, entry in ipairs(data) do
+      local entry_path = Path:new(entry)
+      local suffix = table.remove(entry_path:_split())
+      local new_dest = dest:joinpath(suffix)
+      -- clear destination as it might be Path table otherwise failing w/ extend
+      opts.destination = nil
+      local new_opts = vim.tbl_deep_extend("force", opts, { destination = new_dest })
+      -- nil: not overriden if `override = false`
+      success[new_dest] = entry_path:copy(new_opts) or false
+    end
+    return success
+  else
+    error(string.format("Warning: %s was not copied as `recursive=false`", self:absolute()))
   end
-
-  local dest = Path:new(opts.destination)
-
-  return uv.fs_copyfile(self:absolute(), dest:absolute(), { excl = true })
 end
 
 function Path:touch(opts)

tests/plenary/path_spec.lua

@@ -447,21 +447,125 @@ describe("Path", function()
       Path:new(vim.loop.fs_realpath "../some_random_filename.lua"):rm()
     end)
 
-    it("cannot copy a file if it's already exists", function()
+    it("cannot copy an existing file if override false", function()
       local p1 = Path:new "a_random_filename.rs"
       local p2 = Path:new "not_a_random_filename.rs"
       assert(pcall(p1.touch, p1))
       assert(pcall(p2.touch, p2))
       assert(p1:exists())
       assert(p2:exists())
 
-      assert(pcall(p1.copy, p1, { destination = "not_a_random_filename.rs" }))
+      assert(pcall(p1.copy, p1, { destination = "not_a_random_filename.rs", override = false }))
       assert.are.same(p1.filename, "a_random_filename.rs")
       assert.are.same(p2.filename, "not_a_random_filename.rs")
 
       p1:rm()
       p2:rm()
     end)
+
+    it("fails when copying folders non-recursively", function()
+      local src_dir = Path:new "src"
+      src_dir:mkdir()
+      src_dir:joinpath("file1.lua"):touch()
+
+      local trg_dir = Path:new "trg"
+      local status = xpcall(function()
+        src_dir:copy { destination = trg_dir, recursive = false }
+      end, function() end)
+      -- failed as intended
+      assert(status == false)
+
+      src_dir:rm { recursive = true }
+    end)
+
+    it("can copy directories recursively", function()
+      -- vim.tbl_flatten doesn't work here as copy doesn't return a list
+      local flatten
+      flatten = function(ret, t)
+        for _, v in pairs(t) do
+          if type(v) == "table" then
+            flatten(ret, v)
+          else
+            table.insert(ret, v)
+          end
+        end
+      end
+
+      -- setup directories
+      local src_dir = Path:new "src"
+      local trg_dir = Path:new "trg"
+      src_dir:mkdir()
+
+      -- set up sub directory paths for creation and testing
+      local sub_dirs = { "sub_dir1", "sub_dir1/sub_dir2" }
+      local src_dirs = { src_dir }
+      local trg_dirs = { trg_dir }
+      -- {src, trg}_dirs is a table with all directory levels by {src, trg}
+      for _, dir in ipairs(sub_dirs) do
+        table.insert(src_dirs, src_dir:joinpath(dir))
+        table.insert(trg_dirs, trg_dir:joinpath(dir))
+      end
+
+      -- generate {file}_{level}.lua on every directory level in src
+      -- src
+      -- ├── file1_1.lua
+      -- ├── file2_1.lua
+      -- ├── .file3_1.lua
+      -- └── sub_dir1
+      --     ├── file1_2.lua
+      --     ├── file2_2.lua
+      --     ├── .file3_2.lua
+      --     └── sub_dir2
+      --         ├── file1_3.lua
+      --         ├── file2_3.lua
+      --         └── .file3_3.lua
+      local files = { "file1", "file2", ".file3" }
+      for _, file in ipairs(files) do
+        for level, dir in ipairs(src_dirs) do
+          local p = dir:joinpath(file .. "_" .. level .. ".lua")
+          assert(pcall(p.touch, p, { parents = true, exists_ok = true }))
+          assert(p:exists())
+        end
+      end
+
+      for _, hidden in ipairs { true, false } do
+        -- override = `false` should NOT copy as it was copied beforehand
+        for _, override in ipairs { true, false } do
+          local success = src_dir:copy { destination = trg_dir, recursive = true, override = override, hidden = hidden }
+          -- the files are already created because we iterate first with `override=true`
+          -- hence, we test here that no file ops have been committed: any value in tbl of tbls should be false
+          if not override then
+            local file_ops = {}
+            flatten(file_ops, success)
+            -- 3 layers with at at least 2 and at most 3 files (`hidden = true`)
+            local num_files = not hidden and 6 or 9
+            assert(#file_ops == num_files)
+            for _, op in ipairs(file_ops) do
+              assert(op == false)
+            end
+          else
+            for _, file in ipairs(files) do
+              for level, dir in ipairs(trg_dirs) do
+                local p = dir:joinpath(file .. "_" .. level .. ".lua")
+                -- file 3 is hidden
+                if not (file == files[3]) then
+                  assert(p:exists())
+                else
+                  assert(p:exists() == hidden)
+                end
+              end
+            end
+          end
+          -- only clean up once we tested that we dont want to copy
+          -- if `override=true`
+          if not override then
+            trg_dir:rm { recursive = true }
+          end
+        end
+      end
+
+      src_dir:rm { recursive = true }
+    end)
   end)
 
   describe("parents", function()