fs: implement fs.rmdir recursive

Added recursive option into fs.rmdir and fs.rmdirSync to
delete a forder with sub folders or files.

Author: shisama

doc/api/fs.md

@@ -2880,7 +2880,7 @@ changes:
 
 Synchronous rename(2). Returns `undefined`.
 
-## fs.rmdir(path, callback)
+## fs.rmdir(path[, options], callback)
 <!-- YAML
 added: v0.0.2
 changes:
@@ -2899,6 +2899,8 @@ changes:
 -->
 
 * `path` {string|Buffer|URL}
+* `options` {Object}
+  * `recursive` {boolean} **Default:** `false`
 * `callback` {Function}
   * `err` {Error}
 
@@ -2908,7 +2910,17 @@ to the completion callback.
 Using `fs.rmdir()` on a file (not a directory) results in an `ENOENT` error on
 Windows and an `ENOTDIR` error on POSIX.
 
-## fs.rmdirSync(path)
+The optional `options` argument can be an object with a `recursive` property
+indicating whether a folder with sub folders or files should be deleted.
+
+```js
+// Delete /path/to/foler, regardless of whether sub folders or files exist.
+fs.rmdir('/path/to/folder', { recursive: true }, (err) => {
+  if (err) throw err;
+});
+```
+
+## fs.rmdirSync(path[, options])
 <!-- YAML
 added: v0.1.21
 changes:
@@ -2919,6 +2931,8 @@ changes:
 -->
 
 * `path` {string|Buffer|URL}
+* `options` {Object}
+  * `recursive` {boolean} **Default:** `false`
 
 Synchronous rmdir(2). Returns `undefined`.
 
@@ -4336,12 +4350,14 @@ added: v10.0.0
 Renames `oldPath` to `newPath` and resolves the `Promise` with no arguments
 upon success.
 
-### fsPromises.rmdir(path)
+### fsPromises.rmdir(path[, options])
 <!-- YAML
 added: v10.0.0
 -->
 
 * `path` {string|Buffer|URL}
+* `options` {Object}
+  * `recursive` {boolean} **Default:** `false`
 * Returns: {Promise}
 
 Removes the directory identified by `path` then resolves the `Promise` with
@@ -4835,7 +4851,7 @@ the file contents.
 [`fs.readFile()`]: #fs_fs_readfile_path_options_callback
 [`fs.readFileSync()`]: #fs_fs_readfilesync_path_options
 [`fs.realpath()`]: #fs_fs_realpath_path_options_callback
-[`fs.rmdir()`]: #fs_fs_rmdir_path_callback
+[`fs.rmdir()`]: #fs_fs_rmdir_path_options_callback
 [`fs.stat()`]: #fs_fs_stat_path_options_callback
 [`fs.symlink()`]: #fs_fs_symlink_target_path_type_callback
 [`fs.utimes()`]: #fs_fs_utimes_path_atime_mtime_callback

lib/fs.js

@@ -686,20 +686,34 @@ function ftruncateSync(fd, len = 0) {
   handleErrorFromBinding(ctx);
 }
 
