async-rails 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d28e11df0279381c8d0e03b6a2f51ecf9253846
-  data.tar.gz: e2e6a3d8e860fdab23ae6534d7700e56f670a7a0
+  metadata.gz: 6a7bd80f3580610ce08bedf6109fff6f54ad7120
+  data.tar.gz: 3a8ad7537bc492c85e8a40b21d7e1054ca23de3c
 SHA512:
-  metadata.gz: 053811083f01269722e23d9f066d2d4846aa0ef8474717361f3d09b55fcb344614db1096792cce018b86bfe7b65df2302940861d351bbcfbc0e86a03ff45cc3b
-  data.tar.gz: 8606494455f7a21cf80951e24c9e280aa1a500c003382282e78e15d41518a77bc978ca66d32e4eca9c017d6796bdac03a0fb8d291a1da71a3cd3626585165e57
+  metadata.gz: d8072b21d7c64f39aab41ad85caa776f23ca9c082bc5cbc360c85c8085c6a98bf1022fc6a03447229a4576e9c2adfe826fb3d97522b44bc192ffc008963abeb7
+  data.tar.gz: bf2475def426eab8bd83e68f9938ad61d60c5e91d9d24acd8c5f5400b95424d5feab615ae1b8520aeb84304eb21250374618c144da8c0444f4ce0526fe285e49

data/lib/async-rails/version.rb

@@ -1,5 +1,5 @@
 module Async
   module Rails
-    VERSION = "1.3.0"
+    VERSION = "1.4.0"
   end
 end

data/vendor/assets/javascripts/async.js

@@ -9,6 +9,15 @@
 
     var async = {};
     function noop() {}
+    function identity(v) {
+        return v;
+    }
+    function toBool(v) {
+        return !!v;
+    }
+    function notId(v) {
+        return !v;
+    }
 
     // global on the server, window in the browser
     var previous_async;
@@ -30,20 +39,18 @@
     };
 
     function only_once(fn) {
-        var called = false;
         return function() {
-            if (called) throw new Error("Callback was already called.");
-            called = true;
+            if (fn === null) throw new Error("Callback was already called.");
             fn.apply(this, arguments);
+            fn = null;
         };
     }
 
     function _once(fn) {
-        var called = false;
         return function() {
-            if (called) return;
-            called = true;
+            if (fn === null) return;
             fn.apply(this, arguments);
+            fn = null;
         };
     }
 
@@ -107,6 +114,13 @@
         });
     }
 
+    function _indexOf(arr, item) {
+        for (var i = 0; i < arr.length; i++) {
+            if (arr[i] === item) return i;
+        }
+        return -1;
+    }
+
     var _keys = Object.keys || function (obj) {
         var keys = [];
         for (var k in obj) {
@@ -137,21 +151,30 @@
         }
     }
 
