diff options
Diffstat (limited to 'node_modules/copy-concurrently')
| -rw-r--r-- | node_modules/copy-concurrently/LICENSE | 14 | ||||
| -rw-r--r-- | node_modules/copy-concurrently/README.md | 128 | ||||
| -rw-r--r-- | node_modules/copy-concurrently/copy.js | 225 | ||||
| -rw-r--r-- | node_modules/copy-concurrently/is-windows.js | 2 | ||||
| l--------- | node_modules/copy-concurrently/node_modules/.bin/mkdirp | 1 | ||||
| l--------- | node_modules/copy-concurrently/node_modules/.bin/rimraf | 1 | ||||
| -rw-r--r-- | node_modules/copy-concurrently/package.json | 43 |
7 files changed, 414 insertions, 0 deletions
diff --git a/node_modules/copy-concurrently/LICENSE b/node_modules/copy-concurrently/LICENSE new file mode 100644 index 00000000..83e7c4c6 --- /dev/null +++ b/node_modules/copy-concurrently/LICENSE @@ -0,0 +1,14 @@ +Copyright (c) 2017, Rebecca Turner <me@re-becca.org> + +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. + diff --git a/node_modules/copy-concurrently/README.md b/node_modules/copy-concurrently/README.md new file mode 100644 index 00000000..3f6f9742 --- /dev/null +++ b/node_modules/copy-concurrently/README.md @@ -0,0 +1,128 @@ +# copy-concurrently + +Copy files, directories and symlinks + +``` +const copy = require('copy-concurrently') +copy('/path/to/thing', '/new/path/thing').then(() => { + // this is now copied +}).catch(err => { + // oh noooo +}) +``` + +Copies files, directories and symlinks. Ownership is maintained when +running as root, permissions are always maintained. On Windows, if symlinks +are unavailable then junctions will be used. + +## PUBLIC INTERFACE + +### copy(from, to, [options]) → Promise + +Recursively copies `from` to `to` and resolves its promise when finished. +If `to` already exists then the promise will be rejected with an `EEXIST` +error. + +Options are: + +* maxConcurrency – (Default: `1`) The maximum number of concurrent copies to do at once. +* recurseWith - (Default: `copy.item`) The function to call on each file after recursing into a directory. +* isWindows - (Default: `process.platform === 'win32'`) If true enables Windows symlink semantics. This requires + an extra `stat` to determine if the destination of a symlink is a file or directory. If symlinking a directory + fails then we'll try making a junction instead. + +Options can also include dependency injection: + +* Promise - (Default: `global.Promise`) The promise implementation to use, defaults to Node's. +* fs - (Default: `require('fs')`) The filesystem module to use. Can be used + to use `graceful-fs` or to inject a mock. +* writeStreamAtomic - (Default: `require('fs-write-stream-atomic')`) The + implementation of `writeStreamAtomic` to use. Used to inject a mock. +* getuid - (Default: `process.getuid`) A function that returns the current UID. Used to inject a mock. + +## EXTENSION INTERFACE + +Ordinarily you'd only call `copy` above. But it's possible to use it's +component functions directly. This is useful if, say, you're writing +[move-concurently](https://npmjs.com/package/move-concurrently). + +### copy.file(from, to, options) → Promise + +Copies an ordinary file `from` to destination `to`. Uses +`fs-write-stream-atomic` to ensure that the file is either entirely copied +or not at all. + +Options are: + +* uid, gid - (Optional) If `getuid()` is `0` then this and gid will be used to + set the user and group of `to`. If uid is present then gid must be too. +* mode - (Optional) If set then `to` will have its perms set to `mode`. +* fs - (Default: `require('fs')`) The filesystem module to use. Can be used + to use `graceful-fs` or to inject a mock. +* Promise - (Default: `global.Promise`) The promise implementation to use, defaults to Node's. +* writeStreamAtomic - (Default `require('fs-write-stream-atomic')`) The + implementation of `writeStreamAtomic` to use. Used to inject a mock. + +### copy.symlink(from, to, options) → Promise + +Copies a symlink `from` to destination `to`. If you're using Windows and +symlinking fails and what you're linking is a directory then junctions will +be tried instead. + +Options are: + +* top - The top level the copy is being run from. This is used to determine + if the symlink destination is within the set of files we're copying or + outside it. +* fs - (Default: `require('fs')`) The filesystem module to use. Can be used + to use `graceful-fs` or to inject a mock. +* Promise - (Default: `global.Promise`) The promise implementation to use, defaults to Node's. +* isWindows - (Default: `process.platform === 'win32'`) If true enables Windows symlink semantics. This requires + an extra `stat` to determine if the destination of a symlink is a file or directory. If symlinking a directory + fails then we'll try making a junction instead. + +### copy.recurse(from, to, options) → Promise + +Reads all of the files in directory `from` and adds them to the `queue` +using `recurseWith` (by default `copy.item`). + +Options are: + +* queue - A [`run-queue`](https://npmjs.com/package/run-queue) object to add files found inside `from` to. +* recurseWith - (Default: `copy.item`) The function to call on each file after recursing into a directory. +* uid, gid - (Optional) If `getuid()` is `0` then this and gid will be used to + set the user and group of `to`. If uid is present then gid must be too. +* mode - (Optional) If set then `to` will have its perms set to `mode`. +* fs - (Default: `require('fs')`) The filesystem module to use. Can be used + to use `graceful-fs` or to inject a mock. +* getuid - (Default: `process.getuid`) A function that returns the current UID. Used to inject a mock. + +### copy.item(from, to, options) → Promise + +Copies some kind of `from` to destination `to`. This looks at the filetype +and calls `copy.file`, `copy.symlink` or `copy.recurse` as appropriate. + +Symlink copies are queued with a priority such that they happen after all +file and directory copies as you can't create a junction on windows to a +file that doesn't exist yet. + +Options are: + +* top - The top level the copy is being run from. This is used to determine + if the symlink destination is within the set of files we're copying or + outside it. +* queue - The [`run-queue`](https://npmjs.com/package/run-queue) object to + pass to `copy.recurse` if `from` is a directory. +* recurseWith - (Default: `copy.item`) The function to call on each file after recursing into a directory. +* uid, gid - (Optional) If `getuid()` is `0` then this and gid will be used to + set the user and group of `to`. If uid is present then gid must be too. +* mode - (Optional) If set then `to` will have its perms set to `mode`. +* fs - (Default: `require('fs')`) The filesystem module to use. Can be used + to use `graceful-fs` or to inject a mock. +* getuid - (Default: `process.getuid`) A function that returns the current UID. Used to inject a mock. +* isWindows - (Default: `process.platform === 'win32'`) If true enables Windows symlink semantics. This requires + an extra `stat` to determine if the destination of a symlink is a file or directory. If symlinking a directory + fails then we'll try making a junction instead. +* Promise - (Default: `global.Promise`) The promise implementation to use, defaults to Node's. +* writeStreamAtomic - (Default `require('fs-write-stream-atomic')`) The + implementation of `writeStreamAtomic` to use. Used to inject a mock. diff --git a/node_modules/copy-concurrently/copy.js b/node_modules/copy-concurrently/copy.js new file mode 100644 index 00000000..36ce9f46 --- /dev/null +++ b/node_modules/copy-concurrently/copy.js @@ -0,0 +1,225 @@ +'use strict' +module.exports = copy +module.exports.item = copyItem +module.exports.recurse = recurseDir +module.exports.symlink = copySymlink +module.exports.file = copyFile + +var nodeFs = require('fs') +var path = require('path') +var validate = require('aproba') +var stockWriteStreamAtomic = require('fs-write-stream-atomic') +var mkdirp = require('mkdirp') +var rimraf = require('rimraf') +var isWindows = require('./is-windows') +var RunQueue = require('run-queue') +var extend = Object.assign || require('util')._extend + +function promisify (Promise, fn) { + return function () { + var args = [].slice.call(arguments) + return new Promise(function (resolve, reject) { + return fn.apply(null, args.concat(function (err, value) { + if (err) { + reject(err) + } else { + resolve(value) + } + })) + }) + } +} + +function copy (from, to, opts) { + validate('SSO|SS', arguments) + opts = extend({}, opts || {}) + + var Promise = opts.Promise || global.Promise + var fs = opts.fs || nodeFs + + if (opts.isWindows == null) opts.isWindows = isWindows + if (!opts.Promise) opts.Promise = Promise + if (!opts.fs) opts.fs = fs + if (!opts.recurseWith) opts.recurseWith = copyItem + if (!opts.lstat) opts.lstat = promisify(opts.Promise, fs.lstat) + if (!opts.stat) opts.stat = promisify(opts.Promise, fs.stat) + if (!opts.chown) opts.chown = promisify(opts.Promise, fs.chown) + if (!opts.readdir) opts.readdir = promisify(opts.Promise, fs.readdir) + if (!opts.readlink) opts.readlink = promisify(opts.Promise, fs.readlink) + if (!opts.symlink) opts.symlink = promisify(opts.Promise, fs.symlink) + if (!opts.chmod) opts.chmod = promisify(opts.Promise, fs.chmod) + + opts.top = from + opts.mkdirpAsync = promisify(opts.Promise, mkdirp) + var rimrafAsync = promisify(opts.Promise, rimraf) + + var queue = new RunQueue({ + maxConcurrency: opts.maxConcurrency, + Promise: Promise + }) + opts.queue = queue + + queue.add(0, copyItem, [from, to, opts]) + + return queue.run().catch(function (err) { + // if the target already exists don't clobber it + if (err.code === 'EEXIST' || err.code === 'EPERM') { + return passThroughError() + } else { + return remove(to).then(passThroughError, passThroughError) + } + function passThroughError () { + return Promise.reject(err) + } + }) + + function remove (target) { + var opts = { + unlink: fs.unlink, + chmod: fs.chmod, + stat: fs.stat, + lstat: fs.lstat, + rmdir: fs.rmdir, + readdir: fs.readdir, + glob: false + } + return rimrafAsync(target, opts) + } +} + +function copyItem (from, to, opts) { + validate('SSO', [from, to, opts]) + var fs = opts.fs || nodeFs + var Promise = opts.Promise || global.Promise + var lstat = opts.lstat || promisify(Promise, fs.lstat) + + return lstat(to).then(function () { + return Promise.reject(eexists(from, to)) + }, function (err) { + if (err && err.code !== 'ENOENT') return Promise.reject(err) + return lstat(from) + }).then(function (fromStat) { + var cmdOpts = extend(extend({}, opts), fromStat) + if (fromStat.isDirectory()) { + return recurseDir(from, to, cmdOpts) + } else if (fromStat.isSymbolicLink()) { + opts.queue.add(1, copySymlink, [from, to, cmdOpts]) + } else if (fromStat.isFile()) { + return copyFile(from, to, cmdOpts) + } else if (fromStat.isBlockDevice()) { + return Promise.reject(eunsupported(from + " is a block device, and we don't know how to copy those.")) + } else if (fromStat.isCharacterDevice()) { + return Promise.reject(eunsupported(from + " is a character device, and we don't know how to copy those.")) + } else if (fromStat.isFIFO()) { + return Promise.reject(eunsupported(from + " is a FIFO, and we don't know how to copy those.")) + } else if (fromStat.isSocket()) { + return Promise.reject(eunsupported(from + " is a socket, and we don't know how to copy those.")) + } else { + return Promise.reject(eunsupported("We can't tell what " + from + " is and so we can't copy it.")) + } + }) +} + +function recurseDir (from, to, opts) { + validate('SSO', [from, to, opts]) + var recurseWith = opts.recurseWith || copyItem + var fs = opts.fs || nodeFs + var chown = opts.chown || promisify(Promise, fs.chown) + var readdir = opts.readdir || promisify(Promise, fs.readdir) + var mkdirpAsync = opts.mkdirpAsync || promisify(Promise, mkdirp) + + return mkdirpAsync(to, {fs: fs, mode: opts.mode}).then(function () { + var getuid = opts.getuid || process.getuid + if (getuid && opts.uid != null && getuid() === 0) { + return chown(to, opts.uid, opts.gid) + } + }).then(function () { + return readdir(from) + }).then(function (files) { + files.forEach(function (file) { + opts.queue.add(0, recurseWith, [path.join(from, file), path.join(to, file), opts]) + }) + }) +} + +function copySymlink (from, to, opts) { + validate('SSO', [from, to, opts]) + var fs = opts.fs || nodeFs + var readlink = opts.readlink || promisify(Promise, fs.readlink) + var stat = opts.stat || promisify(Promise, fs.symlink) + var symlink = opts.symlink || promisify(Promise, fs.symlink) + var Promise = opts.Promise || global.Promise + + return readlink(from).then(function (fromDest) { + var absoluteDest = path.resolve(path.dirname(from), fromDest) + // Treat absolute paths that are inside the tree we're + // copying as relative. This necessary to properly support junctions + // on windows (which are always absolute) but is also DWIM with symlinks. + var relativeDest = path.relative(opts.top, absoluteDest) + var linkFrom = relativeDest.substr(0, 2) === '..' ? fromDest : path.relative(path.dirname(from), absoluteDest) + if (opts.isWindows) { + return stat(absoluteDest).catch(function () { return null }).then(function (destStat) { + var isDir = destStat && destStat.isDirectory() + var type = isDir ? 'dir' : 'file' + return symlink(linkFrom, to, type).catch(function (err) { + if (type === 'dir') { + return symlink(linkFrom, to, 'junction') + } else { + return Promise.reject(err) + } + }) + }) + } else { + return symlink(linkFrom, to) + } + }) +} + +function copyFile (from, to, opts) { + validate('SSO', [from, to, opts]) + var fs = opts.fs || nodeFs + var writeStreamAtomic = opts.writeStreamAtomic || stockWriteStreamAtomic + var Promise = opts.Promise || global.Promise + var chmod = opts.chmod || promisify(Promise, fs.chmod) + + var writeOpts = {} + var getuid = opts.getuid || process.getuid + if (getuid && opts.uid != null && getuid() === 0) { + writeOpts.chown = { + uid: opts.uid, + gid: opts.gid + } + } + + return new Promise(function (resolve, reject) { + var errored = false + function onError (err) { + errored = true + reject(err) + } + fs.createReadStream(from) + .once('error', onError) + .pipe(writeStreamAtomic(to, writeOpts)) + .once('error', onError) + .once('close', function () { + if (errored) return + if (opts.mode != null) { + resolve(chmod(to, opts.mode)) + } else { + resolve() + } + }) + }) +} + +function eexists (from, to) { + var err = new Error('Could not move ' + from + ' to ' + to + ': destination already exists.') + err.code = 'EEXIST' + return err +} + +function eunsupported (msg) { + var err = new Error(msg) + err.code = 'EUNSUPPORTED' + return err +} diff --git a/node_modules/copy-concurrently/is-windows.js b/node_modules/copy-concurrently/is-windows.js new file mode 100644 index 00000000..8a991d54 --- /dev/null +++ b/node_modules/copy-concurrently/is-windows.js @@ -0,0 +1,2 @@ +'use strict' +module.exports = process.platform === 'win32' diff --git a/node_modules/copy-concurrently/node_modules/.bin/mkdirp b/node_modules/copy-concurrently/node_modules/.bin/mkdirp new file mode 120000 index 00000000..91a5f623 --- /dev/null +++ b/node_modules/copy-concurrently/node_modules/.bin/mkdirp @@ -0,0 +1 @@ +../../../mkdirp/bin/cmd.js
\ No newline at end of file diff --git a/node_modules/copy-concurrently/node_modules/.bin/rimraf b/node_modules/copy-concurrently/node_modules/.bin/rimraf new file mode 120000 index 00000000..632d6da2 --- /dev/null +++ b/node_modules/copy-concurrently/node_modules/.bin/rimraf @@ -0,0 +1 @@ +../../../rimraf/bin.js
\ No newline at end of file diff --git a/node_modules/copy-concurrently/package.json b/node_modules/copy-concurrently/package.json new file mode 100644 index 00000000..d0595846 --- /dev/null +++ b/node_modules/copy-concurrently/package.json @@ -0,0 +1,43 @@ +{ + "name": "copy-concurrently", + "version": "1.0.5", + "description": "Promises of copies of files, directories and symlinks, with concurrency controls and win32 junction fallback.", + "main": "copy.js", + "scripts": { + "test": "standard && tap --coverage test" + }, + "keywords": [ + "copy", + "cpr" + ], + "author": "Rebecca Turner <me@re-becca.org> (http://re-becca.org/)", + "license": "ISC", + "dependencies": { + "aproba": "^1.1.1", + "fs-write-stream-atomic": "^1.0.8", + "iferr": "^0.1.5", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.4", + "run-queue": "^1.0.0" + }, + "devDependencies": { + "standard": "^8.6.0", + "tacks": "^1.2.6", + "tap": "^10.1.1" + }, + "files": [ + "copy.js", + "is-windows.js" + ], + "directories": { + "test": "test" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/npm/copy-concurrently.git" + }, + "bugs": { + "url": "https://github.com/npm/copy-concurrently/issues" + }, + "homepage": "https://www.npmjs.com/package/copy-concurrently" +} |