pax_global_header00006660000000000000000000000064131555366720014527gustar00rootroot0000000000000052 comment=79b933fb362b2c51bedfa448be848e1d7ed32d7e rimraf-2.6.2/000077500000000000000000000000001315553667200130165ustar00rootroot00000000000000rimraf-2.6.2/.gitignore000066400000000000000000000000611315553667200150030ustar00rootroot00000000000000node_modules/ npm-debug.log .nyc_output coverage rimraf-2.6.2/.travis.yml000066400000000000000000000001251315553667200151250ustar00rootroot00000000000000sudo: false language: node_js node_js: - '0.10' - '0.12' - '4' - '5' - '6' rimraf-2.6.2/LICENSE000066400000000000000000000013751315553667200140310ustar00rootroot00000000000000The ISC License Copyright (c) Isaac Z. Schlueter and Contributors Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. rimraf-2.6.2/README.md000066400000000000000000000070201315553667200142740ustar00rootroot00000000000000[![Build Status](https://travis-ci.org/isaacs/rimraf.svg?branch=master)](https://travis-ci.org/isaacs/rimraf) [![Dependency Status](https://david-dm.org/isaacs/rimraf.svg)](https://david-dm.org/isaacs/rimraf) [![devDependency Status](https://david-dm.org/isaacs/rimraf/dev-status.svg)](https://david-dm.org/isaacs/rimraf#info=devDependencies) The [UNIX command](http://en.wikipedia.org/wiki/Rm_(Unix)) `rm -rf` for node. Install with `npm install rimraf`, or just drop rimraf.js somewhere. ## API `rimraf(f, [opts], callback)` The first parameter will be interpreted as a globbing pattern for files. If you want to disable globbing you can do so with `opts.disableGlob` (defaults to `false`). This might be handy, for instance, if you have filenames that contain globbing wildcard characters. The callback will be called with an error if there is one. Certain errors are handled for you: * Windows: `EBUSY` and `ENOTEMPTY` - rimraf will back off a maximum of `opts.maxBusyTries` times before giving up, adding 100ms of wait between each attempt. The default `maxBusyTries` is 3. * `ENOENT` - If the file doesn't exist, rimraf will return successfully, since your desired outcome is already the case. * `EMFILE` - Since `readdir` requires opening a file descriptor, it's possible to hit `EMFILE` if too many file descriptors are in use. In the sync case, there's nothing to be done for this. But in the async case, rimraf will gradually back off with timeouts up to `opts.emfileWait` ms, which defaults to 1000. ## options * unlink, chmod, stat, lstat, rmdir, readdir, unlinkSync, chmodSync, statSync, lstatSync, rmdirSync, readdirSync In order to use a custom file system library, you can override specific fs functions on the options object. If any of these functions are present on the options object, then the supplied function will be used instead of the default fs method. Sync methods are only relevant for `rimraf.sync()`, of course. For example: ```javascript var myCustomFS = require('some-custom-fs') rimraf('some-thing', myCustomFS, callback) ``` * maxBusyTries If an `EBUSY`, `ENOTEMPTY`, or `EPERM` error code is encountered on Windows systems, then rimraf will retry with a linear backoff wait of 100ms longer on each try. The default maxBusyTries is 3. Only relevant for async usage. * emfileWait If an `EMFILE` error is encountered, then rimraf will retry repeatedly with a linear backoff of 1ms longer on each try, until the timeout counter hits this max. The default limit is 1000. If you repeatedly encounter `EMFILE` errors, then consider using [graceful-fs](http://npm.im/graceful-fs) in your program. Only relevant for async usage. * glob Set to `false` to disable [glob](http://npm.im/glob) pattern matching. Set to an object to pass options to the glob module. The default glob options are `{ nosort: true, silent: true }`. Glob version 6 is used in this module. Relevant for both sync and async usage. * disableGlob Set to any non-falsey value to disable globbing entirely. (Equivalent to setting `glob: false`.) ## rimraf.sync It can remove stuff synchronously, too. But that's not so good. Use the async API. It's better. ## CLI If installed with `npm install rimraf -g` it can be used as a global command `rimraf [ ...]` which is useful for cross platform support. ## mkdirp If you need to create a directory recursively, check out [mkdirp](https://github.com/substack/node-mkdirp). rimraf-2.6.2/bin.js000077500000000000000000000022541315553667200141320ustar00rootroot00000000000000#!/usr/bin/env node var rimraf = require('./') var help = false var dashdash = false var noglob = false var args = process.argv.slice(2).filter(function(arg) { if (dashdash) return !!arg else if (arg === '--') dashdash = true else if (arg === '--no-glob' || arg === '-G') noglob = true else if (arg === '--glob' || arg === '-g') noglob = false else if (arg.match(/^(-+|\/)(h(elp)?|\?)$/)) help = true else return !!arg }) if (help || args.length === 0) { // If they didn't ask for help, then this is not a "success" var log = help ? console.log : console.error log('Usage: rimraf [ ...]') log('') log(' Deletes all files and folders at "path" recursively.') log('') log('Options:') log('') log(' -h, --help Display this usage info') log(' -G, --no-glob Do not expand glob patterns in arguments') log(' -g, --glob Expand glob patterns in arguments (default)') process.exit(help ? 0 : 1) } else go(0) function go (n) { if (n >= args.length) return var options = {} if (noglob) options = { glob: false } rimraf(args[n], options, function (er) { if (er) throw er go(n+1) }) } rimraf-2.6.2/package.json000066400000000000000000000010411315553667200153000ustar00rootroot00000000000000{ "name": "rimraf", "version": "2.6.2", "main": "rimraf.js", "description": "A deep deletion module for node (like `rm -rf`)", "author": "Isaac Z. Schlueter (http://blog.izs.me/)", "license": "ISC", "repository": "git://github.com/isaacs/rimraf.git", "scripts": { "test": "tap test/*.js" }, "bin": "./bin.js", "dependencies": { "glob": "^7.0.5" }, "files": [ "LICENSE", "README.md", "bin.js", "rimraf.js" ], "devDependencies": { "mkdirp": "^0.5.1", "tap": "^10.1.2" } } rimraf-2.6.2/rimraf.js000066400000000000000000000214421315553667200146370ustar00rootroot00000000000000module.exports = rimraf rimraf.sync = rimrafSync var assert = require("assert") var path = require("path") var fs = require("fs") var glob = require("glob") var _0666 = parseInt('666', 8) var defaultGlobOpts = { nosort: true, silent: true } // for EMFILE handling var timeout = 0 var isWindows = (process.platform === "win32") function defaults (options) { var methods = [ 'unlink', 'chmod', 'stat', 'lstat', 'rmdir', 'readdir' ] methods.forEach(function(m) { options[m] = options[m] || fs[m] m = m + 'Sync' options[m] = options[m] || fs[m] }) options.maxBusyTries = options.maxBusyTries || 3 options.emfileWait = options.emfileWait || 1000 if (options.glob === false) { options.disableGlob = true } options.disableGlob = options.disableGlob || false options.glob = options.glob || defaultGlobOpts } function rimraf (p, options, cb) { 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) var busyTries = 0 var errState = null var n = 0 if (options.disableGlob || !glob.hasMagic(p)) return afterGlob(null, [p]) options.lstat(p, function (er, stat) { if (!er) return afterGlob(null, [p]) glob(p, options.glob, afterGlob) }) function next (er) { errState = errState || er if (--n === 0) cb(errState) } function afterGlob (er, results) { if (er) return cb(er) n = results.length if (n === 0) return cb() results.forEach(function (p) { rimraf_(p, options, function CB (er) { if (er) { if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) { busyTries ++ var time = busyTries * 100 // try again, with the same exact callback as this one. return setTimeout(function () { rimraf_(p, options, CB) }, time) } // this one won't happen if graceful-fs is used. if (er.code === "EMFILE" && timeout < options.emfileWait) { return setTimeout(function () { rimraf_(p, options, CB) }, timeout ++) } // already gone if (er.code === "ENOENT") er = null } timeout = 0 next(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, function (er, st) { if (er && er.code === "ENOENT") return cb(null) // Windows can EPERM on stat. Life is suffering. if (er && er.code === "EPERM" && isWindows) fixWinEPERM(p, options, er, cb) if (st && st.isDirectory()) return rmdir(p, options, er, cb) options.unlink(p, function (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, _0666, function (er2) { if (er2) cb(er2.code === "ENOENT" ? null : er) else options.stat(p, function(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) { assert(p) assert(options) if (er) assert(er instanceof Error) try { options.chmodSync(p, _0666) } catch (er2) { if (er2.code === "ENOENT") return else throw er } try { var 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, function (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, function (er, files) { if (er) return cb(er) var n = files.length if (n === 0) return options.rmdir(p, cb) var errState files.forEach(function (f) { rimraf(path.join(p, f), options, function (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) { 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') var results if (options.disableGlob || !glob.hasMagic(p)) { results = [p] } else { try { options.lstatSync(p) results = [p] } catch (er) { results = glob.sync(p, options.glob) } } if (!results.length) return for (var i = 0; i < results.length; i++) { var p = results[i] try { var 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 if (er.code === "EPERM") return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er) 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 === "ENOENT") return if (er.code === "ENOTDIR") throw originalEr if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") rmkidsSync(p, options) } } function rmkidsSync (p, options) { assert(p) assert(options) options.readdirSync(p).forEach(function (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. var retries = isWindows ? 100 : 1 var i = 0 do { var threw = true try { var ret = options.rmdirSync(p, options) threw = false return ret } finally { if (++i < retries && threw) continue } } while (true) } rimraf-2.6.2/test/000077500000000000000000000000001315553667200137755ustar00rootroot00000000000000rimraf-2.6.2/test/basic.js000066400000000000000000000047241315553667200154230ustar00rootroot00000000000000var rimraf = require('../') var t = require('tap') var fs = require('fs') var fill = require('./fill.js') t.test('initial clean', function (t) { rimraf.sync(__dirname + '/target') t.throws(function () { fs.statSync(__dirname + '/target') }) t.end() }) t.test('sync removal', function (t) { fill() t.ok(fs.statSync(__dirname + '/target').isDirectory()) rimraf.sync(__dirname + '/target') t.throws(function () { fs.statSync(__dirname + '/target') }) t.end() }) t.test('async removal', function (t) { fill() t.ok(fs.statSync(__dirname + '/target').isDirectory()) rimraf(__dirname + '/target', function (er) { if (er) throw er t.throws(function () { fs.statSync(__dirname + '/target') }) t.end() }) }) t.test('glob', function (t) { t.plan(2) t.test('async', function (t) { fill() var glob = require('glob') var pattern = __dirname + '/target/f-*' var before = glob.sync(pattern) t.notEqual(before.length, 0) rimraf(pattern, function (er) { if (er) throw er var after = glob.sync(pattern) t.same(after, []) rimraf.sync(__dirname + '/target') t.end() }) }) t.test('sync', function (t) { fill() var glob = require('glob') var pattern = __dirname + '/target/f-*' var before = glob.sync(pattern) t.notEqual(before.length, 0) rimraf.sync(pattern) var after = glob.sync(pattern) t.same(after, []) rimraf.sync(__dirname + '/target') t.end() }) }) t.test('no glob', function (t) { t.plan(2) t.test('async', function (t) { fill() var glob = require('glob') var pattern = __dirname + '/target/f-*' var before = glob.sync(pattern) t.notEqual(before.length, 0) rimraf(pattern, { disableGlob: true }, function (er) { if (er) throw er var after = glob.sync(pattern) t.same(after, before) rimraf.sync(__dirname + '/target') t.end() }) }) t.test('sync', function (t) { fill() var glob = require('glob') var pattern = __dirname + '/target/f-*' var before = glob.sync(pattern) t.notEqual(before.length, 0) rimraf.sync(pattern, { disableGlob: true }) var after = glob.sync(pattern) t.same(after, before) rimraf.sync(__dirname + '/target') t.end() }) }) t.test('verify that cleanup happened', function (t) { t.throws(fs.statSync.bind(fs, __dirname + '/../target')) t.throws(fs.statSync.bind(fs, __dirname + '/target')) t.end() }) rimraf-2.6.2/test/custom-fs.js000066400000000000000000000070231315553667200162550ustar00rootroot00000000000000var rimraf = require('../') var fs = require('fs') var path = require('path') var t = require('tap') process.chdir(__dirname) // track that all the things happened var keepDirs = {} var intercepted = {} function intercept (method, path) { intercepted[method] = intercepted[method] || [] intercepted[method].push(path) intercepted[method] = intercepted[method].sort() intercepted._saved = intercepted._saved.sort() intercepted._removed = intercepted._removed.sort() } var expectAsync = { _removed: [ 'a', 'a/x', 'a/x/some-file.txt', 'a/y', 'a/y/some-file.txt', 'a/z', 'a/z/some-file.txt' ], _saved: [ 'a', 'a/x', 'a/x/keep.txt', 'a/y', 'a/y/keep.txt', 'a/z', 'a/z/keep.txt' ], _keepDirs: { 'a/x': true, 'a/y': true, 'a/z': true, a: true, '.': true }, rmdir: [ 'a', 'a', 'a/x', 'a/x', 'a/y', 'a/y', 'a/z', 'a/z' ], unlink: [ 'a/x/keep.txt', 'a/x/some-file.txt', 'a/y/keep.txt', 'a/y/some-file.txt', 'a/z/keep.txt', 'a/z/some-file.txt' ] } var expectSync = { _removed: [ 'a', 'a/x', 'a/x/some-file.txt', 'a/y', 'a/y/some-file.txt', 'a/z', 'a/z/some-file.txt' ], _saved: [ 'a', 'a/x', 'a/x/keep.txt', 'a/y', 'a/y/keep.txt', 'a/z', 'a/z/keep.txt' ], _keepDirs: { 'a/x': true, a: true, 'a/y': true, 'a/z': true, '.': true }, rmdirSync: [ 'a', 'a', 'a/x', 'a/x', 'a/y', 'a/y', 'a/z', 'a/z' ], unlinkSync: [ 'a/x/keep.txt', 'a/x/some-file.txt', 'a/y/keep.txt', 'a/y/some-file.txt', 'a/z/keep.txt', 'a/z/some-file.txt' ] } function shouldRemove (file) { if (file.match(/keep.txt$/) || keepDirs[file]) { // add the parent dir to keeps, to avoid ENOTEMPTY intercepted._saved.push(file) intercepted._saved = intercepted._saved.sort() keepDirs[path.dirname(file)] = true return false } else { intercepted._removed.push(file) intercepted._removed = intercepted._removed.sort() return true } } var myFs = { unlink: function (file, cb) { intercept('unlink', file) if (shouldRemove(file)) { return fs.unlink(file, cb) } else { return cb() } }, unlinkSync: function (file) { intercept('unlinkSync', file) if (shouldRemove(file)) { return fs.unlinkSync(file) } }, rmdir: function (file, cb) { intercept('rmdir', file) if (shouldRemove(file)) { return fs.rmdir(file, cb) } else { return cb() } }, rmdirSync: function (file) { intercept('rmdirSync', file) if (shouldRemove(file)) { return fs.rmdirSync(file) } } } var mkdirp = require('mkdirp') function create () { intercepted = {} intercepted._removed = [] intercepted._saved = [] intercepted._keepDirs = keepDirs = {} mkdirp.sync('a') ;['x', 'y', 'z'].forEach(function (j) { mkdirp.sync('a/' + j) fs.writeFileSync('a/' + j + '/some-file.txt', 'test\n') fs.writeFileSync('a/' + j + '/keep.txt', 'test\n') }) } t.test('setup', function (t) { create() t.end() }) t.test('rimraf with interceptor', function (t) { rimraf('a', myFs, function (er) { if (er) { throw er } t.strictSame(intercepted, expectAsync) create() t.end() }) }) t.test('rimraf sync with interceptor', function (t) { create() rimraf.sync('a', myFs) t.strictSame(intercepted, expectSync) create() t.end() }) t.test('cleanup', function (t) { rimraf.sync('a') t.throws(fs.statSync.bind(fs, 'a')) t.end() }) rimraf-2.6.2/test/fill.js000066400000000000000000000016761315553667200152730ustar00rootroot00000000000000var fs = require('fs') var mkdirp = require('mkdirp') module.exports = function () { fill(4, 10, 2, __dirname + '/target') } if (module === require.main) { require('tap').pass('yes') return } function fill (depth, files, folders, target) { mkdirp.sync(target) var o = { flag: 'wx' } if (process.version.match(/^v0\.8/)) o = 'utf8' for (var f = files; f > 0; f--) { fs.writeFileSync(target + '/f-' + depth + '-' + f, '', o) } // valid symlink fs.symlinkSync('f-' + depth + '-1', target + '/link-' + depth + '-good', 'file') // invalid symlink fs.symlinkSync('does-not-exist', target + '/link-' + depth + '-bad', 'file') // file with a name that looks like a glob fs.writeFileSync(target + '/[a-z0-9].txt', '', o) depth-- if (depth <= 0) return for (f = folders; f > 0; f--) { mkdirp.sync(target + '/folder-' + depth + '-' + f) fill(depth, files, folders, target + '/d-' + depth + '-' + f) } }