async-rails 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f2f0d5008e172bd87a7dcea946cd29a2e0e9235
-  data.tar.gz: b52c5f238f50edd12bde0e5c1612b332bae398db
+  metadata.gz: 0b75772d99ec34fbeddd4bb669debffbe1a77739
+  data.tar.gz: 29fb194713a6d44c72f620f47babc381a7cf9d63
 SHA512:
-  metadata.gz: e99ba2afc03e64eec2378082145aefcd585e56b92d4118788f1c7541df60b0eb0b8605ce7ae62ca55a114934776a785d46cecb9645ba4168d9ea3211854fc475
-  data.tar.gz: 1b13b2f9dc0b83fe726162441e26d4d00491ca67c93d2298dc5df9d40278579477522032b3171ce020ba9a56d120bc34418c6a383fe439e318038f49a6c0cf07
+  metadata.gz: b815f5630a1a01ca09d37bdde7e882c783ab7a04162227ea401c6a168cd02a5b13adc7f2412f1448d965743c91d02cf8f597085a1f6131c635fa55722d9977a9
+  data.tar.gz: 0bb53625bab9d1cc06b384f915049684827ce286bc2eb2b369cad70d5ee0660af79a9d90e520bb4964acdad1fccc47993ee988b88dafee03445127bd5661724f

data/lib/async-rails/version.rb

@@ -1,5 +1,5 @@
 module Async
   module Rails
-    VERSION = "1.0.2"
+    VERSION = "1.1.0"
   end
 end

data/vendor/assets/javascripts/async.js

@@ -8,7 +8,7 @@
 (function () {
 
     var async = {};
-    var noop = function () {};
+    function noop() {}
 
     // global on the server, window in the browser
     var root, previous_async;
@@ -37,7 +37,16 @@
         return function() {
             if (called) throw new Error("Callback was already called.");
             called = true;
-            fn.apply(root, arguments);
+            fn.apply(this, arguments);
+        };
+    }
+
+    function _once(fn) {
+        var called = false;
+        return function() {
+            if (called) return;
+            called = true;
+            fn.apply(this, arguments);
         };
     }
 
@@ -49,16 +58,31 @@
         return _toString.call(obj) === '[object Array]';
     };
 
-    var _each = function (arr, iterator) {
+    function _isArrayLike(arr) {
+        return _isArray(arr) || (
+            // has a positive integer length property
+            typeof arr.length === "number" &&
+            arr.length >= 0 &&
+            arr.length % 1 === 0
+        );
+    }
+
+    function _each(coll, iterator) {
+        return _isArrayLike(coll) ?
+            _arrayEach(coll, iterator) :
+            _forEachOf(coll, iterator);
+    }
+
+    function _arrayEach(arr, iterator) {
       var index = -1,
           length = arr.length;
 
       while (++index < length) {
         iterator(arr[index], index, arr);
       }
-    };
+    }
 
-    var _map = function (arr, iterator) {
+    function _map(arr, iterator) {
       var index = -1,
           length = arr.length,
           result = Array(length);
@@ -67,20 +91,20 @@
         result[index] = iterator(arr[index], index, arr);
       }
       return result;
-    };
+    }
 
