pax_global_header00006660000000000000000000000064123322034310014503gustar00rootroot0000000000000052 comment=6c9968c26e5cd90d3e14803c87aebbc94a6730e2 rimraf-2.2.8/000077500000000000000000000000001233220343100127745ustar00rootroot00000000000000rimraf-2.2.8/AUTHORS000066400000000000000000000003531233220343100140450ustar00rootroot00000000000000# Authors sorted by whether or not they're me. Isaac Z. Schlueter (http://blog.izs.me) Wayne Larsen (http://github.com/wvl) ritch Marcel Laverdet Yosef Dinerstein rimraf-2.2.8/LICENSE000066400000000000000000000021041233220343100137760ustar00rootroot00000000000000Copyright 2009, 2010, 2011 Isaac Z. Schlueter. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. rimraf-2.2.8/README.md000066400000000000000000000015101233220343100142500ustar00rootroot00000000000000`rm -rf` for node. Install with `npm install rimraf`, or just drop rimraf.js somewhere. ## API `rimraf(f, callback)` 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. * `ENOENT` - If the file doesn't exist, rimraf will return successfully, since your desired outcome is already the case. ## 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.2.8/bin.js000077500000000000000000000013501233220343100141040ustar00rootroot00000000000000#!/usr/bin/env node var rimraf = require('./') var help = false var dashdash = false var args = process.argv.slice(2).filter(function(arg) { if (dashdash) return !!arg else if (arg === '--') dashdash = true 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') process.exit(help ? 0 : 1) } else { args.forEach(function(arg) { rimraf.sync(arg) }) } rimraf-2.2.8/package.json000066400000000000000000000006671233220343100152730ustar00rootroot00000000000000{ "name": "rimraf", "version": "2.2.8", "main": "rimraf.js", "description": "A deep deletion module for node (like `rm -rf`)", "author": "Isaac Z. Schlueter (http://blog.izs.me/)", "license": { "type": "MIT", "url": "https://github.com/isaacs/rimraf/raw/master/LICENSE" }, "repository": "git://github.com/isaacs/rimraf.git", "scripts": { "test": "cd test && bash run.sh" }, "bin": "./bin.js" } rimraf-2.2.8/rimraf.js000066400000000000000000000131721233220343100146160ustar00rootroot00000000000000module.exports = rimraf rimraf.sync = rimrafSync var assert = require("assert") var path = require("path") var fs = require("fs") // for EMFILE handling var timeout = 0 exports.EMFILE_MAX = 1000 exports.BUSYTRIES_MAX = 3 var isWindows = (process.platform === "win32") function defaults (options) { var methods = [ 'unlink', 'chmod', 'stat', 'rmdir', 'readdir' ] methods.forEach(function(m) { options[m] = options[m] || fs[m] m = m + 'Sync' options[m] = options[m] || fs[m] }) } function rimraf (p, options, cb) { if (typeof options === 'function') { cb = options options = {} } assert(p) assert(options) assert(typeof cb === 'function') defaults(options) if (!cb) throw new Error("No callback passed to rimraf()") var busyTries = 0 rimraf_(p, options, function CB (er) { if (er) { if (isWindows && (er.code === "EBUSY" || er.code === "ENOTEMPTY") && busyTries < exports.BUSYTRIES_MAX) { 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 < exports.EMFILE_MAX) { return setTimeout(function () { rimraf_(p, options, CB) }, timeout ++) } // already gone if (er.code === "ENOENT") er = null } timeout = 0 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') 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, 666, 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, 666) } 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) assert(options) try { 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) }) options.rmdirSync(p, options) } rimraf-2.2.8/test/000077500000000000000000000000001233220343100137535ustar00rootroot00000000000000rimraf-2.2.8/test/run.sh000066400000000000000000000003121233220343100151070ustar00rootroot00000000000000#!/bin/bash set -e code=0 for i in test-*.js; do echo -n $i ... bash setup.sh node $i if [ -d target ]; then echo "fail" code=1 else echo "pass" fi done rm -rf target exit $code rimraf-2.2.8/test/setup.sh000066400000000000000000000011321233220343100154440ustar00rootroot00000000000000#!/bin/bash set -e files=10 folders=2 depth=4 target="$PWD/target" rm -rf target fill () { local depth=$1 local files=$2 local folders=$3 local target=$4 if ! [ -d $target ]; then mkdir -p $target fi local f f=$files while [ $f -gt 0 ]; do touch "$target/f-$depth-$f" let f-- done let depth-- if [ $depth -le 0 ]; then return 0 fi f=$folders while [ $f -gt 0 ]; do mkdir "$target/folder-$depth-$f" fill $depth $files $folders "$target/d-$depth-$f" let f-- done } fill $depth $files $folders $target # sanity assert [ -d $target ] rimraf-2.2.8/test/test-async.js000066400000000000000000000002121233220343100163760ustar00rootroot00000000000000var rimraf = require("../rimraf") , path = require("path") rimraf(path.join(__dirname, "target"), function (er) { if (er) throw er }) rimraf-2.2.8/test/test-sync.js000066400000000000000000000001511233220343100162370ustar00rootroot00000000000000var rimraf = require("../rimraf") , path = require("path") rimraf.sync(path.join(__dirname, "target"))