aboutsummaryrefslogtreecommitdiff
path: root/node_modules/fs-extra/lib/remove/rimraf.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/fs-extra/lib/remove/rimraf.js')
-rw-r--r--node_modules/fs-extra/lib/remove/rimraf.js314
1 files changed, 314 insertions, 0 deletions
diff --git a/node_modules/fs-extra/lib/remove/rimraf.js b/node_modules/fs-extra/lib/remove/rimraf.js
new file mode 100644
index 0000000..f078694
--- /dev/null
+++ b/node_modules/fs-extra/lib/remove/rimraf.js
@@ -0,0 +1,314 @@
+'use strict'
+
+const fs = require('graceful-fs')
+const path = require('path')
+const assert = require('assert')
+
+const isWindows = (process.platform === 'win32')
+
+function defaults (options) {
+ const methods = [
+ 'unlink',
+ 'chmod',
+ 'stat',
+ 'lstat',
+ 'rmdir',
+ 'readdir'
+ ]
+ methods.forEach(m => {
+ options[m] = options[m] || fs[m]
+ m = m + 'Sync'
+ options[m] = options[m] || fs[m]
+ })
+
+ options.maxBusyTries = options.maxBusyTries || 3
+}
+
+function rimraf (p, options, cb) {
+ let busyTries = 0
+
+ if (typeof options === 'function') {
+ cb = options
+ options = {}
+ }
+
+ assert(p, 'rimraf: missing path')
+ assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+ assert.equal(typeof cb, 'function', 'rimraf: callback function required')
+ assert(options, 'rimraf: invalid options argument provided')
+ assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+ defaults(options)
+
+ rimraf_(p, options, function CB (er) {
+ if (er) {
+ if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
+ busyTries < options.maxBusyTries) {
+ busyTries++
+ let time = busyTries * 100
+ // try again, with the same exact callback as this one.
+ return setTimeout(() => rimraf_(p, options, CB), time)
+ }
+
+ // already gone
+ if (er.code === 'ENOENT') er = null
+ }
+
+ cb(er)
+ })
+}
+
+// Two possible strategies.
+// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong. However, there
+// are likely far more normal files in the world than directories. This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow. But until then, YAGNI.
+function rimraf_ (p, options, cb) {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
+
+ // sunos lets the root user unlink directories, which is... weird.
+ // so we have to lstat here and make sure it's not a dir.
+ options.lstat(p, (er, st) => {
+ if (er && er.code === 'ENOENT') {
+ return cb(null)
+ }
+
+ // Windows can EPERM on stat. Life is suffering.
+ if (er && er.code === 'EPERM' && isWindows) {
+ return fixWinEPERM(p, options, er, cb)
+ }
+
+ if (st && st.isDirectory()) {
+ return rmdir(p, options, er, cb)
+ }
+
+ options.unlink(p, er => {
+ if (er) {
+ if (er.code === 'ENOENT') {
+ return cb(null)
+ }
+ if (er.code === 'EPERM') {
+ return (isWindows)
+ ? fixWinEPERM(p, options, er, cb)
+ : rmdir(p, options, er, cb)
+ }
+ if (er.code === 'EISDIR') {
+ return rmdir(p, options, er, cb)
+ }
+ }
+ return cb(er)
+ })
+ })
+}
+
+function fixWinEPERM (p, options, er, cb) {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
+ if (er) {
+ assert(er instanceof Error)
+ }
+
+ options.chmod(p, 0o666, er2 => {
+ if (er2) {
+ cb(er2.code === 'ENOENT' ? null : er)
+ } else {
+ options.stat(p, (er3, stats) => {
+ if (er3) {
+ cb(er3.code === 'ENOENT' ? null : er)
+ } else if (stats.isDirectory()) {
+ rmdir(p, options, er, cb)
+ } else {
+ options.unlink(p, cb)
+ }
+ })
+ }
+ })
+}
+
+function fixWinEPERMSync (p, options, er) {
+ let stats
+
+ assert(p)
+ assert(options)
+ if (er) {
+ assert(er instanceof Error)
+ }
+
+ try {
+ options.chmodSync(p, 0o666)
+ } catch (er2) {
+ if (er2.code === 'ENOENT') {
+ return
+ } else {
+ throw er
+ }
+ }
+
+ try {
+ stats = options.statSync(p)
+ } catch (er3) {
+ if (er3.code === 'ENOENT') {
+ return
+ } else {
+ throw er
+ }
+ }
+
+ if (stats.isDirectory()) {
+ rmdirSync(p, options, er)
+ } else {
+ options.unlinkSync(p)
+ }
+}
+
+function rmdir (p, options, originalEr, cb) {
+ assert(p)
+ assert(options)
+ if (originalEr) {
+ assert(originalEr instanceof Error)
+ }
+ assert(typeof cb === 'function')
+
+ // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+ // if we guessed wrong, and it's not a directory, then
+ // raise the original error.
+ options.rmdir(p, er => {
+ if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
+ rmkids(p, options, cb)
+ } else if (er && er.code === 'ENOTDIR') {
+ cb(originalEr)
+ } else {
+ cb(er)
+ }
+ })
+}
+
+function rmkids (p, options, cb) {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
+
+ options.readdir(p, (er, files) => {
+ if (er) return cb(er)
+
+ let n = files.length
+ let errState
+
+ if (n === 0) return options.rmdir(p, cb)
+
+ files.forEach(f => {
+ rimraf(path.join(p, f), options, er => {
+ if (errState) {
+ return
+ }
+ if (er) return cb(errState = er)
+ if (--n === 0) {
+ options.rmdir(p, cb)
+ }
+ })
+ })
+ })
+}
+
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+function rimrafSync (p, options) {
+ let st
+
+ options = options || {}
+ defaults(options)
+
+ assert(p, 'rimraf: missing path')
+ assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+ assert(options, 'rimraf: missing options')
+ assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+ try {
+ st = options.lstatSync(p)
+ } catch (er) {
+ if (er.code === 'ENOENT') {
+ return
+ }
+
+ // Windows can EPERM on stat. Life is suffering.
+ if (er.code === 'EPERM' && isWindows) {
+ fixWinEPERMSync(p, options, er)
+ }
+ }
+
+ try {
+ // sunos lets the root user unlink directories, which is... weird.
+ if (st && st.isDirectory()) {
+ rmdirSync(p, options, null)
+ } else {
+ options.unlinkSync(p)
+ }
+ } catch (er) {
+ if (er.code === 'ENOENT') {
+ return
+ } else if (er.code === 'EPERM') {
+ return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+ } else if (er.code !== 'EISDIR') {
+ throw er
+ }
+ rmdirSync(p, options, er)
+ }
+}
+
+function rmdirSync (p, options, originalEr) {
+ assert(p)
+ assert(options)
+ if (originalEr) {
+ assert(originalEr instanceof Error)
+ }
+
+ try {
+ options.rmdirSync(p)
+ } catch (er) {
+ if (er.code === 'ENOTDIR') {
+ throw originalEr
+ } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
+ rmkidsSync(p, options)
+ } else if (er.code !== 'ENOENT') {
+ throw er
+ }
+ }
+}
+
+function rmkidsSync (p, options) {
+ assert(p)
+ assert(options)
+ options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
+
+ // We only end up here once we got ENOTEMPTY at least once, and
+ // at this point, we are guaranteed to have removed all the kids.
+ // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+ // try really hard to delete stuff on windows, because it has a
+ // PROFOUNDLY annoying habit of not closing handles promptly when
+ // files are deleted, resulting in spurious ENOTEMPTY errors.
+ const retries = isWindows ? 100 : 1
+ let i = 0
+ do {
+ let threw = true
+ try {
+ const ret = options.rmdirSync(p, options)
+ threw = false
+ return ret
+ } finally {
+ if (++i < retries && threw) continue // eslint-disable-line
+ }
+ } while (true)
+}
+
+module.exports = rimraf
+rimraf.sync = rimrafSync
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-06 10:20:50 +0000