pasync - npm Package Compare versions

Comparing version 0.1.0 to 0.2.0

lib/index.js

@@ -30,2 +30,4 @@ var async = require('neo-async');
 
+		var args = Array.prototype.slice.call(arguments, 0);
+
 		var handleError = function(err) {
@@ -45,7 +47,7 @@ if(!err) {
 		if(iteratorCallbackPos >= 0) {
-			iteratorCallback = arguments[iteratorCallbackPos];
+			iteratorCallback = args[iteratorCallbackPos];
 		} else {
-			for(var i = 0; i < arguments.length; i++) {
-				if(typeof arguments[i] === 'function') {
-					iteratorCallback = arguments[i];
+			for(var i = 0; i < args.length; i++) {
+				if(typeof args[i] === 'function') {
+					iteratorCallback = args[i];
 				}
@@ -55,7 +57,7 @@ }
 		// Install a function in the iterator callback's place to avoid accidental misuse
-		arguments[iteratorCallbackPos] = throwIteratorMisuseError;
+		args[iteratorCallbackPos] = throwIteratorMisuseError;
 		// iteratorResult can either be a promise or a value
 		var iteratorResult;
 		try {
-			iteratorResult = promiseIterator.apply(this, arguments);
+			iteratorResult = promiseIterator.apply(this, args);
 		} catch (ex) {
@@ -81,2 +83,7 @@ // Treat exceptions as promise rejections
 				handleError(err);
+			}).catch(function(err) {
+				// Throw error in global
+				setImmediate(function() {
+					throw err;
+				});
 			});
@@ -236,1 +243,239 @@ } else {
 exports.waterfall = convertTaskFunction(async.waterfall, 0, -1, 1, true);
+
+// Misc Functions
+
+exports.compose = function() {
+	var promiseFns = Array.prototype.slice.call(arguments, 0);
+	var callbackFns = promiseFns.map(function(promiseFn) {
+		return constructIterator(promiseFn, 1, true, false);
+	});
+	var resultCallbackFn = async.compose.apply(async, callbackFns);
+	return function(arg) {
+		var self = this;
+		return new Promise(function(resolve, reject)  {
+			resultCallbackFn.call(self, arg, function(err, result) {
+				if(err) {
+					reject(err);
+				} else {
+					resolve(result);
+				}
+			});
+		});
+	};
+};
+
+exports.seq = function() {
+	var promiseFns = Array.prototype.slice.call(arguments, 0);
+	promiseFns.reverse();
+	return exports.compose.apply(exports, promiseFns);
+};
+
+exports.applyEach = function() {
+	var promiseFns = arguments[0];
+	var callback = arguments[arguments.length - 1];
+	var fnArgs = Array.prototype.slice.call(arguments, 1);
+	var callbackFns = promiseFns.map(function(promiseFn) {
+		return constructIterator(promiseFn, fnArgs.length, false, false);
+	});
+	return new Promise(function(resolve, reject) {
+		async.applyEach.apply(async, [callbackFns].concat(fnArgs).concat([function(err) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve();
+			}
+		}]));
+	});
+};
+
+exports.applyEachSeries = function() {
+	var promiseFns = arguments[0];
+	var callback = arguments[arguments.length - 1];
+	var fnArgs = Array.prototype.slice.call(arguments, 1);
+	var callbackFns = promiseFns.map(function(promiseFn) {
+		return constructIterator(promiseFn, fnArgs.length, false, false);
+	});
+	return new Promise(function(resolve, reject) {
+		async.applyEachSeries.apply(async, [callbackFns].concat(fnArgs).concat([function(err) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve();
+			}
+		}]));
+	});
+};
+
+exports.queue = function(promiseWorker, concurrency) {
+	var callbackWorker = constructIterator(promiseWorker, 1, false, false);
+	var queue = async.queue(callbackWorker, concurrency);
+	var origPush = queue.push;
+	var origUnshift = queue.unshift;
+	queue.push = function(task) {
+		return new Promise(function(resolve, reject) {
+			origPush.call(queue, task, function(err) {
+				if(err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	};
+	queue.unshift = function(task) {
+		return new Promise(function(resolve, reject) {
+			origUnshift.call(queue, task, function(err) {
+				if(err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	};
+	return queue;
+};
+
+exports.priorityQueue = function(promiseWorker, concurrency) {
+	var callbackWorker = constructIterator(promiseWorker, 1, false, false);
+	var priorityQueue = async.priorityQueue(callbackWorker, concurrency);
+	var origPush = priorityQueue.push;
+	priorityQueue.push = function(task, priority) {
+		return new Promise(function(resolve, reject) {
+			origPush.call(priorityQueue, task, priority, function(err) {
+				if(err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	};
+	return priorityQueue;
+};
+
+exports.cargo = function(promiseWorker, payload) {
+	var callbackWorker = constructIterator(promiseWorker, 1, false, false);
+	var cargo = async.cargo(callbackWorker, payload);
+	var origPush = cargo.push;
+	cargo.push = function(task) {
+		return new Promise(function(resolve, reject) {
+			origPush.call(cargo, task, function(err) {
+				if(err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	};
+	return cargo;
+};
+
+exports.auto = function(tasks) {
+	var keys = Object.keys(tasks);
+	keys.forEach(function(task) {
+		var promiseFn;
+		var callbackFn = function(cb, results) {
+			var promiseFnResult;
+			try {
+				promiseFnResult = promiseFn.call(this, results);
+			} catch(ex) {
+				cb(ex);
+				return;
+			}
+			if(promiseFnResult && typeof promiseFnResult.then === 'function') {
+				promiseFnResult.then(function(value) {
+					cb(null, value);
+				}, function(err) {
+					cb(err, null);
+				}).catch(function(err) {
+					setImmediate(function() {
+						throw err;
+					});
+				});
+			} else {
+				cb(null, promiseFnResult);
+			}
+		};
+		if(Array.isArray(tasks[task])) {
+			promiseFn = tasks[task][tasks[task].length - 1];
+			tasks[task][tasks[task].length - 1] = callbackFn;
+		} else {
+			promiseFn = tasks[task];
+			tasks[task] = callbackFn;
+		}
+	});
+
+	return new Promise(function(resolve, reject) {
+		async.auto.call(async, tasks, function(err, result) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve(result);
+			}
+		});
+	});
+};
+
+exports.retry = function(times, task) {
+	callbackTask = constructIterator(task, 0, true, false);
+	return new Promise(function(resolve, reject) {
+		async.retry(times, callbackTask, function(err, result) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve(result);
+			}
+		});
+	});
+};
+
+exports.nextTick = function(fn) {
+	if(fn && typeof fn === 'function') {
+		return async.nextTick(fn);
+	} else {
+		return new Promise(function(resolve) {
+			async.nextTick(resolve);
+		});
+	}
+};
+
+exports.times = function(times, task) {
+	var callbackTask = constructIterator(task, 1, false, false);
+	return new Promise(function(resolve, reject) {
+		async.times(times, callbackTask, function(err, result) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve(result);
+			}
+		});
+	});
+};
+
+exports.timesSeries = function(times, task) {
+	var callbackTask = constructIterator(task, 1, false, false);
+	return new Promise(function(resolve, reject) {
+		async.timesSeries(times, callbackTask, function(err, result) {
+			if(err) {
+				reject(err);
+			} else {
+				resolve(result);
+			}
+		});
+	});
+};
+
+// Neo-Async Functions
+// fn, iteratorPos, iteratorCallbackPos, callbackPos, iteratorProvidesValue, noErrors
+exports.mapValues = convertIteratorFunction(async.mapValues, 1, 1, 2, true, false);
+exports.mapValuesSeries = convertIteratorFunction(async.mapValuesSeries, 1, 1, 2, true, false);
+
+// New Helper Functions
+exports.abort = function(err) {
+	exports.nextTick(function() {
+		throw err;
+	});
+};
+

package.json

 {
   "name": "pasync",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Promise-oriented async",
@@ -5,0 +5,0 @@ "main": "./lib/index.js",

README.md

 # pasync
 
-Version of async that uses promises instead of callbacks.
+Version of async that uses promises instead of callbacks.  Also includes other asynchronous
+promise utilities.
 
@@ -61,3 +62,47 @@ ```js
 * waterfall
+* compose
+* seq
+* applyEach
+* applyEachSeries
+* queue
+* priorityQueue
+* cargo
+* auto
+* retry
+* nextTick
+* times
+* timesSeries
 
+## Neo-Async Functions Implemented
 
+* mapValues
+* mapValuesSeries
+
+## Functions not implemented
+
+* iterator
+* apply
+* memoize
+* unmemoize
+* log
+* dir
+* noConflict
+
+## Other Utilities
+
+### abort(err)
+
+This is intended to be used as a last-ditch error handler for promises.  Using
+promises, if the last rejection handler in a promise throws an exception, it is
+silently ignored.  Calling `abort(err)` will throw `err` as an exception in the
+global scope, calling the process's `uncaughtException` listeners or exiting with
+the exception by default.  Use it like this:
+
+```js
+getUser(nonexistent_id).then(function(user) {
+	// do something with user
+}).catch(function(err) {
+	// Note the (obvious) errors in the rejection handlers; by default, this will be silently ignored
+	cunsil.lug(err);
+}).catch(pasync.abort);	// This will catch the undefined variable error and throw it globally
+```

test/tests.js

@@ -0,1 +1,3 @@
+/*jshint -W030 */
+
 var expect = require('chai').expect;
@@ -602,2 +604,856 @@ var pasync = require('../lib/index');
 
+	it('compose', function(done) {
+		var thisTest = {};
+		function mul2(n) {
+			return Promise.resolve(n * 2);
+		}
+		function mul3(n) {
+			expect(this).to.equal(thisTest);
+			return Promise.resolve(n * 3);
+		}
+		function mul4(n) {
+			return Promise.resolve(n * 4);
+		}
+		var composition = pasync.compose(mul2, mul3, mul4);
+		composition.call(thisTest, 2).then(function(result) {
+			expect(result).to.equal(48);
+			done();
+		}).catch(done);
+	});
+
+	it('compose with error', function(done) {
+		function mul2(n) {
+			return Promise.resolve(n * 2);
+		}
+		function mul3(n) {
+			return Promise.reject(123);
+		}
+		function mul4(n) {
+			return Promise.resolve(n * 4);
+		}
+		var composition = pasync.compose(mul2, mul3, mul4);
+		composition(2).then(function(result) {
+			done(new Error('Should not succeed'));
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('seq', function(done) {
+		var thisTest = {};
+		function mul2(n) {
+			return Promise.resolve(n * 2);
+		}
+		function mul3(n) {
+			expect(this).to.equal(thisTest);
+			return Promise.resolve(n * 3);
+		}
+		function mul4(n) {
+			return Promise.resolve(n * 4);
+		}
+		var composition = pasync.seq(mul2, mul3, mul4);
+		composition.call(thisTest, 2).then(function(result) {
+			expect(result).to.equal(48);
+			done();
+		}).catch(done);
+	});
+
+	it('applyEach', function(done) {
+		var resultArray = [];
+		function addStuff1(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		function addStuff2(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		function addStuff3(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		pasync.applyEach([
+			addStuff1,
+			addStuff2,
+			addStuff3
+		], 4, 5).then(function() {
+			expect(resultArray).to.deep.equal([4, 5, 4, 5, 4, 5]);
+			done();
+		}).catch(done);
+	});
+
+	it('applyEach with error', function(done) {
+		var resultArray = [];
+		function addStuff1(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		function addStuff2(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.reject(123);
+		}
+		function addStuff3(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		pasync.applyEach([
+			addStuff1,
+			addStuff2,
+			addStuff3
+		], 4, 5).then(function() {
+			done(new Error('Should not succeed'));
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('applyEachSeries', function(done) {
+		var resultArray = [];
+		function addStuff1(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		function addStuff2(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		function addStuff3(a, b) {
+			resultArray.push(a);
+			resultArray.push(b);
+			return Promise.resolve();
+		}
+		pasync.applyEachSeries([
+			addStuff1,
+			addStuff2,
+			addStuff3
+		], 4, 5).then(function() {
+			expect(resultArray).to.deep.equal([4, 5, 4, 5, 4, 5]);
+			done();
+		}).catch(done);
+	});
+
+	it('queue', function(done) {
+		var responseQueue = [];
+		var queue = pasync.queue(function(task) {
+			return new Promise(function(resolve, reject) {
+				responseQueue.push(task * 2);
+				resolve();
+			});
+		}, 2);
+
+		queue.unshift(1).catch(done);
+		queue.push([2, 3, 4, 5]).catch(done);
+
+		queue.drain = function() {
+			expect(responseQueue).to.deep.equal([2, 4, 6, 8, 10]);
+			done();
+		};
+	});
+
+	it('queue with error', function(done) {
+		var responseQueue = [];
+		var queue = pasync.queue(function(task) {
+			return new Promise(function(resolve, reject) {
+				if(task === 4) {
+					reject(123);
+				} else {
+					responseQueue.push(task * 2);
+					resolve();
+				}
+			});
+		}, 2);
+
+		queue.unshift(1).catch(done);
+		queue.push([2, 3]).catch(done);
+		queue.push(4).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+		}).catch(done);
+		queue.push(5).catch(done);
+
+		queue.drain = function() {
+			expect(responseQueue).to.deep.equal([2, 4, 6, 10]);
+			done();
+		};
+	});
+
+	it('priorityQueue', function(done) {
+		var responseQueue = [];
+		var priorityQueue = pasync.priorityQueue(function(task) {
+			return new Promise(function(resolve, reject) {
+				responseQueue.push(task * 2);
+				resolve();
+			});
+		}, 2);
+
+		priorityQueue.push(1, 3).catch(done);
+		priorityQueue.push([2, 3, 4, 5], 1).catch(done);
+
+		priorityQueue.drain = function() {
+			expect(responseQueue).to.deep.equal([4, 6, 8, 10, 2]);
+			done();
+		};
+	});
+
+
+	it('priorityQueue with error', function(done) {
+		var responseQueue = [];
+		var priorityQueue = pasync.priorityQueue(function(task) {
+			return new Promise(function(resolve, reject) {
+				if(task === 4) {
+					reject(123);
+				} else {
+					responseQueue.push(task * 2);
+					resolve();
+				}
+			});
+		}, 2);
+
+		priorityQueue.push([2, 3]).catch(done);
+		priorityQueue.push(4).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+		}).catch(done);
+		priorityQueue.push(5).catch(done);
+
+		priorityQueue.drain = function() {
+			expect(responseQueue).to.deep.equal([4, 6, 10]);
+			done();
+		};
+	});
+
+	it('cargo', function(done) {
+		var responseArray = [];
+		var cargo = pasync.cargo(function(tasks) {
+			tasks.forEach(function(task) {
+				responseArray.push(task * 12);
+			});
+			return Promise.resolve();
+		}, 5);
+
+		cargo.push([1, 2, 3, 4, 5]).catch(done);
+		cargo.drain = function() {
+			expect(responseArray).to.deep.equal([12, 24, 36, 48, 60]);
+			done();
+		};
+	});
+
+	it('cargo with error', function(done) {
+		var responseArray = [];
+		var cargo = pasync.cargo(function(tasks) {
+			return new Promise(function(resolve, reject) {
+				var isError = false;
+				tasks.forEach(function(task) {
+					if(task === 3) {
+						isError = true;
+					} else {
+						responseArray.push(task * 12);
+					}
+				});
+				if(isError) {
+					reject(123)
+				} else {
+					resolve();
+				}
+			});
+		}, 2);
+
+		cargo.push([1, 2, 4, 5]).catch(done);
+		cargo.push(3).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('auto', function(done) {
+		var responseArray = [];
+		var auto = pasync.auto({
+			get_data: function() {
+				responseArray.push(2);
+				return Promise.resolve(2);
+			},
+			da_data: ['get_data', function(results) {
+				var tempResult = results.get_data * 2;
+				responseArray.push(tempResult);
+				return Promise.resolve(tempResult);
+			}],
+			get_more_data: ['get_data', 'da_data', function(results) {
+				var tempResult = results.da_data * 2;
+				responseArray.push(tempResult);
+				return Promise.resolve(tempResult);
+			}]
+		}).then(function(resultObject) {
+			expect(responseArray).to.deep.equal([2, 4, 8]);
+			done();
+		}).catch(done);
+	});
+
+	it('auto with value', function(done) {
+		var responseArray = [];
+		var auto = pasync.auto({
+			get_data: function() {
+				responseArray.push(2);
+				return 2;
+			},
+			da_data: ['get_data', function(results) {
+				var tempResult = results.get_data * 2;
+				responseArray.push(tempResult);
+				return Promise.resolve(tempResult);
+			}],
+			get_more_data: ['get_data', 'da_data', function(results) {
+				var tempResult = results.da_data * 2;
+				responseArray.push(tempResult);
+				return Promise.resolve(tempResult);
+			}]
+		}).then(function(resultObject) {
+			expect(responseArray).to.deep.equal([2, 4, 8]);
+			done();
+		}).catch(done);
+	});
+
+	it('auto with error', function(done) {
+		var auto = pasync.auto({
+			fail_me: function() {
+				return Promise.reject(123);
+			}
+		}).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('auto with throwing error', function(done) {
+		var auto = pasync.auto({
+			fail_me: function() {
+				throw(123);
+			}
+		}).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('retry', function(done) {
+		var responseArray = [];
+		var retry = pasync.retry(3, function() {
+			responseArray.push('a');
+			responseArray.push('b');
+			responseArray.push('c');
+			return Promise.resolve();
+		}).then(function() {
+			expect(responseArray).to.deep.equal(['a', 'b', 'c']);
+			done();
+		}).catch(done);
+	});
+
+	it('retry with error', function(done) {
+		var retryCount = 0;
+		var retry = pasync.retry(3, function() {
+			retryCount++;
+			return Promise.reject(123);
+		}).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+			expect(retryCount).to.equal(3);
+			done();
+		}).catch(done);
+	});
+
+	it('nextTick', function(done) {
+		var resultArray = [];
+		new Promise(function(resolve) {
+			pasync.nextTick(resolve);
+			resultArray.push(1);
+		}).then(function() {
+			resultArray.push(2);
+			expect(resultArray).to.deep.equal([1, 2]);
+			done();
+		}).catch(done);
+	});
+
+	it('nextTick chaining', function(done) {
+		var resultArray = [];
+		resultArray.push(1);
+		Promise.resolve().then(function() {
+			resultArray.push(2);
+		}).then(pasync.nextTick).then(function() {
+			expect(resultArray).to.deep.equal([1, 2]);
+			done();
+		}).catch(done);
+	});
+
+	it('times', function(done) {
+		var timesCount = 0;
+		var timesTest = 2;
+		pasync.times(8, function(n, next) {
+			timesCount++;
+			timesTest = timesTest * 2;
+			return Promise.resolve();
+		}).then(function() {
+			expect(timesCount).to.equal(8);
+			expect(timesTest).to.equal(512);
+			done();
+		}).catch(done);
+	});
+
+	it('times with error', function(done) {
+		var timesCount = 0;
+		pasync.times(8, function(n, next) {
+			timesCount++;
+			return Promise.reject(123);
+		}).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(timesCount).to.equal(8);
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	it('timesSeries', function(done) {
+		var timesCount = 0;
+		var timesTest = 2;
+		pasync.timesSeries(17, function(n, next) {
+			timesCount++;
+			timesTest = timesTest * 2;
+			return Promise.resolve();
+		}).then(function() {
+			expect(timesCount).to.equal(17);
+			expect(timesTest).to.equal(262144);
+			done();
+		}).catch(done);
+	});
+
+	it('timesSeries with error', function(done) {
+		pasync.timesSeries(8, function(n, next) {
+			return Promise.reject(123);
+		}).then(function() {
+			throw new Error('should not reach');
+		}, function(err) {
+			expect(err).to.equal(123);
+			done();
+		}).catch(done);
+	});
+
+	describe('Neo-Async Improvement of Convenience Support', function() {
+		var testObject = {
+			notRed: 'red',
+			notGreen: 'green',
+			notBlue: 'blue'
+		};
+
+		var numTestObject = {
+			one: 1,
+			two: 2,
+			three: 3
+		};
+
+		it('each with object', function(done) {
+			var res = [];
+			pasync.each(testObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						res.push(el);
+						resolve();
+					});
+				});
+			}).then(function() {
+				expect(res).to.contain('red');
+				expect(res).to.contain('blue');
+				expect(res).to.contain('green');
+				expect(res).to.have.length(3);
+				done();
+			}).catch(done);
+		});
+
+		it('each with values', function(done) {
+			var res = [];
+			pasync.each(numTestObject, function(el) {
+				res.push(el);
+			}).then(function() {
+				expect(res).to.contain(1);
+				expect(res).to.contain(2);
+				expect(res).to.contain(3);
+				expect(res).to.have.length(3);
+				done();
+			}).catch(done);
+		});
+
+		it('eachSeries', function(done) {
+			var res = [];
+			pasync.eachSeries(testObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						res.push(el);
+						resolve();
+					});
+				});
+			}).then(function() {
+					expect(res).to.contain('red');
+					expect(res).to.contain('blue');
+					expect(res).to.contain('green');
+					expect(res).to.have.length(3);
+				done();
+			}).catch(done);
+		});
+
+		it('eachLimit', function(done) {
+			var res = [];
+			pasync.eachLimit(testObject, 2, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						res.push(el);
+						resolve();
+					});
+				});
+			}).then(function() {
+						expect(res).to.contain('red');
+						expect(res).to.contain('blue');
+						expect(res).to.contain('green');
+				expect(res).to.have.length(3);
+				done();
+			}).catch(done);
+		});
+
+		it('map with promises', function(done) {
+			pasync.map(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el + 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([ 2, 3, 4 ]);
+				done();
+			}).catch(done);
+		});
+
+		it('map with values', function(done) {
+			pasync.map(numTestObject, function(el) {
+				return el + 1;
+			}).then(function(res) {
+				expect(res).to.deep.equal([2, 3, 4]);
+				done();
+			}).catch(done);
+		});
+
+		it('mapSeries', function(done) {
+			pasync.mapSeries(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el + 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([2, 3, 4]);
+				done();
+			}).catch(done);
+		});
+
+		it('mapLimit', function(done) {
+			pasync.mapLimit(numTestObject, 2, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el + 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([2, 3, 4]);
+				done();
+			}).catch(done);
+		});
+
+		it('filter', function(done) {
+			pasync.filter(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el > 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([2, 3]);
+				done();
+			}).catch(done);
+		});
+
+		it('filterSeries', function(done) {
+			pasync.filterSeries(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el > 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([2, 3]);
+				done();
+			}).catch(done);
+		});
+
+		it('reject', function(done) {
+			pasync.reject(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el > 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([1]);
+				done();
+			}).catch(done);
+		});
+
+
+		it('rejectSeries', function(done) {
+			pasync.rejectSeries(numTestObject, function(el) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(el > 1);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([1]);
+				done();
+			}).catch(done);
+		});
+
+		it('reduce', function(done) {
+			pasync.reduce(numTestObject, 0, function(memo, item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(memo + item);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(6);
+				done();
+			}).catch(done);
+		});
+
+		it('reduceRight', function(done) {
+			pasync.reduceRight(numTestObject, 0, function(memo, item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(memo + item);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(6);
+				done();
+			}).catch(done);
+		});
+
+		it('detect', function(done) {
+			pasync.detect(numTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item === 2);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(2);
+				done();
+			}).catch(done);
+		});
+
+		it('detectSeries', function(done) {
+			pasync.detectSeries(numTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item === 2);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(2);
+				done();
+			}).catch(done);
+		});
+
+		it('sortBy', function(done) {
+			var unorderedNumTestObject = {
+				one: 2,
+				two: 3,
+				three: 1
+			};
+			pasync.sortBy(unorderedNumTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([1, 2, 3]);
+				done();
+			}).catch(done);
+		});
+
+		it('some', function(done) {
+			pasync.some(numTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item === 2);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(true);
+				done();
+			}).catch(done);
+		});
+
+		it('every', function(done) {
+			pasync.every(numTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item === 2);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.equal(false);
+				done();
+			}).catch(done);
+		});
+
+		it('concat', function(done) {
+			var specialNumTestObject = {
+				one: [1, 2],
+				four: [3, 4]
+			};
+			pasync.concat(specialNumTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([1, 2, 3, 4]);
+				done();
+			}).catch(done);
+		});
+
+		it('concatSeries', function(done) {
+			var specialNumTestObject = {
+				one: [1, 2],
+				four: [3, 4]
+			};
+			pasync.concatSeries(specialNumTestObject, function(item) {
+				return new Promise(function(resolve) {
+					setImmediate(function() {
+						resolve(item);
+					});
+				});
+			}).then(function(res) {
+				expect(res).to.deep.equal([1, 2, 3, 4]);
+				done();
+			}).catch(done);
+		});
+	});
+
+	describe('Neo-Async features', function() {
+
+		it('mapValues as array', function(done) {
+			var arr = [1, 2, 3];
+			pasync.mapValues(arr, function(el) {
+				return el + 1;
+			}).then(function(res) {
+				expect(res).to.deep.equal({
+					0: 2,
+					1: 3,
+					2: 4
+				});
+				done();
+			}).catch(done);
+		});
+
+		it('mapValues as object', function(done) {
+			var arr = {
+				hello: 1,
+				goodbye: 2,
+				dough: 3
+			};
+			pasync.mapValues(arr, function(el) {
+				return el + 1;
+			}).then(function(res) {
+				expect(res).to.deep.equal({
+					hello: 2,
+					goodbye: 3,
+					dough: 4
+				});
+				done();
+			}).catch(done);
+		});
+
+		it('mapValuesSeries as array', function(done) {
+			var arr = [1, 2, 3];
+			pasync.mapValuesSeries(arr, function(el) {
+				return el + 1;
+			}).then(function(res) {
+				expect(res).to.deep.equal({
+					0: 2,
+					1: 3,
+					2: 4
+				});
+				done();
+			}).catch(done);
+		});
+
+		it('mapValuesSeries as object', function(done) {
+			var arr = {
+				hello: 1,
+				goodbye: 2,
+				dough: 3
+			};
+			pasync.mapValuesSeries(arr, function(el) {
+				return el + 1;
+			}).then(function(res) {
+				expect(res).to.deep.equal({
+					hello: 2,
+					goodbye: 3,
+					dough: 4
+				});
+				done();
+			}).catch(done);
+		});
+
+		it('abort', function(done) {
+			// fudge around with uncaught exception listeners ...
+			var oldListeners = process.listeners('uncaughtException').slice(0);
+			oldListeners.forEach(function(listener) {
+				process.removeListener('uncaughtException', listener);
+			});
+			var newListener = function(exception) {
+				process.removeListener('uncaughtException', newListener);
+				oldListeners.forEach(function(listener) {
+					process.on('uncaughtException', listener);
+				});
+				expect(exception).to.equal(123);
+				done();
+			};
+			process.on('uncaughtException', newListener);
+
+			// Do test
+			new Promise(function(resolve) {
+				setTimeout(resolve, 5);
+			}).then(function() {
+				throw 123;
+			}).catch(pasync.abort);
+		});
+	});
 });

No alert changes

Improved metrics

Total package byte prevSize

51024

increased by110.23%

Lines of code

1778

increased by133.64%

Number of lines in readme file

108

increased by71.43%

No dependency changes