-    var _reduce = function (arr, iterator, memo) {
-        _each(arr, function (x, i, a) {
+    function _reduce(arr, iterator, memo) {
+        _arrayEach(arr, function (x, i, a) {
             memo = iterator(memo, x, i, a);
         });
         return memo;
-    };
+    }
 
-    var _forEachOf = function (object, iterator) {
-        _each(_keys(object), function (key) {
+    function _forEachOf(object, iterator) {
+        _arrayEach(_keys(object), function (key) {
             iterator(object[key], key);
         });
-    };
+    }
 
     var _keys = Object.keys || function (obj) {
         var keys = [];
@@ -92,7 +116,27 @@
         return keys;
     };
 
-    var _baseSlice = function (arr, start) {
+    function _keyIterator(coll) {
+        var i = -1;
+        var len;
+        var keys;
+        if (_isArrayLike(coll)) {
+            len = coll.length;
+            return function next() {
+                i++;
+                return i < len ? i : null;
+            };
+        } else {
+            keys = _keys(coll);
+            len = keys.length;
+            return function next() {
+                i++;
+                return i < len ? keys[i] : null;
+            };
+        }
+    }
+
+    function _baseSlice(arr, start) {
         start = start || 0;
         var index = -1;
         var length = arr.length;
@@ -107,7 +151,13 @@
           result[index] = arr[index + start];
         }
         return result;
-    };
+    }
+
+    function _withoutIndex(iterator) {
+        return function (value, index, callback) {
+            return iterator(value, callback);
+        };
+    }
 
     //// exported async module functions ////
 
@@ -147,272 +197,172 @@
         }
     }
 
+    async.forEach =
     async.each = function (arr, iterator, callback) {
-        callback = callback || noop;
-        if (!arr.length) {
-            return callback(null);
-        }
-        var completed = 0;
-        _each(arr, function (x) {
-            iterator(x, only_once(done) );
-        });
-        function done(err) {
-          if (err) {
-              callback(err);
-              callback = noop;
-          }
-          else {
-              completed += 1;
-              if (completed >= arr.length) {
-                  callback(null);
-              }
-          }
-        }
+        return async.eachOf(arr, _withoutIndex(iterator), callback);
     };
-    async.forEach = async.each;
 
+    async.forEachSeries =
     async.eachSeries = function (arr, iterator, callback) {
-        callback = callback || noop;
-        if (!arr.length) {
-            return callback(null);
-        }
-        var completed = 0;
-        var iterate = function () {
-            iterator(arr[completed], function (err) {
-                if (err) {
-                    callback(err);
-                    callback = noop;
-                }
-                else {
-                    completed += 1;
-                    if (completed >= arr.length) {
-                        callback(null);
-                    }
-                    else {
-                        iterate();
-                    }
-                }
-            });
-        };
-        iterate();
+        return async.eachOfSeries(arr, _withoutIndex(iterator), callback);
     };
-    async.forEachSeries = async.eachSeries;
 
 
+    async.forEachLimit =
     async.eachLimit = function (arr, limit, iterator, callback) {
-        var fn = _eachLimit(limit);
-        fn.apply(null, [arr, iterator, callback]);
+        return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
     };
-    async.forEachLimit = async.eachLimit;
-
-    var _eachLimit = function (limit) {
-
-        return function (arr, iterator, callback) {
-            callback = callback || noop;
-            if (!arr.length || limit <= 0) {
-                return callback(null);
-            }
-            var completed = 0;
-            var started = 0;
-            var running = 0;
-            var errored = false;
 
-            (function replenish () {
-                if (completed >= arr.length) {
-                    return callback(null);
-                }
-
-                while (running < limit && started < arr.length && !errored) {
-                    started += 1;
-                    running += 1;
-                    iterator(arr[started - 1], function (err) {
-                        if (err) {
-                            callback(err);
-                            errored = true;
-                            callback = noop;
-                        }
-                        else {
-                            completed += 1;
-                            running -= 1;
-                            if (completed >= arr.length) {
-                                callback(null);
-                            }
-                            else {
-                                replenish();
-                            }
-                        }
-                    });
-                }
-            })();
-        };
-    };
-
-
-
-    async.forEachOf = async.eachOf = function (object, iterator, callback) {
-        callback = callback || function () {};
+    async.forEachOf =
+    async.eachOf = function (object, iterator, callback) {
+        callback = _once(callback || noop);
+        object = object || [];
         var size = object.length || _keys(object).length;
         var completed = 0;
         if (!size) {
             return callback(null);
         }
-        _forEachOf(object, function (value, key) {
-            iterator(object[key], key, function (err) {
-                if (err) {
-                    callback(err);
-                    callback = function () {};
-                } else {
-                    completed += 1;
-                    if (completed === size) {
-                        callback(null);
-                    }
-                }
-            });
+        _each(object, function (value, key) {
+            iterator(object[key], key, only_once(done));
         });
+        function done(err) {
+          if (err) {
+              callback(err);
+          }
+          else {
+              completed += 1;
+              if (completed >= size) {
+                  callback(null);
+              }
+          }
+        }
     };
 
-    async.forEachOfSeries = async.eachOfSeries = function (obj, iterator, callback) {
-        callback = callback || function () {};
-        var keys = _keys(obj);
-        var size = keys.length;
-        if (!size) {
-            return callback();
-        }
-        var completed = 0;
-        var iterate = function () {
+    async.forEachOfSeries =
+    async.eachOfSeries = function (obj, iterator, callback) {
+        callback = _once(callback || noop);
+        obj = obj || [];
+        var nextKey = _keyIterator(obj);
+        function iterate() {
             var sync = true;
-            var key = keys[completed];
+            var key = nextKey();
+            if (key === null) {
+                return callback(null);
+            }
             iterator(obj[key], key, function (err) {
                 if (err) {
                     callback(err);
-                    callback = function () {};
                 }
                 else {
-                    completed += 1;
-                    if (completed >= size) {
-                        callback(null);
+                    if (sync) {
+                        async.nextTick(iterate);
                     }
                     else {
-                        if (sync) {
-                            async.nextTick(iterate);
-                        }
-                        else {
-                            iterate();
-                        }
+                        iterate();
                     }
                 }
             });
             sync = false;
-        };
+        }
         iterate();
     };
 
 
 
-    async.forEachOfLimit = async.eachOfLimit = function (obj, limit, iterator, callback) {
-        _forEachOfLimit(limit)(obj, iterator, callback);
+    async.forEachOfLimit =
+    async.eachOfLimit = function (obj, limit, iterator, callback) {
+        _eachOfLimit(limit)(obj, iterator, callback);
     };
 
-    var _forEachOfLimit = function (limit) {
+    function _eachOfLimit(limit) {
 
         return function (obj, iterator, callback) {
-            callback = callback || function () {};
-            var keys = _keys(obj);
-            var size = keys.length;
-            if (!size || limit <= 0) {
+            callback = _once(callback || noop);
+            obj = obj || [];
+            var nextKey = _keyIterator(obj);
+            if (limit <= 0) {
                 return callback(null);
             }
-            var completed = 0;
-            var started = 0;
+            var done = false;
             var running = 0;
+            var errored = false;
 
             (function replenish () {
-                if (completed >= size) {
-                    return callback();
+                if (done && running <= 0) {
+                    return callback(null);
                 }
 
-                while (running < limit && started < size) {
-                    started += 1;
+                while (running < limit && !errored) {
+                    var key = nextKey();
+                    if (key === null) {
+                        done = true;
+                        if (running <= 0) {
+                            callback(null);
+                        }
+                        return;
+                    }
                     running += 1;
-                    var key = keys[started - 1];
                     iterator(obj[key], key, function (err) {
+                        running -= 1;
                         if (err) {
                             callback(err);
-                            callback = function () {};
+                            errored = true;
                         }
                         else {
-                            completed += 1;
-                            running -= 1;
-                            if (completed >= size) {
-                                callback(null);
-                            }
-                            else {
-                                replenish();
-                            }
+                            replenish();
                         }
                     });
                 }
             })();
         };
-    };
+    }
 
 
-    var doParallel = function (fn) {
-        return function () {
-            var args = _baseSlice(arguments);
-            return fn.apply(null, [async.each].concat(args));
+    function doParallel(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOf, obj, iterator, callback);
         };
-    };
-    var doParallelLimit = function(limit, fn) {
-        return function () {
-            var args = _baseSlice(arguments);
-            return fn.apply(null, [_eachLimit(limit)].concat(args));
+    }
+    function doParallelLimit(limit, fn) {
+        return function (obj, iterator, callback) {
+            return fn(_eachOfLimit(limit), obj, iterator, callback);
         };
-    };
-    var doSeries = function (fn) {
-        return function () {
-            var args = _baseSlice(arguments);
-            return fn.apply(null, [async.eachSeries].concat(args));
+    }
+    function doSeries(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOfSeries, obj, iterator, callback);
         };
-    };
-
+    }
 
-    var _asyncMap = function (eachfn, arr, iterator, callback) {
-        arr = _map(arr, function (x, i) {
-            return {index: i, value: x};
-        });
-        if (!callback) {
-            eachfn(arr, function (x, callback) {
-                iterator(x.value, function (err) {
-                    callback(err);
-                });
-            });
-        } else {
-            var results = [];
-            eachfn(arr, function (x, callback) {
-                iterator(x.value, function (err, v) {
-                    results[x.index] = v;
-                    callback(err);
-                });
-            }, function (err) {
-                callback(err, results);
+    function _asyncMap(eachfn, arr, iterator, callback) {
+        callback = _once(callback || noop);
+        var results = [];
+        eachfn(arr, function (value, index, callback) {
+            iterator(value, function (err, v) {
+                results[index] = v;
+                callback(err);
             });
-        }
-    };
+        }, function (err) {
+            callback(err, results);
+        });
+    }
+
     async.map = doParallel(_asyncMap);
     async.mapSeries = doSeries(_asyncMap);
     async.mapLimit = function (arr, limit, iterator, callback) {
         return _mapLimit(limit)(arr, iterator, callback);
     };
 
-    var _mapLimit = function(limit) {
+    function _mapLimit(limit) {
         return doParallelLimit(limit, _asyncMap);
-    };
+    }
 
     // reduce only has a series version, as doing reduce in parallel won't
     // work in many situations.
+    async.inject =
+    async.foldl =
     async.reduce = function (arr, memo, iterator, callback) {
-        async.eachSeries(arr, function (x, callback) {
+        async.eachOfSeries(arr, function (x, i, callback) {
             iterator(memo, x, function (err, v) {
                 memo = v;
                 callback(err);
@@ -421,71 +371,67 @@
             callback(err || null, memo);
         });
     };
-    // inject alias
-    async.inject = async.reduce;
-    // foldl alias
-    async.foldl = async.reduce;
 
+    async.foldr =
     async.reduceRight = function (arr, memo, iterator, callback) {
         var reversed = _map(arr, function (x) {
             return x;
         }).reverse();
         async.reduce(reversed, memo, iterator, callback);
     };
-    // foldr alias
-    async.foldr = async.reduceRight;
 
-    var _filter = function (eachfn, arr, iterator, callback) {
+    function _filter(eachfn, arr, iterator, callback) {
         var results = [];
         arr = _map(arr, function (x, i) {
             return {index: i, value: x};
         });
-        eachfn(arr, function (x, callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x.value, function (v) {
                 if (v) {
                     results.push(x);
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             callback(_map(results.sort(function (a, b) {
                 return a.index - b.index;
             }), function (x) {
                 return x.value;
             }));
         });
-    };
+    }
+
+    async.select =
     async.filter = doParallel(_filter);
+
+    async.selectSeries =
     async.filterSeries = doSeries(_filter);
-    // select alias
-    async.select = async.filter;
-    async.selectSeries = async.filterSeries;
 
-    var _reject = function (eachfn, arr, iterator, callback) {
+    function _reject(eachfn, arr, iterator, callback) {
         var results = [];
         arr = _map(arr, function (x, i) {
             return {index: i, value: x};
         });
-        eachfn(arr, function (x, callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x.value, function (v) {
                 if (!v) {
                     results.push(x);
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             callback(_map(results.sort(function (a, b) {
                 return a.index - b.index;
             }), function (x) {
                 return x.value;
             }));
         });
-    };
+    }
     async.reject = doParallel(_reject);
     async.rejectSeries = doSeries(_reject);
 
-    var _detect = function (eachfn, arr, iterator, main_callback) {
-        eachfn(arr, function (x, callback) {
+    function _detect(eachfn, arr, iterator, main_callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x, function (result) {
                 if (result) {
                     main_callback(x);
@@ -495,15 +441,16 @@
                     callback();
                 }
             });
-        }, function (err) {
+        }, function () {
             main_callback();
         });
-    };
+    }
     async.detect = doParallel(_detect);
     async.detectSeries = doSeries(_detect);
 
+    async.any =
     async.some = function (arr, iterator, main_callback) {
-        async.each(arr, function (x, callback) {
+        async.eachOf(arr, function (x, _, callback) {
             iterator(x, function (v) {
                 if (v) {
                     main_callback(true);
@@ -511,15 +458,14 @@
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             main_callback(false);
         });
     };
-    // any alias
-    async.any = async.some;
 
+    async.all =
     async.every = function (arr, iterator, main_callback) {
-        async.each(arr, function (x, callback) {
+        async.eachOf(arr, function (x, _, callback) {
             iterator(x, function (v) {
                 if (!v) {
                     main_callback(false);
@@ -527,12 +473,10 @@
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             main_callback(true);
         });
     };
-    // all alias
-    async.all = async.every;
 
     async.sortBy = function (arr, iterator, callback) {
         async.map(arr, function (x, callback) {
@@ -549,19 +493,21 @@
                 return callback(err);
             }
             else {
-                var fn = function (left, right) {
-                    var a = left.criteria, b = right.criteria;
-                    return a < b ? -1 : a > b ? 1 : 0;
-                };
-                callback(null, _map(results.sort(fn), function (x) {
+                callback(null, _map(results.sort(comparator), function (x) {
                     return x.value;
                 }));
             }
+
         });
+
+        function comparator(left, right) {
+            var a = left.criteria, b = right.criteria;
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
     };
 
     async.auto = function (tasks, callback) {
-        callback = callback || noop;
+        callback = _once(callback || noop);
         var keys = _keys(tasks);
         var remainingTasks = keys.length;
         if (!remainingTasks) {
@@ -571,56 +517,50 @@
         var results = {};
 
         var listeners = [];
-        var addListener = function (fn) {
+        function addListener(fn) {
             listeners.unshift(fn);
-        };
-        var removeListener = function (fn) {
+        }
+        function removeListener(fn) {
             for (var i = 0; i < listeners.length; i += 1) {
                 if (listeners[i] === fn) {
                     listeners.splice(i, 1);
                     return;
                 }
             }
-        };
-        var taskComplete = function () {
+        }
+        function taskComplete() {
             remainingTasks--;
-            _each(listeners.slice(0), function (fn) {
+            _arrayEach(listeners.slice(0), function (fn) {
                 fn();
             });
-        };
+        }
 
         addListener(function () {
             if (!remainingTasks) {
-                var theCallback = callback;
-                // prevent final callback from calling itself if it errors
-                callback = noop;
-
-                theCallback(null, results);
+                callback(null, results);
             }
         });
 
-        _each(keys, function (k) {
+        _arrayEach(keys, function (k) {
             var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
-            var taskCallback = function (err) {
+            function taskCallback(err) {
                 var args = _baseSlice(arguments, 1);
                 if (args.length <= 1) {
                     args = args[0];
                 }
                 if (err) {
                     var safeResults = {};
-                    _each(_keys(results), function(rkey) {
+                    _arrayEach(_keys(results), function(rkey) {
                         safeResults[rkey] = results[rkey];
                     });
                     safeResults[k] = args;
                     callback(err, safeResults);
-                    // stop subsequent errors hitting callback multiple times
-                    callback = noop;
                 }
                 else {
                     results[k] = args;
                     async.setImmediate(taskComplete);
                 }
-            };
+            }
             var requires = task.slice(0, Math.abs(task.length - 1)) || [];
             // prevent dead-locks
             var len = requires.length;
@@ -633,23 +573,23 @@
                     throw new Error('Has cyclic dependencies');
                 }
             }
-            var ready = function () {
+            function ready() {
                 return _reduce(requires, function (a, x) {
                     return (a && results.hasOwnProperty(x));
                 }, true) && !results.hasOwnProperty(k);
-            };
+            }
             if (ready()) {
                 task[task.length - 1](taskCallback, results);
             }
             else {
-                var listener = function () {
-                    if (ready()) {
-                        removeListener(listener);
-                        task[task.length - 1](taskCallback, results);
-                    }
-                };
                 addListener(listener);
             }
+            function listener() {
+                if (ready()) {
+                    removeListener(listener);
+                    task[task.length - 1](taskCallback, results);
+                }
+            }
         });
     };
 
@@ -664,14 +604,16 @@
         }
         // Make sure times is a number
         times = parseInt(times, 10) || DEFAULT_TIMES;
-        var wrappedTask = function(wrappedCallback, wrappedResults) {
-            var retryAttempt = function(task, finalAttempt) {
+
+        function wrappedTask(wrappedCallback, wrappedResults) {
+            function retryAttempt(task, finalAttempt) {
                 return function(seriesCallback) {
                     task(function(err, result){
                         seriesCallback(!err || finalAttempt, {err: err, result: result});
                     }, wrappedResults);
                 };
-            };
+            }
+
             while (times) {
                 attempts.push(retryAttempt(task, !(times-=1)));
             }
@@ -679,13 +621,14 @@
                 data = data[data.length - 1];
                 (wrappedCallback || callback)(data.err, data.result);
             });
-        };
+        }
+
         // If a callback is passed, run this as a controll flow
         return callback ? wrappedTask() : wrappedTask;
     };
 
     async.waterfall = function (tasks, callback) {
-        callback = callback || noop;
+        callback = _once(callback || noop);
         if (!_isArray(tasks)) {
           var err = new Error('First argument to waterfall must be an array of functions');
           return callback(err);
@@ -693,11 +636,10 @@
         if (!tasks.length) {
             return callback();
         }
-        var wrapIterator = function (iterator) {
+        function wrapIterator(iterator) {
             return function (err) {
                 if (err) {
                     callback.apply(null, arguments);
-                    callback = noop;
                 }
                 else {
                     var args = _baseSlice(arguments, 1);
@@ -708,100 +650,70 @@
                     else {
                         args.push(callback);
                     }
-                    async.setImmediate(function () {
-                        iterator.apply(null, args);
-                    });
+                    ensureAsync(iterator).apply(null, args);
                 }
             };
-        };
+        }
         wrapIterator(async.iterator(tasks))();
     };
 
-    var _parallel = function(eachfn, tasks, callback) {
+    function _parallel(eachfn, tasks, callback) {
         callback = callback || noop;
-        if (_isArray(tasks)) {
-            eachfn.map(tasks, function (fn, callback) {
-                if (fn) {
-                    fn(function (err) {
-                        var args = _baseSlice(arguments, 1);
-                        if (args.length <= 1) {
-                            args = args[0];
-                        }
-                        callback.call(null, err, args);
-                    });
+        var results = _isArrayLike(tasks) ? [] : {};
+
+        eachfn(tasks, function (task, key, callback) {
+            task(function (err) {
+                var args = _baseSlice(arguments, 1);
+                if (args.length <= 1) {
+                    args = args[0];
                 }
-            }, callback);
-        }
-        else {
-            var results = {};
-            eachfn.each(_keys(tasks), function (k, callback) {
-                tasks[k](function (err) {
-                    var args = _baseSlice(arguments, 1);
-                    if (args.length <= 1) {
-                        args = args[0];
-                    }
-                    results[k] = args;
-                    callback(err);
-                });
-            }, function (err) {
-                callback(err, results);
+                results[key] = args;
+                callback(err);
             });
-        }
-    };
+        }, function (err) {
+            callback(err, results);
+        });
+    }
 
     async.parallel = function (tasks, callback) {
-        _parallel({ map: async.map, each: async.each }, tasks, callback);
+        _parallel(async.eachOf, tasks, callback);
     };
 
     async.parallelLimit = function(tasks, limit, callback) {
-        _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback);
+        _parallel(_eachOfLimit(limit), tasks, callback);
     };
 
     async.series = function (tasks, callback) {
         callback = callback || noop;
-        if (_isArray(tasks)) {
-            async.mapSeries(tasks, function (fn, callback) {
-                if (fn) {
-                    fn(function (err) {
-                        var args = _baseSlice(arguments, 1);
-                        if (args.length <= 1) {
-                            args = args[0];
-                        }
-                        callback.call(null, err, args);
-                    });
+        var results = _isArrayLike(tasks) ? [] : {};
+
+        async.eachOfSeries(tasks, function (task, key, callback) {
+            task(function (err) {
+                var args = _baseSlice(arguments, 1);
+                if (args.length <= 1) {
+                    args = args[0];
                 }
-            }, callback);
-        }
-        else {
-            var results = {};
-            async.eachSeries(_keys(tasks), function (k, callback) {
-                tasks[k](function (err) {
-                    var args = _baseSlice(arguments, 1);
-                    if (args.length <= 1) {
-                        args = args[0];
-                    }
-                    results[k] = args;
-                    callback(err);
-                });
-            }, function (err) {
-                callback(err, results);
+                results[key] = args;
+                callback(err);
             });
-        }
+        }, function (err) {
+            callback(err, results);
+        });
     };
 
     async.iterator = function (tasks) {
-        var makeCallback = function (index) {
-            var fn = function () {
+        function makeCallback(index) {
+            function fn() {
                 if (tasks.length) {
                     tasks[index].apply(null, arguments);
                 }
                 return fn.next();
-            };
+            }
             fn.next = function () {
                 return (index < tasks.length - 1) ? makeCallback(index + 1): null;
             };
             return fn;
-        };
+        }
         return makeCallback(0);
     };
 
@@ -814,17 +726,17 @@
         };
     };
 
-    var _concat = function (eachfn, arr, fn, callback) {
-        var r = [];
-        eachfn(arr, function (x, cb) {
+    function _concat(eachfn, arr, fn, callback) {
+        var result = [];
+        eachfn(arr, function (x, index, cb) {
             fn(x, function (err, y) {
-                r = r.concat(y || []);
+                result = result.concat(y || []);
                 cb(err);
             });
         }, function (err) {
-            callback(err, r);
+            callback(err, result);
         });
-    };
+    }
     async.concat = doParallel(_concat);
     async.concatSeries = doSeries(_concat);
 
@@ -886,85 +798,93 @@
         });
     };
 
-    async.queue = function (worker, concurrency) {
-        if (concurrency === undefined) {
+    function _queue(worker, concurrency, payload) {
+        if (concurrency == null) {
             concurrency = 1;
         }
         else if(concurrency === 0) {
             throw new Error('Concurrency must not be zero');
         }
         function _insert(q, data, pos, callback) {
-          if (!q.started){
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
             q.started = true;
-          }
-          if (!_isArray(data)) {
-              data = [data];
-          }
-          if(data.length === 0) {
-             // call drain immediately if there are no tasks
-             return async.setImmediate(function() {
-                 if (q.drain) {
-                     q.drain();
-                 }
-             });
-          }
-          _each(data, function(task) {
-              var item = {
-                  data: task,
-                  callback: typeof callback === 'function' ? callback : null
-              };
-
-              if (pos) {
-                q.tasks.unshift(item);
-              } else {
-                q.tasks.push(item);
-              }
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0 && q.idle()) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                   q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    callback: callback || noop
+                };
 
-              if (q.saturated && q.tasks.length === q.concurrency) {
-                  q.saturated();
-              }
-              async.setImmediate(q.process);
-          });
+                if (pos) {
+                  q.tasks.unshift(item);
+                } else {
+                  q.tasks.push(item);
+                }
+
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+                async.setImmediate(q.process);
+            });
         }
 
         var workers = 0;
         var q = {
             tasks: [],
             concurrency: concurrency,
-            saturated: null,
-            empty: null,
-            drain: null,
+            saturated: noop,
+            empty: noop,
+            drain: noop,
             started: false,
             paused: false,
             push: function (data, callback) {
-              _insert(q, data, false, callback);
+                _insert(q, data, false, callback);
             },
             kill: function () {
-              q.drain = null;
-              q.tasks = [];
+                q.drain = noop;
+                q.tasks = [];
             },
             unshift: function (data, callback) {
-              _insert(q, data, true, callback);
+                _insert(q, data, true, callback);
             },
             process: function () {
                 if (!q.paused && workers < q.concurrency && q.tasks.length) {
-                    var task = q.tasks.shift();
-                    if (q.empty && q.tasks.length === 0) {
+                    var tasks = payload ?
+                        q.tasks.splice(0, payload) :
+                        q.tasks.splice(0, q.tasks.length);
+
+                    var data = _map(tasks, function (task) {
+                        return task.data;
+                    });
+
+                    if (q.tasks.length === 0) {
                         q.empty();
                     }
                     workers += 1;
-                    var next = function () {
-                        workers -= 1;
-                        if (task.callback) {
-                            task.callback.apply(task, arguments);
-                        }
-                        if (q.drain && q.tasks.length + workers === 0) {
-                            q.drain();
-                        }
-                        q.process();
-                    };
                     var cb = only_once(next);
-                    worker(task.data, cb);
+                    worker(data, cb);
+                }
+
+                function next() {
+                    workers -= 1;
+                    var args = arguments;
+                    _arrayEach(tasks, function (task) {
+                        task.callback.apply(task, args);
+                    });
+                    if (q.tasks.length + workers === 0) {
+                        q.drain();
+                    }
+                    q.process();
                 }
             },
             length: function () {
@@ -977,7 +897,6 @@
                 return q.tasks.length + workers === 0;
             },
             pause: function () {
-                if (q.paused === true) { return; }
                 q.paused = true;
             },
             resume: function () {
@@ -991,58 +910,65 @@
                 }
             }
         };
+        return q;
+    }
+
+    async.queue = function (worker, concurrency) {
+        var q = _queue(function (items, cb) {
+            worker(items[0], cb);
+        }, concurrency, 1);
+
         return q;
     };
 
     async.priorityQueue = function (worker, concurrency) {
 
         function _compareTasks(a, b){
-          return a.priority - b.priority;
+            return a.priority - b.priority;
         }
 
         function _binarySearch(sequence, item, compare) {
           var beg = -1,
               end = sequence.length - 1;
           while (beg < end) {
-            var mid = beg + ((end - beg + 1) >>> 1);
-            if (compare(item, sequence[mid]) >= 0) {
-              beg = mid;
-            } else {
-              end = mid - 1;
-            }
+              var mid = beg + ((end - beg + 1) >>> 1);
+              if (compare(item, sequence[mid]) >= 0) {
+                  beg = mid;
+              } else {
+                  end = mid - 1;
+              }
           }
           return beg;
         }
 
         function _insert(q, data, priority, callback) {
-          if (!q.started){
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
             q.started = true;
-          }
-          if (!_isArray(data)) {
-              data = [data];
-          }
-          if(data.length === 0) {
-             // call drain immediately if there are no tasks
-             return async.setImmediate(function() {
-                 if (q.drain) {
-                     q.drain();
-                 }
-             });
-          }
-          _each(data, function(task) {
-              var item = {
-                  data: task,
-                  priority: priority,
-                  callback: typeof callback === 'function' ? callback : null
-              };
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                    q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    priority: priority,
+                    callback: typeof callback === 'function' ? callback : noop
+                };
 
-              q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
+                q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
 
-              if (q.saturated && q.tasks.length === q.concurrency) {
-                  q.saturated();
-              }
-              async.setImmediate(q.process);
-          });
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+                async.setImmediate(q.process);
+            });
         }
 
         // Start with a normal queue
@@ -1050,7 +976,7 @@
 
         // Override push to accept second parameter representing priority
         q.push = function (data, priority, callback) {
-          _insert(q, data, priority, callback);
+            _insert(q, data, priority, callback);
         };
 
         // Remove unshift function
@@ -1060,74 +986,10 @@
     };
 
     async.cargo = function (worker, payload) {
-        var working     = false,
-            tasks       = [];
-
-        var cargo = {
-            tasks: tasks,
-            payload: payload,
-            saturated: null,
-            empty: null,
-            drain: null,
-            drained: true,
-            push: function (data, callback) {
-                if (!_isArray(data)) {
-                    data = [data];
-                }
-                _each(data, function(task) {
-                    tasks.push({
-                        data: task,
-                        callback: typeof callback === 'function' ? callback : null
-                    });
-                    cargo.drained = false;
-                    if (cargo.saturated && tasks.length === payload) {
-                        cargo.saturated();
-                    }
-                });
-                async.setImmediate(cargo.process);
-            },
-            process: function process() {
-                if (working) return;
-                if (tasks.length === 0) {
-                    if(cargo.drain && !cargo.drained) cargo.drain();
-                    cargo.drained = true;
-                    return;
-                }
-
-                var ts = typeof payload === 'number' ?
-                    tasks.splice(0, payload) :
-                    tasks.splice(0, tasks.length);
-
-                var ds = _map(ts, function (task) {
-                    return task.data;
-                });
-
-                if(cargo.empty) cargo.empty();
-                working = true;
-                worker(ds, function () {
-                    working = false;
-
-                    var args = arguments;
-                    _each(ts, function (data) {
-                        if (data.callback) {
-                            data.callback.apply(null, args);
-                        }
-                    });
-
-                    process();
-                });
-            },
-            length: function () {
-                return tasks.length;
-            },
-            running: function () {
-                return working;
-            }
-        };
-        return cargo;
+        return _queue(worker, 1, payload);
     };
 
-    var _console_fn = function (name) {
+    function _console_fn(name) {
         return function (fn) {
             var args = _baseSlice(arguments, 1);
             fn.apply(null, args.concat([function (err) {
@@ -1139,14 +1001,14 @@
                         }
                     }
                     else if (console[name]) {
-                        _each(args, function (x) {
+                        _arrayEach(args, function (x) {
                             console[name](x);
                         });
                     }
                 }
             }]));
         };
-    };
+    }
     async.log = _console_fn('log');
     async.dir = _console_fn('dir');
     /*async.info = _console_fn('info');
@@ -1159,7 +1021,7 @@
         hasher = hasher || function (x) {
             return x;
         };
-        var memoized = function () {
+        function memoized() {
             var args = _baseSlice(arguments);
             var callback = args.pop();
             var key = hasher.apply(null, args);
@@ -1182,7 +1044,7 @@
                     }
                 }]));
             }
-        };
+        }
         memoized.memo = memo;
         memoized.unmemoized = fn;
         return memoized;
@@ -1215,7 +1077,14 @@
         return function () {
             var that = this;
             var args = _baseSlice(arguments);
-            var callback = args.pop();
+
+            var callback = args.slice(-1)[0];
+            if (typeof callback == 'function') {
+                args.pop();
+            } else {
+                callback = noop;
+            }
+
             async.reduce(fns, args, function (newargs, fn, cb) {
                 fn.apply(that, newargs.concat([function () {
                     var err = arguments[0];
@@ -1233,16 +1102,17 @@
       return async.seq.apply(null, Array.prototype.reverse.call(arguments));
     };
 
-    var _applyEach = function (eachfn, fns /*args...*/) {
-        var go = function () {
+
+    function _applyEach(eachfn, fns /*args...*/) {
+        function go() {
             var that = this;
             var args = _baseSlice(arguments);
             var callback = args.pop();
-            return eachfn(fns, function (fn, cb) {
+            return eachfn(fns, function (fn, _, cb) {
                 fn.apply(that, args.concat([cb]));
             },
             callback);
-        };
+        }
         if (arguments.length > 2) {
             var args = _baseSlice(arguments, 2);
             return go.apply(this, args);
@@ -1250,23 +1120,52 @@
         else {
             return go;
         }
+    }
+
+    async.applyEach = function (/*fns, args...*/) {
+        var args = _baseSlice(arguments);
+        return _applyEach.apply(null, [async.eachOf].concat(args));
+    };
+    async.applyEachSeries = function (/*fns, args...*/) {
+        var args = _baseSlice(arguments);
+        return _applyEach.apply(null, [async.eachOfSeries].concat(args));
     };
-    async.applyEach = doParallel(_applyEach);
-    async.applyEachSeries = doSeries(_applyEach);
+
 
     async.forever = function (fn, callback) {
+        var done = only_once(callback || noop);
+        var task = ensureAsync(fn);
         function next(err) {
             if (err) {
-                if (callback) {
-                    return callback(err);
-                }
-                throw err;
+                return done(err);
             }
-            fn(next);
+            task(next);
         }
         next();
     };
 
+    function ensureAsync(fn) {
+        return function (/*...args, callback*/) {
+            var args = _baseSlice(arguments);
+            var callback = args.pop();
+            args.push(function () {
+                var innerArgs = arguments;
+                if (sync) {
+                    async.setImmediate(function () {
+                        callback.apply(null, innerArgs);
+                    });
+                } else {
+                    callback.apply(null, innerArgs);
+                }
+            });
+            var sync = true;
+            fn.apply(this, args);
+            sync = false;
+        };
+    }
+
+    async.ensureAsync = ensureAsync;
+
     // Node.js
     if (typeof module !== 'undefined' && module.exports) {
         module.exports = async;