node-gulp-4.0.2+~cs38.20.35/ 0000775 0000000 0000000 00000000000 14156670073 0015040 5 ustar 00root root 0000000 0000000 node-gulp-4.0.2+~cs38.20.35/.editorconfig 0000664 0000000 0000000 00000000305 14156670073 0017513 0 ustar 00root root 0000000 0000000 # http://editorconfig.org
root = true
[*]
indent_style = space
indent_size = 2
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[*.md]
trim_trailing_whitespace = false
node-gulp-4.0.2+~cs38.20.35/.eslintrc 0000664 0000000 0000000 00000000030 14156670073 0016655 0 ustar 00root root 0000000 0000000 {
"extends": "gulp"
}
node-gulp-4.0.2+~cs38.20.35/.jscsrc 0000664 0000000 0000000 00000000027 14156670073 0016327 0 ustar 00root root 0000000 0000000 {
"preset": "gulp"
}
node-gulp-4.0.2+~cs38.20.35/.travis.yml 0000664 0000000 0000000 00000000171 14156670073 0017150 0 ustar 00root root 0000000 0000000 sudo: false
language: node_js
node_js:
- '6'
- '5'
- '4'
- '0.12'
- '0.10'
after_script:
- npm run coveralls
node-gulp-4.0.2+~cs38.20.35/LICENSE 0000664 0000000 0000000 00000002142 14156670073 0016044 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2014 Blaine Bublitz, Eric Schoffstall and other contributors
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.
node-gulp-4.0.2+~cs38.20.35/README.md 0000664 0000000 0000000 00000020645 14156670073 0016326 0 ustar 00root root 0000000 0000000
# bach
[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
Compose your async functions with elegance.
## Usage
With `bach`, it is very easy to compose async functions to run in series or parallel.
```js
var bach = require('bach');
function fn1(cb) {
cb(null, 1);
}
function fn2(cb) {
cb(null, 2);
}
function fn3(cb) {
cb(null, 3);
}
var seriesFn = bach.series(fn1, fn2, fn3);
// fn1, fn2, and fn3 will be run in series
seriesFn(function(err, res) {
if (err) { // in this example, err is undefined
// handle error
}
// handle results
// in this example, res is [1, 2, 3]
});
var parallelFn = bach.parallel(fn1, fn2, fn3);
// fn1, fn2, and fn3 will be run in parallel
parallelFn(function(err, res) {
if (err) { // in this example, err is undefined
// handle error
}
// handle results
// in this example, res is [1, 2, 3]
});
```
Since the composer functions return a function, you can combine them.
```js
var combinedFn = bach.series(fn1, bach.parallel(fn2, fn3));
// fn1 will be executed before fn2 and fn3 are run in parallel
combinedFn(function(err, res) {
if (err) { // in this example, err is undefined
// handle error
}
// handle results
// in this example, res is [1, [2, 3]]
});
```
Functions are called with [async-done], so you can return a stream, promise, observable or child process. See [`async-done` completion and error resolution][completions] for more detail.
```js
// streams
var fs = require('fs');
function streamFn1() {
return fs.createReadStream('./example')
.pipe(fs.createWriteStream('./example'));
}
function streamFn2() {
return fs.createReadStream('./example')
.pipe(fs.createWriteStream('./example'));
}
var parallelStreams = bach.parallel(streamFn1, streamFn2);
parallelStreams(function(err) {
if (err) { // in this example, err is undefined
// handle error
}
// all streams have emitted an 'end' or 'close' event
});
```
```js
// promises
var when = require('when');
function promiseFn1() {
return when.resolve(1);
}
function promiseFn2() {
return when.resolve(2);
}
var parallelPromises = bach.parallel(promiseFn1, promiseFn2);
parallelPromises(function(err, res) {
if (err) { // in this example, err is undefined
// handle error
}
// handle results
// in this example, res is [1, 2]
});
```
All errors are caught in a [domain] and passed to the final callback as the first argument.
```js
function success(cb) {
setTimeout(function() {
cb(null, 1);
}, 500);
}
function error() {
throw new Error('Thrown Error');
}
var errorThrownFn = bach.parallel(error, success);
errorThrownFn(function(err, res) {
if (err) {
// handle error
// in this example, err is an error caught by the domain
}
// handle results
// in this example, res is [undefined]
});
```
When an error happens in a parallel composition, the callback will be called as soon as the error happens.
If you want to continue on error and wait until all functions have finished before calling the callback, use `settleSeries` or `settleParallel`.
```js
function success(cb) {
setTimeout(function() {
cb(null, 1);
}, 500);
}
function error(cb) {
cb(new Error('Async Error'));
}
var parallelSettlingFn = bach.settleParallel(success, error);
parallelSettlingFn(function(err, res) {
// all functions have finished executing
if (err) {
// handle error
// in this example, err is an error passed to the callback
}
// handle results
// in this example, res is [1]
});
```
## API
### `series(fns..., [extensions])`
Takes a variable amount of functions (`fns`) to be called in series when the returned function is
called. Optionally, takes an [extensions](#extensions) object as the last argument.
Returns an `invoker(cb)` function to be called to start the serial execution. The invoker function takes a callback (`cb`) with the `function(error, results)` signature.
If all functions complete successfully, the callback function will be called with all `results` as the second argument.
If an error occurs, execution will stop and the error will be passed to the callback function as the first parameter. The error parameter will always be a single error.
### `parallel(fns..., [extensions])`
Takes a variable amount of functions (`fns`) to be called in parallel when the returned function is
called. Optionally, takes an [extensions](#extensions) object as the last argument.
Returns an `invoker(cb)` function to be called to start the parallel execution. The invoker function takes a callback (`cb`) with the `function(error, results)` signature.
If all functions complete successfully, the callback function will be called with all `results` as the second argument.
If an error occurs, the callback function will be called with the error as the first parameter. Any async functions that have not completed, will still complete, but their results will __not__ be available. The error parameter will always be a single error.
### `settleSeries(fns..., [extensions])`
Takes a variable amount of functions (`fns`) to be called in series when the returned function is
called. Optionally, takes an [extensions](#extensions) object as the last argument.
Returns an `invoker(cb)` function to be called to start the serial execution. The invoker function takes a callback (`cb`) with the `function(error, results)` signature.
All functions will always be called and the callback will receive all settled errors and results. If any errors occur, the error parameter will be an array of errors.
### `settleParallel(fns..., [extensions])`
Takes a variable amount of functions (`fns`) to be called in parallel when the returned function is
called. Optionally, takes an [extensions](#extensions) object as the last argument.
Returns an `invoker(cb)` function to be called to start the parallel execution. The invoker function takes a callback (`cb`) with the `function(error, results)` signature.
All functions will always be called and the callback will receive all settled errors and results. If any errors occur, the error parameter will be an array of errors.
### `extensions`
The `extensions` object is used for specifying functions that give insight into the lifecycle of each function call. The possible extension points are `create`, `before`, `after` and `error`. If an extension point is not specified, it defaults to a no-op function.
##### `extensions.create(fn, index)`
Called at the very beginning of each function call with the function (`fn`) being executed and the `index` from the array/arguments. If `create` returns a value (`storage`), it is passed to the `before`, `after` and `error` extension points.
If a value is not returned, an empty object is used as `storage` for each other extension point.
This is useful for tracking information across an iteration.
##### `extensions.before(storage)`
Called immediately before each function call with the `storage` value returned from the `create` extension point.
##### `extensions.after(result, storage)`
Called immediately after each function call with the `result` of the function and the `storage` value returned from the `create` extension point.
##### `extensions.error(error, storage)`
Called immediately after a failed function call with the `error` of the function and the `storage` value returned from the `create` extension point.
## License
MIT
[domain]: http://nodejs.org/api/domain.html
[async-done]: https://github.com/gulpjs/async-done
[completions]: https://github.com/gulpjs/async-done#completion-and-error-resolution
[downloads-image]: http://img.shields.io/npm/dm/bach.svg
[npm-url]: https://www.npmjs.com/package/bach
[npm-image]: http://img.shields.io/npm/v/bach.svg
[travis-url]: https://travis-ci.org/gulpjs/bach
[travis-image]: http://img.shields.io/travis/gulpjs/bach.svg?label=travis-ci
[appveyor-url]: https://ci.appveyor.com/project/gulpjs/bach
[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/bach.svg?label=appveyor
[coveralls-url]: https://coveralls.io/r/gulpjs/bach
[coveralls-image]: http://img.shields.io/coveralls/gulpjs/bach.svg
[gitter-url]: https://gitter.im/gulpjs/gulp
[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg
node-gulp-4.0.2+~cs38.20.35/appveyor.yml 0000664 0000000 0000000 00000000721 14156670073 0017430 0 ustar 00root root 0000000 0000000 # http://www.appveyor.com/docs/appveyor-yml
# http://www.appveyor.com/docs/lang/nodejs-iojs
environment:
matrix:
# node.js
- nodejs_version: "0.10"
- nodejs_version: "0.12"
- nodejs_version: "4"
- nodejs_version: "5"
- nodejs_version: "6"
install:
- ps: Install-Product node $env:nodejs_version
- npm install
test_script:
- node --version
- npm --version
- cmd: npm test
build: off
# build version format
version: "{build}"
node-gulp-4.0.2+~cs38.20.35/index.js 0000664 0000000 0000000 00000000321 14156670073 0016501 0 ustar 00root root 0000000 0000000 'use strict';
module.exports = {
series: require('./lib/series'),
parallel: require('./lib/parallel'),
settleSeries: require('./lib/settleSeries'),
settleParallel: require('./lib/settleParallel'),
};
node-gulp-4.0.2+~cs38.20.35/lib/ 0000775 0000000 0000000 00000000000 14156670073 0015606 5 ustar 00root root 0000000 0000000 node-gulp-4.0.2+~cs38.20.35/lib/helpers.js 0000664 0000000 0000000 00000003226 14156670073 0017611 0 ustar 00root root 0000000 0000000 'use strict';
var assert = require('assert');
var filter = require('arr-filter');
var map = require('arr-map');
var flatten = require('arr-flatten');
var forEach = require('array-each');
function noop() {}
function getExtensions(lastArg) {
if (typeof lastArg !== 'function') {
return lastArg;
}
}
function filterSuccess(elem) {
return elem.state === 'success';
}
function filterError(elem) {
return elem.state === 'error';
}
function buildOnSettled(done) {
if (typeof done !== 'function') {
done = noop;
}
function onSettled(error, result) {
if (error) {
return done(error, null);
}
var settledErrors = filter(result, filterError);
var settledResults = filter(result, filterSuccess);
var errors = null;
if (settledErrors.length) {
errors = map(settledErrors, 'value');
}
var results = null;
if (settledResults.length) {
results = map(settledResults, 'value');
}
done(errors, results);
}
return onSettled;
}
function verifyArguments(args) {
args = flatten(args);
var lastIdx = args.length - 1;
assert.ok(args.length, 'A set of functions to combine is required');
forEach(args, function(arg, argIdx) {
var isFunction = typeof arg === 'function';
if (isFunction) {
return;
}
if (argIdx === lastIdx) {
// Last arg can be an object of extension points
return;
}
var msg = 'Only functions can be combined, got ' + typeof arg +
' for argument ' + argIdx;
assert.ok(isFunction, msg);
});
return args;
}
module.exports = {
getExtensions: getExtensions,
onSettled: buildOnSettled,
verifyArguments: verifyArguments,
};
node-gulp-4.0.2+~cs38.20.35/lib/parallel.js 0000664 0000000 0000000 00000001127 14156670073 0017741 0 ustar 00root root 0000000 0000000 'use strict';
var initial = require('array-initial');
var last = require('array-last');
var asyncDone = require('async-done');
var nowAndLater = require('now-and-later');
var helpers = require('./helpers');
function iterator(fn, key, cb) {
return asyncDone(fn, cb);
}
function buildParallel() {
var args = helpers.verifyArguments(arguments);
var extensions = helpers.getExtensions(last(args));
if (extensions) {
args = initial(args);
}
function parallel(done) {
nowAndLater.map(args, iterator, extensions, done);
}
return parallel;
}
module.exports = buildParallel;
node-gulp-4.0.2+~cs38.20.35/lib/series.js 0000664 0000000 0000000 00000001125 14156670073 0017435 0 ustar 00root root 0000000 0000000 'use strict';
var initial = require('array-initial');
var last = require('array-last');
var asyncDone = require('async-done');
var nowAndLater = require('now-and-later');
var helpers = require('./helpers');
function iterator(fn, key, cb) {
return asyncDone(fn, cb);
}
function buildSeries() {
var args = helpers.verifyArguments(arguments);
var extensions = helpers.getExtensions(last(args));
if (extensions) {
args = initial(args);
}
function series(done) {
nowAndLater.mapSeries(args, iterator, extensions, done);
}
return series;
}
module.exports = buildSeries;
node-gulp-4.0.2+~cs38.20.35/lib/settleParallel.js 0000664 0000000 0000000 00000001247 14156670073 0021125 0 ustar 00root root 0000000 0000000 'use strict';
var initial = require('array-initial');
var last = require('array-last');
var asyncSettle = require('async-settle');
var nowAndLater = require('now-and-later');
var helpers = require('./helpers');
function iterator(fn, key, cb) {
return asyncSettle(fn, cb);
}
function buildSettleParallel() {
var args = helpers.verifyArguments(arguments);
var extensions = helpers.getExtensions(last(args));
if (extensions) {
args = initial(args);
}
function settleParallel(done) {
var onSettled = helpers.onSettled(done);
nowAndLater.map(args, iterator, extensions, onSettled);
}
return settleParallel;
}
module.exports = buildSettleParallel;
node-gulp-4.0.2+~cs38.20.35/lib/settleSeries.js 0000664 0000000 0000000 00000001245 14156670073 0020621 0 ustar 00root root 0000000 0000000 'use strict';
var initial = require('array-initial');
var last = require('array-last');
var asyncSettle = require('async-settle');
var nowAndLater = require('now-and-later');
var helpers = require('./helpers');
function iterator(fn, key, cb) {
return asyncSettle(fn, cb);
}
function buildSettleSeries() {
var args = helpers.verifyArguments(arguments);
var extensions = helpers.getExtensions(last(args));
if (extensions) {
args = initial(args);
}
function settleSeries(done) {
var onSettled = helpers.onSettled(done);
nowAndLater.mapSeries(args, iterator, extensions, onSettled);
}
return settleSeries;
}
module.exports = buildSettleSeries;
node-gulp-4.0.2+~cs38.20.35/package.json 0000664 0000000 0000000 00000003302 14156670073 0017324 0 ustar 00root root 0000000 0000000 {
"name": "bach",
"version": "1.2.0",
"description": "Compose your async functions with elegance.",
"author": "Gulp Team (http://gulpjs.com/)",
"contributors": [
"Blaine Bublitz ",
"Pawel Kozlowski ",
"Benjamin Tan "
],
"repository": "gulpjs/bach",
"license": "MIT",
"engines": {
"node": ">= 0.10"
},
"main": "index.js",
"files": [
"index.js",
"lib",
"LICENSE"
],
"scripts": {
"lint": "eslint . && jscs index.js lib/ test/",
"pretest": "npm run lint",
"test": "mocha --async-only",
"cover": "istanbul cover _mocha --report lcovonly",
"coveralls": "npm run cover && istanbul-coveralls"
},
"dependencies": {
"arr-filter": "^1.1.1",
"arr-flatten": "^1.0.1",
"arr-map": "^2.0.0",
"array-each": "^1.0.0",
"array-initial": "^1.0.0",
"array-last": "^1.1.1",
"async-done": "^1.2.2",
"async-settle": "^1.0.0",
"now-and-later": "^2.0.0"
},
"devDependencies": {
"eslint": "^1.7.3",
"eslint-config-gulp": "^2.0.0",
"expect": "^1.19.0",
"istanbul": "^0.4.3",
"istanbul-coveralls": "^1.0.3",
"jscs": "^2.3.5",
"jscs-preset-gulp": "^1.0.0",
"mocha": "^2.4.5"
},
"keywords": [
"compose",
"fluent",
"composing",
"continuation",
"function composition",
"functional",
"async",
"map",
"series",
"parallel",
"extension",
"tracing",
"debug",
"timing",
"aop",
"settle",
"promises",
"callbacks",
"observables",
"streams",
"end",
"completion",
"complete",
"finish",
"done",
"error handling"
]
}
node-gulp-4.0.2+~cs38.20.35/test/ 0000775 0000000 0000000 00000000000 14156670073 0016017 5 ustar 00root root 0000000 0000000 node-gulp-4.0.2+~cs38.20.35/test/.eslintrc 0000664 0000000 0000000 00000000035 14156670073 0017641 0 ustar 00root root 0000000 0000000 {
"extends": "gulp/test"
}
node-gulp-4.0.2+~cs38.20.35/test/getExtensions.js 0000664 0000000 0000000 00000000741 14156670073 0021216 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var getExtensions = require('../lib/helpers').getExtensions;
describe('getExtensions', function() {
it('should return the argument if it is an object', function(done) {
var obj = {};
expect(getExtensions(obj)).toEqual(obj);
done();
});
it('should return undefined if argument is not an object', function(done) {
var fn = function() {};
expect(getExtensions(fn)).toEqual(undefined);
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/onSettled.js 0000664 0000000 0000000 00000001665 14156670073 0020326 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var onSettled = require('../lib/helpers').onSettled;
var errors = [
{ state: 'error', value: new Error('Error 1') },
{ state: 'error', value: new Error('Error 2') },
];
describe('onSettled', function() {
it('should group all errors', function(done) {
onSettled(function(errs, results) {
expect(errs.length).toEqual(2);
expect(results).toEqual(null);
done();
})(null, errors);
});
it('should error early if called with an error', function(done) {
onSettled(function(err, results) {
expect(err).toBeAn(Error);
expect(results).toEqual(null);
done();
})(new Error('Should not happen'));
});
it('should handle the no callback case', function(done) {
onSettled()(null, errors);
done();
});
it('should handle non-functions as callbacks', function(done) {
onSettled('not a function')(null, errors);
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/parallel.js 0000664 0000000 0000000 00000003121 14156670073 0020146 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var bach = require('../');
function fn1(done) {
done(null, 1);
}
function fn2(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
function fn3(done) {
done(null, 3);
}
function fnError(done) {
done(new Error('An Error Occurred'));
}
describe('parallel', function() {
it('should execute functions in parallel, passing results', function(done) {
bach.parallel(fn1, fn2, fn3)(function(error, results) {
expect(error).toEqual(null);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should execute functions in parallel, passing error', function(done) {
function slowFn(done) {
setTimeout(function() {
expect('slow function should not be called').toEqual(undefined);
done(null, 2);
}, 500);
}
bach.parallel(fn1, slowFn, fn3, fnError)(function(error, results) {
expect(error).toBeAn(Error);
expect(results).toEqual([1, undefined, 3, undefined]);
done();
});
});
it('should take extension points and call them for each function', function(done) {
var arr = [];
var fns = [fn1, fn2, fn3];
bach.parallel(fn1, fn2, fn3, {
create: function(fn, idx) {
expect(fns).toInclude(fn);
arr[idx] = fn;
return arr;
},
before: function(storage) {
expect(storage).toEqual(arr);
},
after: function(result, storage) {
expect(storage).toEqual(arr);
},
})(function(error) {
expect(error).toEqual(null);
expect(arr).toEqual(fns);
});
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/series.js 0000664 0000000 0000000 00000002764 14156670073 0017660 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var bach = require('../');
function fn1(done) {
done(null, 1);
}
function fn2(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
function fn3(done) {
done(null, 3);
}
function fnError(done) {
done(new Error('An Error Occurred'));
}
describe('series', function() {
it('should execute functions in series, passing results', function(done) {
bach.series(fn1, fn2, fn3)(function(error, results) {
expect(error).toEqual(null);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should execute functions in series, passing error', function(done) {
function slowFn(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
bach.series(fn1, slowFn, fn3, fnError)(function(error, results) {
expect(error).toBeAn(Error);
expect(results).toEqual([1, 2, 3, undefined]);
done();
});
});
it('should take extension points and call them for each function', function(done) {
var arr = [];
var fns = [fn1, fn2, fn3];
bach.series(fn1, fn2, fn3, {
create: function(fn, idx) {
expect(fns).toInclude(fn);
arr[idx] = fn;
return arr;
},
before: function(storage) {
expect(storage).toEqual(arr);
},
after: function(result, storage) {
expect(storage).toEqual(arr);
},
})(function(error) {
expect(error).toEqual(null);
expect(arr).toEqual(fns);
});
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/settleParallel.js 0000664 0000000 0000000 00000003125 14156670073 0021333 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var bach = require('../');
function fn1(done) {
done(null, 1);
}
function fn2(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
function fn3(done) {
done(null, 3);
}
function fnError(done) {
done(new Error('An Error Occurred'));
}
describe('settleParallel', function() {
it('should execute functions in parallel, passing settled results', function(done) {
bach.settleParallel(fn1, fn2, fn3)(function(errors, results) {
expect(errors).toEqual(null);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should execute functions in parallel, passing settled errors and results', function(done) {
function slowFn(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
bach.settleParallel(fn1, slowFn, fn3, fnError)(function(errors, results) {
expect(errors).toBeAn(Array);
expect(errors[0]).toBeAn(Error);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should take extension points and call them for each function', function(done) {
var arr = [];
var fns = [fn1, fn2, fn3];
bach.settleParallel(fn1, fn2, fn3, {
create: function(fn, idx) {
expect(fns).toInclude(fn);
arr[idx] = fn;
return arr;
},
before: function(storage) {
expect(storage).toEqual(arr);
},
after: function(result, storage) {
expect(storage).toEqual(arr);
},
})(function(error) {
expect(error).toEqual(null);
expect(arr).toEqual(fns);
});
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/settleSeries.js 0000664 0000000 0000000 00000003111 14156670073 0021024 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var bach = require('../');
function fn1(done) {
done(null, 1);
}
function fn2(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
function fn3(done) {
done(null, 3);
}
function fnError(done) {
done(new Error('An Error Occurred'));
}
describe('settleSeries', function() {
it('should execute functions in series, passing settled results', function(done) {
bach.settleSeries(fn1, fn2, fn3)(function(errors, results) {
expect(errors).toEqual(null);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should execute functions in series, passing settled errors and results', function(done) {
function slowFn(done) {
setTimeout(function() {
done(null, 2);
}, 500);
}
bach.settleSeries(fn1, slowFn, fn3, fnError)(function(errors, results) {
expect(errors).toBeAn(Array);
expect(errors[0]).toBeAn(Error);
expect(results).toEqual([1, 2, 3]);
done();
});
});
it('should take extension points and call them for each function', function(done) {
var arr = [];
var fns = [fn1, fn2, fn3];
bach.settleSeries(fn1, fn2, fn3, {
create: function(fn, idx) {
expect(fns).toInclude(fn);
arr[idx] = fn;
return arr;
},
before: function(storage) {
expect(storage).toEqual(arr);
},
after: function(result, storage) {
expect(storage).toEqual(arr);
},
})(function(error) {
expect(error).toEqual(null);
expect(arr).toEqual(fns);
});
done();
});
});
node-gulp-4.0.2+~cs38.20.35/test/verifyArguments.js 0000664 0000000 0000000 00000001574 14156670073 0021556 0 ustar 00root root 0000000 0000000 'use strict';
var expect = require('expect');
var verifyArguments = require('../lib/helpers').verifyArguments;
function validArg() {}
describe('verifyArguments', function() {
it('should act as pass-through for a valid set of arguments', function(done) {
var args = [validArg, validArg];
expect(verifyArguments(args)).toEqual(args);
done();
});
it('should throw descriptive error message on invalid argument', function(done) {
function invalid() {
verifyArguments([validArg, 'invalid', validArg]);
}
expect(invalid).toThrow('Only functions can be combined, got string for argument 1');
done();
});
it('should throw descriptive error message on when no arguments provided', function(done) {
function empty() {
verifyArguments([]);
}
expect(empty).toThrow('A set of functions to combine is required');
done();
});
});