-function rmdir(path, callback) {
+function rmdir(path, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  const {
+    recursive = false
+  } = options || {};
   callback = makeCallback(callback);
   path = toPathIfFileURL(path);
   validatePath(path);
+  if (typeof recursive !== 'boolean')
+    throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', recursive);
   const req = new FSReqCallback();
   req.oncomplete = callback;
-  binding.rmdir(pathModule.toNamespacedPath(path), req);
+  binding.rmdir(pathModule.toNamespacedPath(path), recursive, req);
 }
 
-function rmdirSync(path) {
+function rmdirSync(path, options) {
   path = toPathIfFileURL(path);
+  const {
+    recursive = false
+  } = options || {};
   validatePath(path);
+  if (typeof recursive !== 'boolean')
+    throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', recursive);
   const ctx = { path };
-  binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);
+  binding.rmdir(pathModule.toNamespacedPath(path), recursive, undefined, ctx);
   handleErrorFromBinding(ctx);
 }
 

lib/internal/fs/promises.js

@@ -278,10 +278,17 @@ async function ftruncate(handle, len = 0) {
   return binding.ftruncate(handle.fd, len, kUsePromises);
 }
 
-async function rmdir(path) {
+async function rmdir(path, options) {
+  const {
+    recursive = false
+  } = options || {};
   path = toPathIfFileURL(path);
   validatePath(path);
-  return binding.rmdir(pathModule.toNamespacedPath(path), kUsePromises);
+  if (typeof recursive !== 'boolean')
+    throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', recursive);
+  return binding.rmdir(pathModule.toNamespacedPath(path),
+                       recursive,
+                       kUsePromises);
 }
 
 async function fdatasync(handle) {

src/node_file.cc

@@ -1234,25 +1234,150 @@ static void Unlink(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+int RMDirrSync(uv_loop_t* loop, uv_fs_t* req, const std::string& path,
+               uv_fs_cb cb = nullptr) {
+  FSContinuationData continuation_data(req, 0, cb);
+  continuation_data.PushPath(std::move(path));
+
+  while (continuation_data.paths.size() > 0) {
+    std::string next_path = continuation_data.PopPath();
+    int err = uv_fs_rmdir(loop, req, next_path.c_str(), nullptr);
+    switch (err) {
+      case 0:
+        if (continuation_data.paths.size() == 0) {
+          return 0;
+        }
+        break;
+      case UV_ENOTEMPTY: {
+        uv_fs_scandir(loop, req, next_path.c_str(), 0, nullptr);
+
+        uv_dirent_t entry;
+        uv_fs_scandir_next(req, &entry);
+
+        std::string dirname(next_path + '/' + entry.name);
+        if (next_path != dirname) {
+          continuation_data.PushPath(std::move(next_path));
+          continuation_data.PushPath(std::move(dirname));
+        } else if (continuation_data.paths.size() == 0) {
+          err = UV_EEXIST;
+        }
+        break;
+      }
+      case UV_ENOTDIR: {
+        uv_fs_unlink(loop, req, next_path.c_str(), nullptr);
+        break;
+      }
+      case UV_EPERM: {
+        return err;
+      }
+      default:
+        uv_fs_req_cleanup(req);
+        break;
+    }
+    uv_fs_req_cleanup(req);
+  }
+
+  return 0;
+}
+
+int RMDirrAsync(uv_loop_t* loop,
+                uv_fs_t* req,
+                const char* path,
+                uv_fs_cb cb) {
+  FSReqBase* req_wrap = FSReqBase::from_req(req);
+  // on the first iteration of algorithm, stash state information.
+  if (req_wrap->continuation_data == nullptr) {
+    req_wrap->continuation_data = std::unique_ptr<FSContinuationData>{
+      new FSContinuationData(req, 0, cb)};
+    req_wrap->continuation_data->PushPath(std::move(path));
+  }
+
+  std::string next_path = req_wrap->continuation_data->PopPath();
+  int err = uv_fs_rmdir(loop, req, next_path.c_str(),
+                        uv_fs_callback_t{[](uv_fs_t* req) {
+    FSReqBase* req_wrap = FSReqBase::from_req(req);
+    Environment* env = req_wrap->env();
+    uv_loop_t* loop = env->event_loop();
+    std::string path = req->path;
+    int err = req->result;
+    switch (err) {
+      case 0: {
+        if (req_wrap->continuation_data->paths.size() == 0) {
+          req_wrap->continuation_data->Done(0);
+        } else {
+          uv_fs_req_cleanup(req);
+          RMDirrAsync(loop, req, path.c_str(), nullptr);
+        }
+        break;
+      }
+      case UV_ENOTEMPTY: {
+        uv_fs_req_cleanup(req);
+        uv_fs_scandir(loop, req, path.c_str(), 0, nullptr);
+
+        uv_dirent_t entry;
+        uv_fs_scandir_next(req, &entry);
+
+        std::string dirname(path + '/' + entry.name);
+        if (dirname != path) {
+          req_wrap->continuation_data->PushPath(std::move(path));
+          req_wrap->continuation_data->PushPath(std::move(dirname));
+        } else if (req_wrap->continuation_data->paths.size() == 0) {
+          err = UV_EEXIST;
+          break;
+        }
+        uv_fs_req_cleanup(req);
+        RMDirrAsync(loop, req, path.c_str(), nullptr);
+        break;
+      }
+      case UV_ENOTDIR: {
+        uv_fs_req_cleanup(req);
+        uv_fs_unlink(loop, req, path.c_str(), nullptr);
+        RMDirrAsync(loop, req, path.c_str(), nullptr);
+        break;
+      }
+      case UV_EPERM: {
+        req_wrap->continuation_data->Done(err);
+        break;
+      }
+      default:
+        if (req_wrap->continuation_data->paths.size() > 0) {
+          uv_fs_req_cleanup(req);
+          RMDirrAsync(loop, req, path.c_str(), nullptr);
+        }
+        break;
+    }
+  }});
+
+  return err;
+}
+
 static void RMDir(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
   const int argc = args.Length();
-  CHECK_GE(argc, 2);
+  CHECK_GE(argc, 3);
 
   BufferValue path(env->isolate(), args[0]);
   CHECK_NOT_NULL(*path);
 
-  FSReqBase* req_wrap_async = GetReqWrap(env, args[1]);  // rmdir(path, req)
+  CHECK(args[1]->IsBoolean());
+  bool recursive = args[1]->IsTrue();
+
+  FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);  // rmdir(path, req)
   if (req_wrap_async != nullptr) {
     AsyncCall(env, req_wrap_async, args, "rmdir", UTF8, AfterNoArgs,
-              uv_fs_rmdir, *path);
+              recursive ? RMDirrAsync : uv_fs_rmdir, *path);
   } else {  // rmdir(path, undefined, ctx)
-    CHECK_EQ(argc, 3);
+    CHECK_EQ(argc, 4);
     FSReqWrapSync req_wrap_sync;
     FS_SYNC_TRACE_BEGIN(rmdir);
-    SyncCall(env, args[2], &req_wrap_sync, "rmdir",
-             uv_fs_rmdir, *path);
+    if (recursive) {
+      SyncCall(env, args[3], &req_wrap_sync, "rmdir",
+              RMDirrSync, *path);
+    } else {
+      SyncCall(env, args[3], &req_wrap_sync, "rmdir",
+              uv_fs_rmdir, *path);
+    }
     FS_SYNC_TRACE_END(rmdir);
   }
 }

test/parallel/test-fs-rmdir-recursive.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+const paramdir = path.join(tmpdir.path, 'dir');
+
+// fs.rmdir - recursive: true
+{
+  const d = path.join(tmpdir.path, 'dir', 'test_rmdir');
+  // Make sure the directory does not exist
+  assert(!fs.existsSync(d));
+  // Create the directory now
+  fs.mkdirSync(d, { recursive: true });
+  assert(fs.existsSync(d));
+  // Create files
+  fs.writeFileSync(path.join(d, 'test.txt'), 'test');
+
+  fs.rmdir(paramdir, { recursive: true }, common.mustCall((err) => {
+    assert.ifError(err);
+    assert(!fs.existsSync(d));
+  }));
+}
+
+// fs.rmdirSync - recursive: true
+{
+  const d = path.join(tmpdir.path, 'dir', 'test_rmdirSync');
+  // Make sure the directory does not exist
+  assert(!fs.existsSync(d));
+  // Create the directory now
+  fs.mkdirSync(d, { recursive: true });
+  assert(fs.existsSync(d));
+  // Create files
+  fs.writeFileSync(path.join(d, 'test.txt'), 'test');
+
+  fs.rmdirSync(paramdir, { recursive: true });
+  assert(!fs.existsSync(d));
+}
+
+// fs.promises.rmdir - recursive: true
+{
+  const d = path.join(tmpdir.path, 'dir', 'test_promises_rmdir');
+  // Make sure the directory does not exist
+  assert(!fs.existsSync(d));
+  // Create the directory now
+  fs.mkdirSync(d, { recursive: true });
+  assert(fs.existsSync(d));
+  // Create files
+  fs.writeFileSync(path.join(d, 'test.txt'), 'test');
+
+  async () => {
+    await fs.promises.rmdir(paramdir, { recursive: true });
+    assert(!fs.existsSync(d));
+  };
+}
+
+// recursive: false
+{
+  const d = path.join(tmpdir.path, 'dir', 'test_rmdir_recursive_false');
+  // Make sure the directory does not exist
+  assert(!fs.existsSync(d));
+  // Create the directory now
+  fs.mkdirSync(d, { recursive: true });
+  assert(fs.existsSync(d));
+
+  // fs.rmdir
+  fs.rmdir(paramdir, { recursive: false }, common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ENOTEMPTY');
+  }));
+
+  // fs.rmdirSync
+  common.expectsError(
+    () => fs.rmdirSync(paramdir, { recursive: false }),
+    {
+      code: 'ENOTEMPTY'
+    }
+  );
+
+  // fs.promises.rmdir
+  assert.rejects(
+    fs.promises.rmdir(paramdir, { recursive: false }),
+    {
+      code: 'ENOTEMPTY'
+    }
+  );
+}