chore: add fs API unlinkEmptyDirectoryAsync and tests

Author: abose

src/filesystem/Directory.js

@@ -121,41 +121,70 @@ define(function (require, exports, module) {
     }
 
     /**
-     * Read the contents of a Directory, returns a promise. If this Directory is under a watch root,
-     * the listing will exclude any items filtered out by the watch root's filter
-     * function.
+     * Returns true if is a directory exists and is empty.
      *
-     * @return {Promise<{entries: FileSystemEntry, contentStats: FileSystemStats, contentsStatsErrors}>} An object
-     * with attributes - entries(an array of file system entries), contentStats and contentsStatsErrors(a map from
-     * content name to error if there is any).
+     * @return {Promise<boolean>} True if directory is empty and it exists, else false.
      */
-    Directory.prototype.getContentsAsync = function () {
+    Directory.prototype.isEmptyAsync = function () {
         let that = this;
         return new Promise((resolve, reject)=>{
-            that.getContents((err, contents, contentStats, contentsStatsErrors) =>{
+            that.getContents((err, contents) =>{
                 if(err){
                     reject(err);
                     return;
                 }
-                resolve({entries: contents, contentStats, contentsStatsErrors});
+                resolve(contents.length === 0);
             });
         });
     };
 
     /**
-     * Returns true if is a directory exists and is empty.
+     * Recursively deletes all empty subdirectories within the current directory. If all subdirectories are empty,
+     * the current directory itself will be deleted.
+     * A directory is considered empty if it doesn't contain any files in its subtree.
      *
-     * @return {Promise<boolean>} True if directory is empty and it exists, else false.
+     * If a subtree contains a large number of nested subdirectories and no files, the whole tree will be deleted.
+     * Only branches that contain a file will be retained.
+     *
+     * @returns {Promise<void>} A Promise that resolves when the operation is finished
+     * @throws {FileSystemError} If an error occurs while accessing the filesystem
+     *
+     * @example
+     *
+     * await dir.unlinkEmptyDirectoryAsync();
      */
-    Directory.prototype.isEmptyAsync = function () {
+    Directory.prototype.unlinkEmptyDirectoryAsync = async function () {
+        let that = this;
+        let {entries} = await that.getContentsAsync();
+        for(let entry of entries){
+            if(entry.isDirectory) {
+                await entry.unlinkEmptyDirectoryAsync();
+            }
+        }
+        let isEmpty = await that.isEmptyAsync();
+        if(isEmpty){
+            await that.unlinkAsync();
+        }
+    };
+
+    /**
+     * Read the contents of a Directory, returns a promise. If this Directory is under a watch root,
+     * the listing will exclude any items filtered out by the watch root's filter
+     * function.
+     *
+     * @return {Promise<{entries: FileSystemEntry, contentStats: FileSystemStats, contentsStatsErrors}>} An object
+     * with attributes - entries(an array of file system entries), contentStats and contentsStatsErrors(a map from
+     * content name to error if there is any).
+     */
+    Directory.prototype.getContentsAsync = function () {
         let that = this;
         return new Promise((resolve, reject)=>{
-            that.getContents((err, contents) =>{
+            that.getContents((err, contents, contentStats, contentsStatsErrors) =>{
                 if(err){
                     reject(err);
                     return;
                 }
-                resolve(contents.length === 0);
+                resolve({entries: contents, contentStats, contentsStatsErrors});
             });
         });
     };

test/spec/FileSystem-test.js

@@ -19,14 +19,15 @@
  *
  */
 
-/*global describe, it, expect, beforeEach, afterEach, awaits, awaitsFor, awaitsForDone, jasmine, spyOn */
+/*global describe, it, expect, beforeEach, afterEach, awaits, awaitsFor, awaitsForDone, jasmine, spyOn, jsPromise */
 
 define(function (require, exports, module) {
 
 
     var Directory           = require("filesystem/Directory"),
         File                = require("filesystem/File"),
         FileSystem          = require("filesystem/FileSystem"),
+        FileUtils           = require("file/FileUtils"),
         FileSystemStats     = require("filesystem/FileSystemStats"),
         FileSystemError     = require("filesystem/FileSystemError"),
         MockFileSystemImpl  = require("./MockFileSystemImpl"),
@@ -569,6 +570,84 @@ define(function (require, exports, module) {
             });
         });
 
+        describe("unlinkEmptyDirectoryAsync tests", function () {
+            it("should unlinkEmptyDirectoryAsync delete self if empty", async function () {
+                let directory = fileSystem.getDirectoryForPath("/subdir2/");
+                await directory.createAsync();
+                let stat = await directory.statAsync();
+                expect(stat.isDirectory).toBeTrue();
+
+                await directory.unlinkEmptyDirectoryAsync();
+                let isExists = await directory.existsAsync();
+                expect(isExists).toBeFalse();
+            });
+
+            it("should unlinkEmptyDirectoryAsync reject if directory doesnt exist", async function () {
+                let directory = fileSystem.getDirectoryForPath("/subdir2/");
+                let isExists = await directory.existsAsync();
+                expect(isExists).toBeFalse();
+
+                let err;
+                try{
+                    await directory.unlinkEmptyDirectoryAsync();
+                } catch (e) {
+                    err = e;
+                }
+                expect(err).toBe(FileSystemError.NOT_FOUND);
+            });
+
+            async function createDirTree(dirList, fileList) {
+                for(let dir of dirList){
+                    let directory = fileSystem.getDirectoryForPath(dir);
+                    await directory.createAsync();
+                }
+                for(let file of fileList){
+                    let fileEntry = fileSystem.getFileForPath(file);
+                    await jsPromise(FileUtils.writeText(fileEntry, "hello", true));
+                }
+            }
+            async function verifyExists(deletedPaths, shouldExist, isFile = false) {
+                for(let deletedPath of deletedPaths){
+                    let entry = isFile ? fileSystem.getFileForPath(deletedPath)
+                        :fileSystem.getDirectoryForPath(deletedPath);
+                    let isExists = await entry.existsAsync();
+                    expect(deletedPath + ":" + isExists).toBe(deletedPath + ":" + shouldExist);
+                }
+            }
+            it("should unlinkEmptyDirectoryAsync delete subtree with no files", async function () {
+                await createDirTree(["/subdir2/", "/subdir2/s3/", "/subdir2/s4/", "/subdir2/s3/s33/"], []);
+
+                let directory = fileSystem.getDirectoryForPath("/subdir2/");
+                await directory.unlinkEmptyDirectoryAsync();
+                let isExists = await directory.existsAsync();
+                expect(isExists).toBeFalse();
+            });
+
+            it("should unlinkEmptyDirectoryAsync retain subtree with files", async function () {
+                await createDirTree(["/subdir2/", "/subdir2/s3/", "/subdir2/s4/", "/subdir2/s3/s33/"],
+                    ["/subdir2/1.txt"]);
+
+                let directory = fileSystem.getDirectoryForPath("/subdir2/");
+                await directory.unlinkEmptyDirectoryAsync();
+
+                await verifyExists(["/subdir2/s3/", "/subdir2/s4/", "/subdir2/s3/s33/"], false);
+                await verifyExists(["/subdir2/"], true);
+                await verifyExists(["/subdir2/1.txt"], true, true);
+            });
+
+            it("should unlinkEmptyDirectoryAsync retain subtree with files 2", async function () {
+                await createDirTree(["/subdir2/", "/subdir2/s3/", "/subdir2/s3/s33/", "/subdir2/s3/s33/s333/"],
+                    ["/subdir2/s3/s33/1.txt"]);
+
+                let directory = fileSystem.getDirectoryForPath("/subdir2/s3/");
+                await directory.unlinkEmptyDirectoryAsync();
+
+                await verifyExists(["/subdir2/s3/s33/s333/"], false);
+                await verifyExists(["/subdir2/", "/subdir2/s3/", "/subdir2/s3/s33/"], true);
+                await verifyExists(["/subdir2/s3/s33/1.txt"], true, true);
+            });
+        });
+
         describe("Get Free Path", function () {
             it("should return suggested path as is if it doesnt exist", async function () {
                 let cbCalled = false,