-    function _baseSlice(arr, start) {
-        start = start || 0;
-        var index = -1;
-        var length = arr.length;
-
-        if (start) {
-            length -= start;
-            length = length < 0 ? 0 : length;
-        }
-        var result = Array(length);
-
-        while (++index < length) {
-            result[index] = arr[index + start];
-        }
-        return result;
+    // Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html)
+    // This accumulates the arguments passed into an array, after a given index.
+    // From underscore.js (https://github.com/jashkenas/underscore/pull/2140).
+    function _restParam(func, startIndex) {
+        startIndex = startIndex == null ? func.length - 1 : +startIndex;
+        return function() {
+            var length = Math.max(arguments.length - startIndex, 0);
+            var rest = Array(length);
+            for (var index = 0; index < length; index++) {
+                rest[index] = arguments[index + startIndex];
+            }
+            switch (startIndex) {
+                case 0: return func.call(this, rest);
+                case 1: return func.call(this, arguments[0], rest);
+                case 2: return func.call(this, arguments[0], arguments[1], rest);
+            }
+            // Currently unused but handle cases outside of the switch statement:
+            // var args = Array(startIndex + 1);
+            // for (index = 0; index < startIndex; index++) {
+            //     args[index] = arguments[index];
+            // }
+            // args[startIndex] = rest;
+            // return func.apply(this, args);
+        };
     }
 
     function _withoutIndex(iterator) {
@@ -165,38 +188,22 @@
     //// nextTick implementation with browser-compatible fallback ////
 
     // capture the global reference to guard against fakeTimer mocks
-    var _setImmediate;
-    if (typeof setImmediate === 'function') {
-        _setImmediate = setImmediate;
-    }
+    var _setImmediate = typeof setImmediate === 'function' && setImmediate;
 
-    if (typeof process === 'undefined' || !(process.nextTick)) {
-        if (_setImmediate) {
-            async.nextTick = function (fn) {
-                // not a direct alias for IE10 compatibility
-                _setImmediate(fn);
-            };
-            async.setImmediate = async.nextTick;
-        }
-        else {
-            async.nextTick = function (fn) {
-                setTimeout(fn, 0);
-            };
-            async.setImmediate = async.nextTick;
-        }
-    }
-    else {
+    var _delay = _setImmediate ? function(fn) {
+        // not a direct alias for IE10 compatibility
+        _setImmediate(fn);
+    } : function(fn) {
+        setTimeout(fn, 0);
+    };
+
+    if (typeof process === 'object' && typeof process.nextTick === 'function') {
         async.nextTick = process.nextTick;
-        if (_setImmediate) {
-            async.setImmediate = function (fn) {
-              // not a direct alias for IE10 compatibility
-                _setImmediate(fn);
-            };
-        }
-        else {
-            async.setImmediate = async.nextTick;
-        }
+    } else {
+        async.nextTick = _delay;
     }
+    async.setImmediate = _setImmediate ? _delay : async.nextTick;
+
 
     async.forEach =
     async.each = function (arr, iterator, callback) {
@@ -328,8 +335,8 @@
             return fn(async.eachOf, obj, iterator, callback);
         };
     }
-    function doParallelLimit(limit, fn) {
-        return function (obj, iterator, callback) {
+    function doParallelLimit(fn) {
+        return function (obj, limit, iterator, callback) {
             return fn(_eachOfLimit(limit), obj, iterator, callback);
         };
     }
@@ -354,13 +361,7 @@
 
     async.map = doParallel(_asyncMap);
     async.mapSeries = doSeries(_asyncMap);
-    async.mapLimit = function (arr, limit, iterator, callback) {
-        return _mapLimit(limit)(arr, iterator, callback);
-    };
-
-    function _mapLimit(limit) {
-        return doParallelLimit(limit, _asyncMap);
-    }
+    async.mapLimit = doParallelLimit(_asyncMap);
 
     // reduce only has a series version, as doing reduce in parallel won't
     // work in many situations.
@@ -379,21 +380,16 @@
 
     async.foldr =
     async.reduceRight = function (arr, memo, iterator, callback) {
-        var reversed = _map(arr, function (x) {
-            return x;
-        }).reverse();
+        var reversed = _map(arr, identity).reverse();
         async.reduce(reversed, memo, 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, index, callback) {
-            iterator(x.value, function (v) {
+            iterator(x, function (v) {
                 if (v) {
-                    results.push(x);
+                    results.push({index: index, value: x});
                 }
                 callback();
             });
@@ -409,6 +405,9 @@
     async.select =
     async.filter = doParallel(_filter);
 
+    async.selectLimit =
+    async.filterLimit = doParallelLimit(_filter);
+
     async.selectSeries =
     async.filterSeries = doSeries(_filter);
 
@@ -420,55 +419,49 @@
         }, callback);
     }
     async.reject = doParallel(_reject);
+    async.rejectLimit = doParallelLimit(_reject);
     async.rejectSeries = doSeries(_reject);
 
-    function _detect(eachfn, arr, iterator, main_callback) {
-        eachfn(arr, function (x, index, callback) {
-            iterator(x, function (result) {
-                if (result) {
-                    main_callback(x);
-                    main_callback = noop;
-                }
-                else {
+    function _createTester(eachfn, check, getResult) {
+        return function(arr, limit, iterator, cb) {
+            function done() {
+                if (cb) cb(getResult(false, void 0));
+            }
+            function iteratee(x, _, callback) {
+                if (!cb) return callback();
+                iterator(x, function (v) {
+                    if (cb && check(v)) {
+                        cb(getResult(true, x));
+                        cb = iterator = false;
+                    }
                     callback();
-                }
-            });
-        }, function () {
-            main_callback();
-        });
+                });
+            }
+            if (arguments.length > 3) {
+                eachfn(arr, limit, iteratee, done);
+            } else {
+                cb = iterator;
+                iterator = limit;
+                eachfn(arr, iteratee, done);
+            }
+        };
     }
-    async.detect = doParallel(_detect);
-    async.detectSeries = doSeries(_detect);
 
     async.any =
-    async.some = function (arr, iterator, main_callback) {
-        async.eachOf(arr, function (x, _, callback) {
-            iterator(x, function (v) {
-                if (v) {
-                    main_callback(true);
-                    main_callback = noop;
-                }
-                callback();
-            });
-        }, function () {
-            main_callback(false);
-        });
-    };
+    async.some = _createTester(async.eachOf, toBool, identity);
+
+    async.someLimit = _createTester(async.eachOfLimit, toBool, identity);
 
     async.all =
-    async.every = function (arr, iterator, main_callback) {
-        async.eachOf(arr, function (x, _, callback) {
-            iterator(x, function (v) {
-                if (!v) {
-                    main_callback(false);
-                    main_callback = noop;
-                }
-                callback();
-            });
-        }, function () {
-            main_callback(true);
-        });
-    };
+    async.every = _createTester(async.eachOf, notId, notId);
+
+    async.everyLimit = _createTester(async.eachOfLimit, notId, notId);
+
+    function _findGetResult(v, x) {
+        return x;
+    }
+    async.detect = _createTester(async.eachOf, identity, _findGetResult);
+    async.detectSeries = _createTester(async.eachOfSeries, identity, _findGetResult);
 
     async.sortBy = function (arr, iterator, callback) {
         async.map(arr, function (x, callback) {
@@ -513,12 +506,8 @@
             listeners.unshift(fn);
         }
         function removeListener(fn) {
-            for (var i = 0; i < listeners.length; i += 1) {
-                if (listeners[i] === fn) {
-                    listeners.splice(i, 1);
-                    return;
-                }
-            }
+            var idx = _indexOf(listeners, fn);
+            if (idx >= 0) listeners.splice(idx, 1);
         }
         function taskComplete() {
             remainingTasks--;
@@ -535,15 +524,14 @@
 
         _arrayEach(keys, function (k) {
             var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
-            function taskCallback(err) {
-                var args = _baseSlice(arguments, 1);
+            var taskCallback = _restParam(function(err, args) {
                 if (args.length <= 1) {
                     args = args[0];
                 }
                 if (err) {
                     var safeResults = {};
-                    _arrayEach(_keys(results), function(rkey) {
-                        safeResults[rkey] = results[rkey];
+                    _forEachOf(results, function(val, rkey) {
+                        safeResults[rkey] = val;
                     });
                     safeResults[k] = args;
                     callback(err, safeResults);
@@ -552,8 +540,8 @@
                     results[k] = args;
                     async.setImmediate(taskComplete);
                 }
-            }
-            var requires = task.slice(0, Math.abs(task.length - 1)) || [];
+            });
+            var requires = task.slice(0, task.length - 1);
             // prevent dead-locks
             var len = requires.length;
             var dep;
@@ -561,7 +549,7 @@
                 if (!(dep = tasks[requires[len]])) {
                     throw new Error('Has inexistant dependency');
                 }
-                if (_isArray(dep) && !!~dep.indexOf(k)) {
+                if (_isArray(dep) && _indexOf(dep, k) >= 0) {
                     throw new Error('Has cyclic dependencies');
                 }
             }
@@ -587,53 +575,40 @@
 
 
 
-    async.retry = function(/*[times,] task [, callback]*/) {
+    async.retry = function(times, task, callback) {
         var DEFAULT_TIMES = 5;
         var DEFAULT_INTERVAL = 0;
 
         var attempts = [];
 
         var opts = {
-          times: DEFAULT_TIMES,
-          interval: DEFAULT_INTERVAL
+            times: DEFAULT_TIMES,
+            interval: DEFAULT_INTERVAL
         };
 
         function parseTimes(acc, t){
-          if(typeof t === 'number'){
-            acc.times = parseInt(t, 10) || DEFAULT_TIMES;
-          } else if(typeof t === 'object'){
-            acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
-            acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
-          } else {
-            throw new Error('Unsupported argument type for \'times\': ' + typeof(t));
-          }
+            if(typeof t === 'number'){
+                acc.times = parseInt(t, 10) || DEFAULT_TIMES;
+            } else if(typeof t === 'object'){
+                acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
+                acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
+            } else {
+                throw new Error('Unsupported argument type for \'times\': ' + typeof(t));
+            }
         }
 
-        switch(arguments.length){
-            case 1: {
-              opts.task = arguments[0];
-              break;
-            }
-            case 2 : {
-              if(typeof arguments[0] === 'number' || typeof arguments[0] === 'object'){
-                parseTimes(opts, arguments[0]);
-                opts.task = arguments[1];
-              } else {
-                opts.task = arguments[0];
-                opts.callback = arguments[1];
-              }
-              break;
-            }
-            case 3: {
-              parseTimes(opts, arguments[0]);
-              opts.task = arguments[1];
-              opts.callback = arguments[2];
-              break;
-            }
-            default: {
-              throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
-            }
-          }
+        var length = arguments.length;
+        if (length < 1 || length > 3) {
+            throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
+        } else if (length <= 2 && typeof times === 'function') {
+            callback = task;
+            task = times;
+        }
+        if (typeof times !== 'function') {
+            parseTimes(opts, times);
+        }
+        opts.callback = callback;
+        opts.task = task;
 
         function wrappedTask(wrappedCallback, wrappedResults) {
             function retryAttempt(task, finalAttempt) {
@@ -645,11 +620,11 @@
             }
 
             function retryInterval(interval){
-              return function(seriesCallback){
-                setTimeout(function(){
-                  seriesCallback(null);
-                }, interval);
-              };
+                return function(seriesCallback){
+                    setTimeout(function(){
+                        seriesCallback(null);
+                    }, interval);
+                };
             }
 
             while (opts.times) {
@@ -657,7 +632,7 @@
                 var finalAttempt = !(opts.times-=1);
                 attempts.push(retryAttempt(opts.task, finalAttempt));
                 if(!finalAttempt && opts.interval > 0){
-                  attempts.push(retryInterval(opts.interval));
+                    attempts.push(retryInterval(opts.interval));
                 }
             }
 
@@ -681,12 +656,11 @@
             return callback();
         }
         function wrapIterator(iterator) {
-            return function (err) {
+            return _restParam(function (err, args) {
                 if (err) {
-                    callback.apply(null, arguments);
+                    callback.apply(null, [err].concat(args));
                 }
                 else {
-                    var args = _baseSlice(arguments, 1);
                     var next = iterator.next();
                     if (next) {
                         args.push(wrapIterator(next));
@@ -696,7 +670,7 @@
                     }
                     ensureAsync(iterator).apply(null, args);
                 }
-            };
+            });
         }
         wrapIterator(async.iterator(tasks))();
     };
@@ -706,14 +680,13 @@
         var results = _isArrayLike(tasks) ? [] : {};
 
         eachfn(tasks, function (task, key, callback) {
-            task(function (err) {
-                var args = _baseSlice(arguments, 1);
+            task(_restParam(function (err, args) {
                 if (args.length <= 1) {
                     args = args[0];
                 }
                 results[key] = args;
                 callback(err);
-            });
+            }));
         }, function (err) {
             callback(err, results);
         });
@@ -727,22 +700,8 @@
         _parallel(_eachOfLimit(limit), tasks, callback);
     };
 
-    async.series = function (tasks, callback) {
-        callback = callback || noop;
-        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];
-                }
-                results[key] = args;
-                callback(err);
-            });
-        }, function (err) {
-            callback(err, results);
-        });
+    async.series = function(tasks, callback) {
+        _parallel(async.eachOfSeries, tasks, callback);
     };
 
     async.iterator = function (tasks) {
@@ -761,14 +720,13 @@
         return makeCallback(0);
     };
 
-    async.apply = function (fn) {
-        var args = _baseSlice(arguments, 1);
-        return function () {
+    async.apply = _restParam(function (fn, args) {
+        return _restParam(function (callArgs) {
             return fn.apply(
-                null, args.concat(_baseSlice(arguments))
+                null, args.concat(callArgs)
             );
-        };
-    };
+        });
+    });
 
     function _concat(eachfn, arr, fn, callback) {
         var result = [];
@@ -787,105 +745,74 @@
     async.whilst = function (test, iterator, callback) {
         callback = callback || noop;
         if (test()) {
-            iterator(function (err) {
+            var next = _restParam(function(err, args) {
                 if (err) {
-                    return callback(err);
+                    callback(err);
+                } else if (test.apply(this, args)) {
+                    iterator(next);
+                } else {
+                    callback(null);
                 }
-                async.whilst(test, iterator, callback);
             });
-        }
-        else {
+            iterator(next);
+        } else {
             callback(null);
         }
     };
 
     async.doWhilst = function (iterator, test, callback) {
-        callback = callback || noop;
-        iterator(function (err) {
-            if (err) {
-                return callback(err);
-            }
-            var args = _baseSlice(arguments, 1);
-            if (test.apply(null, args)) {
-                async.doWhilst(iterator, test, callback);
-            }
-            else {
-                callback(null);
-            }
-        });
+        var calls = 0;
+        return async.whilst(function() {
+            return ++calls <= 1 || test.apply(this, arguments);
+        }, iterator, callback);
     };
 
     async.until = function (test, iterator, callback) {
-        callback = callback || noop;
-        if (!test()) {
-            iterator(function (err) {
-                if (err) {
-                    return callback(err);
-                }
-                async.until(test, iterator, callback);
-            });
-        }
-        else {
-            callback(null);
-        }
+        return async.whilst(function() {
+            return !test.apply(this, arguments);
+        }, iterator, callback);
     };
 
     async.doUntil = function (iterator, test, callback) {
-        callback = callback || noop;
-        iterator(function (err) {
-            if (err) {
-                return callback(err);
-            }
-            var args = _baseSlice(arguments, 1);
-            if (!test.apply(null, args)) {
-                async.doUntil(iterator, test, callback);
-            }
-            else {
-                callback(null);
-            }
-        });
+        return async.doWhilst(iterator, function() {
+            return !test.apply(this, arguments);
+        }, callback);
     };
 
     async.during = function (test, iterator, callback) {
         callback = callback || noop;
-        test(function(err, truth) {
+
+        var next = _restParam(function(err, args) {
             if (err) {
-                return callback(err);
-            }
-            if (truth) {
-                iterator(function (err) {
-                    if (err) {
-                        return callback(err);
-                    }
-                    async.during(test, iterator, callback);
-                });
+                callback(err);
+            } else {
+                args.push(check);
+                test.apply(this, args);
             }
-            else {
+        });
+
+        var check = function(err, truth) {
+            if (err) {
+                callback(err);
+            } else if (truth) {
+                iterator(next);
+            } else {
                 callback(null);
             }
-        });
+        };
+
+        test(check);
     };
 
     async.doDuring = function (iterator, test, callback) {
-        callback = callback || noop;
-        iterator(function (err) {
-            if (err) {
-                return callback(err);
+        var calls = 0;
+        async.during(function(next) {
+            if (calls++ < 1) {
+                next(null, true);
+            } else {
+                test.apply(this, arguments);
             }
-            var args = _baseSlice(arguments, 1);
-            args.push(function (err, truth) {
-                if (err) {
-                   return callback(err);
-                }
-                if (truth) {
-                    async.doDuring(iterator, test, callback);
-                }
-                else {
-                    callback(null);
-                }
-            });
-            test.apply(null, args);
-        });
+        }, iterator, callback);
     };
 
     function _queue(worker, concurrency, payload) {
@@ -906,7 +833,7 @@
             if(data.length === 0 && q.idle()) {
                 // call drain immediately if there are no tasks
                 return async.setImmediate(function() {
-                   q.drain();
+                    q.drain();
                 });
             }
             _arrayEach(data, function(task) {
@@ -1022,17 +949,17 @@
         }
 
         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;
-              }
-          }
-          return beg;
+            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;
+                }
+            }
+            return beg;
         }
 
         function _insert(q, data, priority, callback) {
@@ -1084,10 +1011,8 @@
     };
 
     function _console_fn(name) {
-        return function (fn) {
-            var args = _baseSlice(arguments, 1);
-            fn.apply(null, args.concat([function (err) {
-                var args = _baseSlice(arguments, 1);
+        return _restParam(function (fn, args) {
+            fn.apply(null, args.concat([_restParam(function (err, args) {
                 if (typeof console !== 'undefined') {
                     if (err) {
                         if (console.error) {
@@ -1100,8 +1025,8 @@
                         });
                     }
                 }
-            }]));
-        };
+            })]));
+        });
     }
     async.log = _console_fn('log');
     async.dir = _console_fn('dir');
@@ -1112,11 +1037,8 @@
     async.memoize = function (fn, hasher) {
         var memo = {};
         var queues = {};
-        hasher = hasher || function (x) {
-            return x;
-        };
-        function memoized() {
-            var args = _baseSlice(arguments);
+        hasher = hasher || identity;
+        var memoized = _restParam(function memoized(args) {
             var callback = args.pop();
             var key = hasher.apply(null, args);
             if (key in memo) {
@@ -1129,16 +1051,16 @@
             }
             else {
                 queues[key] = [callback];
-                fn.apply(null, args.concat([function () {
-                    memo[key] = _baseSlice(arguments);
+                fn.apply(null, args.concat([_restParam(function (args) {
+                    memo[key] = args;
                     var q = queues[key];
                     delete queues[key];
                     for (var i = 0, l = q.length; i < l; i++) {
-                      q[i].apply(null, arguments);
+                        q[i].apply(null, args);
                     }
-                }]));
+                })]));
             }
-        }
+        });
         memoized.memo = memo;
         memoized.unmemoized = fn;
         return memoized;
@@ -1164,11 +1086,10 @@
 
     async.seq = function (/* functions... */) {
         var fns = arguments;
-        return function () {
+        return _restParam(function (args) {
             var that = this;
-            var args = _baseSlice(arguments);
 
-            var callback = args.slice(-1)[0];
+            var callback = args[args.length - 1];
             if (typeof callback == 'function') {
                 args.pop();
             } else {
@@ -1176,16 +1097,14 @@
             }
 
             async.reduce(fns, args, function (newargs, fn, cb) {
-                fn.apply(that, newargs.concat([function () {
-                    var err = arguments[0];
-                    var nextargs = _baseSlice(arguments, 1);
+                fn.apply(that, newargs.concat([_restParam(function (err, nextargs) {
                     cb(err, nextargs);
-                }]));
+                })]));
             },
             function (err, results) {
                 callback.apply(that, [err].concat(results));
             });
-        };
+        });
     };
 
     async.compose = function (/* functions... */) {
@@ -1193,33 +1112,27 @@
     };
 
 
-    function _applyEach(eachfn, fns /*args...*/) {
-        function go() {
-            var that = this;
-            var args = _baseSlice(arguments);
-            var callback = args.pop();
-            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);
-        }
-        else {
-            return go;
-        }
+    function _applyEach(eachfn) {
+        return _restParam(function(fns, args) {
+            var go = _restParam(function(args) {
+                var that = this;
+                var callback = args.pop();
+                return eachfn(fns, function (fn, _, cb) {
+                    fn.apply(that, args.concat([cb]));
+                },
+                callback);
+            });
+            if (args.length) {
+                return go.apply(this, args);
+            }
+            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 = _applyEach(async.eachOf);
+    async.applyEachSeries = _applyEach(async.eachOfSeries);
 
 
     async.forever = function (fn, callback) {
@@ -1235,8 +1148,7 @@
     };
 
     function ensureAsync(fn) {
-        return function (/*...args, callback*/) {
-            var args = _baseSlice(arguments);
+        return _restParam(function (args) {
             var callback = args.pop();
             args.push(function () {
                 var innerArgs = arguments;
@@ -1251,22 +1163,21 @@
             var sync = true;
             fn.apply(this, args);
             sync = false;
-        };
+        });
     }
 
     async.ensureAsync = ensureAsync;
 
-    async.constant = function constant(/*values...*/) {
-        var args = [null].concat(_baseSlice(arguments));
+    async.constant = _restParam(function(values) {
+        var args = [null].concat(values);
         return function (callback) {
             return callback.apply(this, args);
         };
-    };
+    });
 
     async.wrapSync =
     async.asyncify = function asyncify(func) {
-        return function (/*args..., callback*/) {
-            var args = _baseSlice(arguments);
+        return _restParam(function (args) {
             var callback = args.pop();
             var result;
             try {
@@ -1274,8 +1185,17 @@
             } catch (e) {
                 return callback(e);
             }
-            callback(null, result);
-        };
+            // if result is Promise object
+            if (typeof result !== 'undefined' && typeof result.then === "function") {
+                result.then(function(value) {
+                    callback(null, value);
+                }).catch(function(err) {
+                    callback(err.message ? err : new Error(err));
+                });
+            } else {
+                callback(null, result);
+            }
+        });
     };
 
     // Node.js

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-rails
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jason Chen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-15 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties