diff options
Diffstat (limited to 'deps/npm/node_modules/copy-concurrently')
13 files changed, 674 insertions, 0 deletions
diff --git a/deps/npm/node_modules/copy-concurrently/LICENSE b/deps/npm/node_modules/copy-concurrently/LICENSE new file mode 100644 index 0000000000..e0040f6659 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/LICENSE @@ -0,0 +1,13 @@ +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/deps/npm/node_modules/copy-concurrently/README.md b/deps/npm/node_modules/copy-concurrently/README.md new file mode 100644 index 0000000000..e27b016d72 --- /dev/null +++ b/deps/npm/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/deps/npm/node_modules/copy-concurrently/copy.js b/deps/npm/node_modules/copy-concurrently/copy.js new file mode 100644 index 0000000000..36ce9f46fb --- /dev/null +++ b/deps/npm/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/deps/npm/node_modules/copy-concurrently/is-windows.js b/deps/npm/node_modules/copy-concurrently/is-windows.js new file mode 100644 index 0000000000..8a991d54f5 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/is-windows.js @@ -0,0 +1,2 @@ +'use strict' +module.exports = process.platform === 'win32' diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/.npmignore b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/.npmignore new file mode 100644 index 0000000000..3c3629e647 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/.npmignore @@ -0,0 +1 @@ +node_modules diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/LICENSE b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/LICENSE new file mode 100644 index 0000000000..19d5f4bce5 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Nadav Ivgi + +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.
\ No newline at end of file diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/README.md b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/README.md new file mode 100644 index 0000000000..0940763fa9 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/README.md @@ -0,0 +1,40 @@ +# iferr + +Higher-order functions for easier error handling. + +`if (err) return cb(err);` be gone! + +## Install +```bash +npm install iferr +``` + +## Use + +### JavaScript example +```js +var iferr = require('iferr'); + +function get_friends_count(id, cb) { + User.load_user(id, iferr(cb, function(user) { + user.load_friends(iferr(cb, function(friends) { + cb(null, friends.length); + })); + })); +} +``` + +### CoffeeScript example +```coffee +iferr = require 'iferr' + +get_friends_count = (id, cb) -> + User.load_user id, iferr cb, (user) -> + user.load_friends iferr cb, (friends) -> + cb null, friends.length +``` + +(TODO: document tiferr, throwerr and printerr) + +## License +MIT diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.coffee b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.coffee new file mode 100644 index 0000000000..da6d00719f --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.coffee @@ -0,0 +1,24 @@ +# Delegates to `succ` on sucecss or to `fail` on error +# ex: Thing.load 123, iferr cb, (thing) -> ... +iferr = (fail, succ) -> (err, a...) -> + if err? then fail err + else succ? a... + +# Like iferr, but also catches errors thrown from `succ` and passes to `fail` +tiferr = (fail, succ) -> iferr fail, (a...) -> + try succ a... + catch err then fail err + +# Delegate to the success function on success, or throw the error otherwise +# ex: Thing.load 123, throwerr (thing) -> ... +throwerr = iferr.bind null, (err) -> throw err + +# Prints errors when one is passed, or does nothing otherwise +# ex: thing.save printerr +printerr = iferr (err) -> console.error err.stack or err + +module.exports = exports = iferr +exports.iferr = iferr +exports.tiferr = tiferr +exports.throwerr = throwerr +exports.printerr = printerr diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.js b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.js new file mode 100644 index 0000000000..78fce3d2b0 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/index.js @@ -0,0 +1,49 @@ +// Generated by CoffeeScript 1.7.1 +(function() { + var exports, iferr, printerr, throwerr, tiferr, + __slice = [].slice; + + iferr = function(fail, succ) { + return function() { + var a, err; + err = arguments[0], a = 2 <= arguments.length ? __slice.call(arguments, 1) : []; + if (err != null) { + return fail(err); + } else { + return typeof succ === "function" ? succ.apply(null, a) : void 0; + } + }; + }; + + tiferr = function(fail, succ) { + return iferr(fail, function() { + var a, err; + a = 1 <= arguments.length ? __slice.call(arguments, 0) : []; + try { + return succ.apply(null, a); + } catch (_error) { + err = _error; + return fail(err); + } + }); + }; + + throwerr = iferr.bind(null, function(err) { + throw err; + }); + + printerr = iferr(function(err) { + return console.error(err.stack || err); + }); + + module.exports = exports = iferr; + + exports.iferr = iferr; + + exports.tiferr = tiferr; + + exports.throwerr = throwerr; + + exports.printerr = printerr; + +}).call(this); diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/package.json b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/package.json new file mode 100644 index 0000000000..3dfa53fe63 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/package.json @@ -0,0 +1,55 @@ +{ + "_from": "iferr@^0.1.5", + "_id": "iferr@0.1.5", + "_inBundle": false, + "_integrity": "sha1-xg7taebY/bazEEofy8ocGS3FtQE=", + "_location": "/copy-concurrently/iferr", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "iferr@^0.1.5", + "name": "iferr", + "escapedName": "iferr", + "rawSpec": "^0.1.5", + "saveSpec": null, + "fetchSpec": "^0.1.5" + }, + "_requiredBy": [ + "/copy-concurrently" + ], + "_resolved": "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz", + "_shasum": "c60eed69e6d8fdb6b3104a1fcbca1c192dc5b501", + "_spec": "iferr@^0.1.5", + "_where": "/Users/rebecca/code/npm/node_modules/copy-concurrently", + "author": { + "name": "Nadav Ivgi" + }, + "bugs": { + "url": "https://github.com/shesek/iferr/issues" + }, + "bundleDependencies": false, + "deprecated": false, + "description": "Higher-order functions for easier error handling", + "devDependencies": { + "coffee-script": "^1.7.1", + "mocha": "^1.18.2" + }, + "homepage": "https://github.com/shesek/iferr", + "keywords": [ + "error", + "errors" + ], + "license": "MIT", + "main": "index.js", + "name": "iferr", + "repository": { + "type": "git", + "url": "git+https://github.com/shesek/iferr.git" + }, + "scripts": { + "prepublish": "coffee -c index.coffee", + "test": "mocha" + }, + "version": "0.1.5" +} diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/index.coffee b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/index.coffee new file mode 100644 index 0000000000..be0bc56fdf --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/index.coffee @@ -0,0 +1,42 @@ +{ iferr, tiferr, throwerr } = require '../index.coffee' +{ equal: eq, throws } = require 'assert' + +invoke_fail = (cb) -> cb new Error 'callback error' +invoke_succ = (cb) -> cb null +throw_error = -> throw new Error 'thrown' + +describe 'iferr', -> + it 'calls the error callback on errors', (done) -> + invoke_fail iferr( + (err) -> + eq err.message, 'callback error' + do done + -> + done new Error 'shouldn\'t call the success callback' + ) + + it 'calls the success callback on success', (done) -> + invoke_succ iferr( + -> done new Error 'shouldn\'t call the error callback' + done + ) + +describe 'tiferr', -> + it 'catches errors in the success callback', (done) -> + invoke_succ tiferr( + (err) -> + eq err.message, 'thrown' + do done + throw_error + ) + +describe 'throwerr', -> + it 'throws errors passed to the callback', (done)-> + try invoke_fail throwerr -> + done 'shouldn\'t call the success callback' + catch err + eq err.message, 'callback error' + do done + + it 'delegates to the success callback otherwise', (done) -> + invoke_succ throwerr done diff --git a/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/mocha.opts b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/mocha.opts new file mode 100644 index 0000000000..019defcf15 --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/node_modules/iferr/test/mocha.opts @@ -0,0 +1,2 @@ +--compilers coffee:coffee-script/register +--reporter spec diff --git a/deps/npm/node_modules/copy-concurrently/package.json b/deps/npm/node_modules/copy-concurrently/package.json new file mode 100644 index 0000000000..5a89b02e7f --- /dev/null +++ b/deps/npm/node_modules/copy-concurrently/package.json @@ -0,0 +1,72 @@ +{ + "_from": "copy-concurrently@^1.0.0", + "_id": "copy-concurrently@1.0.5", + "_inBundle": false, + "_integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==", + "_location": "/copy-concurrently", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "copy-concurrently@^1.0.0", + "name": "copy-concurrently", + "escapedName": "copy-concurrently", + "rawSpec": "^1.0.0", + "saveSpec": null, + "fetchSpec": "^1.0.0" + }, + "_requiredBy": [ + "/move-concurrently" + ], + "_resolved": "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz", + "_shasum": "92297398cae34937fcafd6ec8139c18051f0b5e0", + "_spec": "copy-concurrently@^1.0.0", + "_where": "/Users/rebecca/code/npm/node_modules/move-concurrently", + "author": { + "name": "Rebecca Turner", + "email": "me@re-becca.org", + "url": "http://re-becca.org/" + }, + "bugs": { + "url": "https://github.com/npm/copy-concurrently/issues" + }, + "bundleDependencies": false, + "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" + }, + "deprecated": false, + "description": "Promises of copies of files, directories and symlinks, with concurrency controls and win32 junction fallback.", + "devDependencies": { + "standard": "^8.6.0", + "tacks": "^1.2.6", + "tap": "^10.1.1" + }, + "directories": { + "test": "test" + }, + "files": [ + "copy.js", + "is-windows.js" + ], + "homepage": "https://www.npmjs.com/package/copy-concurrently", + "keywords": [ + "copy", + "cpr" + ], + "license": "ISC", + "main": "copy.js", + "name": "copy-concurrently", + "repository": { + "type": "git", + "url": "git+https://github.com/npm/copy-concurrently.git" + }, + "scripts": { + "test": "standard && tap --coverage test" + }, + "version": "1.0.5" +} |