]>
code.delx.au - gnu-emacs-elpa/blob - packages/context-coloring/benchmark/fixtures/async-0.9.0.js
3 * https://github.com/caolan/async
5 * Copyright 2010-2014 Caolan McMahon
6 * Released under the MIT license
8 /*jshint onevar: false, indent:4 */
9 /*global setImmediate: false, setTimeout: false, console: false */
14 // global on the server, window in the browser
15 var root
, previous_async
;
19 previous_async
= root
.async
;
22 async
.noConflict = function () {
23 root
.async
= previous_async
;
27 function only_once(fn
) {
30 if (called
) throw new Error("Callback was already called.");
32 fn
.apply(root
, arguments
);
36 //// cross-browser compatiblity functions ////
38 var _toString
= Object
.prototype.toString
;
40 var _isArray
= Array
.isArray
|| function (obj
) {
41 return _toString
.call(obj
) === '[object Array]';
44 var _each = function (arr
, iterator
) {
46 return arr
.forEach(iterator
);
48 for (var i
= 0; i
< arr
.length
; i
+= 1) {
49 iterator(arr
[i
], i
, arr
);
53 var _map = function (arr
, iterator
) {
55 return arr
.map(iterator
);
58 _each(arr
, function (x
, i
, a
) {
59 results
.push(iterator(x
, i
, a
));
64 var _reduce = function (arr
, iterator
, memo
) {
66 return arr
.reduce(iterator
, memo
);
68 _each(arr
, function (x
, i
, a
) {
69 memo
= iterator(memo
, x
, i
, a
);
74 var _keys = function (obj
) {
76 return Object
.keys(obj
);
80 if (obj
.hasOwnProperty(k
)) {
87 //// exported async module functions ////
89 //// nextTick implementation with browser-compatible fallback ////
90 if (typeof process
=== 'undefined' || !(process
.nextTick
)) {
91 if (typeof setImmediate
=== 'function') {
92 async
.nextTick = function (fn
) {
93 // not a direct alias for IE10 compatibility
96 async
.setImmediate
= async
.nextTick
;
99 async
.nextTick = function (fn
) {
102 async
.setImmediate
= async
.nextTick
;
106 async
.nextTick
= process
.nextTick
;
107 if (typeof setImmediate
!== 'undefined') {
108 async
.setImmediate = function (fn
) {
109 // not a direct alias for IE10 compatibility
114 async
.setImmediate
= async
.nextTick
;
118 async
.each = function (arr
, iterator
, callback
) {
119 callback
= callback
|| function () {};
124 _each(arr
, function (x
) {
125 iterator(x
, only_once(done
) );
130 callback = function () {};
134 if (completed
>= arr
.length
) {
140 async
.forEach
= async
.each
;
142 async
.eachSeries = function (arr
, iterator
, callback
) {
143 callback
= callback
|| function () {};
148 var iterate = function () {
149 iterator(arr
[completed
], function (err
) {
152 callback = function () {};
156 if (completed
>= arr
.length
) {
167 async
.forEachSeries
= async
.eachSeries
;
169 async
.eachLimit = function (arr
, limit
, iterator
, callback
) {
170 var fn
= _eachLimit(limit
);
171 fn
.apply(null, [arr
, iterator
, callback
]);
173 async
.forEachLimit
= async
.eachLimit
;
175 var _eachLimit = function (limit
) {
177 return function (arr
, iterator
, callback
) {
178 callback
= callback
|| function () {};
179 if (!arr
.length
|| limit
<= 0) {
186 (function replenish () {
187 if (completed
>= arr
.length
) {
191 while (running
< limit
&& started
< arr
.length
) {
194 iterator(arr
[started
- 1], function (err
) {
197 callback = function () {};
202 if (completed
>= arr
.length
) {
216 var doParallel = function (fn
) {
218 var args
= Array
.prototype.slice
.call(arguments
);
219 return fn
.apply(null, [async
.each
].concat(args
));
222 var doParallelLimit = function(limit
, fn
) {
224 var args
= Array
.prototype.slice
.call(arguments
);
225 return fn
.apply(null, [_eachLimit(limit
)].concat(args
));
228 var doSeries = function (fn
) {
230 var args
= Array
.prototype.slice
.call(arguments
);
231 return fn
.apply(null, [async
.eachSeries
].concat(args
));
236 var _asyncMap = function (eachfn
, arr
, iterator
, callback
) {
237 arr
= _map(arr
, function (x
, i
) {
238 return {index
: i
, value
: x
};
241 eachfn(arr
, function (x
, callback
) {
242 iterator(x
.value
, function (err
) {
248 eachfn(arr
, function (x
, callback
) {
249 iterator(x
.value
, function (err
, v
) {
250 results
[x
.index
] = v
;
254 callback(err
, results
);
258 async
.map
= doParallel(_asyncMap
);
259 async
.mapSeries
= doSeries(_asyncMap
);
260 async
.mapLimit = function (arr
, limit
, iterator
, callback
) {
261 return _mapLimit(limit
)(arr
, iterator
, callback
);
264 var _mapLimit = function(limit
) {
265 return doParallelLimit(limit
, _asyncMap
);
268 // reduce only has a series version, as doing reduce in parallel won't
269 // work in many situations.
270 async
.reduce = function (arr
, memo
, iterator
, callback
) {
271 async
.eachSeries(arr
, function (x
, callback
) {
272 iterator(memo
, x
, function (err
, v
) {
281 async
.inject
= async
.reduce
;
283 async
.foldl
= async
.reduce
;
285 async
.reduceRight = function (arr
, memo
, iterator
, callback
) {
286 var reversed
= _map(arr
, function (x
) {
289 async
.reduce(reversed
, memo
, iterator
, callback
);
292 async
.foldr
= async
.reduceRight
;
294 var _filter = function (eachfn
, arr
, iterator
, callback
) {
296 arr
= _map(arr
, function (x
, i
) {
297 return {index
: i
, value
: x
};
299 eachfn(arr
, function (x
, callback
) {
300 iterator(x
.value
, function (v
) {
307 callback(_map(results
.sort(function (a
, b
) {
308 return a
.index
- b
.index
;
314 async
.filter
= doParallel(_filter
);
315 async
.filterSeries
= doSeries(_filter
);
317 async
.select
= async
.filter
;
318 async
.selectSeries
= async
.filterSeries
;
320 var _reject = function (eachfn
, arr
, iterator
, callback
) {
322 arr
= _map(arr
, function (x
, i
) {
323 return {index
: i
, value
: x
};
325 eachfn(arr
, function (x
, callback
) {
326 iterator(x
.value
, function (v
) {
333 callback(_map(results
.sort(function (a
, b
) {
334 return a
.index
- b
.index
;
340 async
.reject
= doParallel(_reject
);
341 async
.rejectSeries
= doSeries(_reject
);
343 var _detect = function (eachfn
, arr
, iterator
, main_callback
) {
344 eachfn(arr
, function (x
, callback
) {
345 iterator(x
, function (result
) {
348 main_callback = function () {};
358 async
.detect
= doParallel(_detect
);
359 async
.detectSeries
= doSeries(_detect
);
361 async
.some = function (arr
, iterator
, main_callback
) {
362 async
.each(arr
, function (x
, callback
) {
363 iterator(x
, function (v
) {
366 main_callback = function () {};
371 main_callback(false);
375 async
.any
= async
.some
;
377 async
.every = function (arr
, iterator
, main_callback
) {
378 async
.each(arr
, function (x
, callback
) {
379 iterator(x
, function (v
) {
381 main_callback(false);
382 main_callback = function () {};
391 async
.all
= async
.every
;
393 async
.sortBy = function (arr
, iterator
, callback
) {
394 async
.map(arr
, function (x
, callback
) {
395 iterator(x
, function (err
, criteria
) {
400 callback(null, {value
: x
, criteria
: criteria
});
403 }, function (err
, results
) {
405 return callback(err
);
408 var fn = function (left
, right
) {
409 var a
= left
.criteria
, b
= right
.criteria
;
410 return a
< b
? -1 : a
> b
? 1 : 0;
412 callback(null, _map(results
.sort(fn
), function (x
) {
419 async
.auto = function (tasks
, callback
) {
420 callback
= callback
|| function () {};
421 var keys
= _keys(tasks
);
422 var remainingTasks
= keys
.length
423 if (!remainingTasks
) {
430 var addListener = function (fn
) {
431 listeners
.unshift(fn
);
433 var removeListener = function (fn
) {
434 for (var i
= 0; i
< listeners
.length
; i
+= 1) {
435 if (listeners
[i
] === fn
) {
436 listeners
.splice(i
, 1);
441 var taskComplete = function () {
443 _each(listeners
.slice(0), function (fn
) {
448 addListener(function () {
449 if (!remainingTasks
) {
450 var theCallback
= callback
;
451 // prevent final callback from calling itself if it errors
452 callback = function () {};
454 theCallback(null, results
);
458 _each(keys
, function (k
) {
459 var task
= _isArray(tasks
[k
]) ? tasks
[k
]: [tasks
[k
]];
460 var taskCallback = function (err
) {
461 var args
= Array
.prototype.slice
.call(arguments
, 1);
462 if (args
.length
<= 1) {
466 var safeResults
= {};
467 _each(_keys(results
), function(rkey
) {
468 safeResults
[rkey
] = results
[rkey
];
470 safeResults
[k
] = args
;
471 callback(err
, safeResults
);
472 // stop subsequent errors hitting callback multiple times
473 callback = function () {};
477 async
.setImmediate(taskComplete
);
480 var requires
= task
.slice(0, Math
.abs(task
.length
- 1)) || [];
481 var ready = function () {
482 return _reduce(requires
, function (a
, x
) {
483 return (a
&& results
.hasOwnProperty(x
));
484 }, true) && !results
.hasOwnProperty(k
);
487 task
[task
.length
- 1](taskCallback
, results
);
490 var listener = function () {
492 removeListener(listener
);
493 task
[task
.length
- 1](taskCallback
, results
);
496 addListener(listener
);
501 async
.retry = function(times
, task
, callback
) {
502 var DEFAULT_TIMES
= 5;
504 // Use defaults if times not passed
505 if (typeof times
=== 'function') {
508 times
= DEFAULT_TIMES
;
510 // Make sure times is a number
511 times
= parseInt(times
, 10) || DEFAULT_TIMES
;
512 var wrappedTask = function(wrappedCallback
, wrappedResults
) {
513 var retryAttempt = function(task
, finalAttempt
) {
514 return function(seriesCallback
) {
515 task(function(err
, result
){
516 seriesCallback(!err
|| finalAttempt
, {err
: err
, result
: result
});
521 attempts
.push(retryAttempt(task
, !(times
-=1)));
523 async
.series(attempts
, function(done
, data
){
524 data
= data
[data
.length
- 1];
525 (wrappedCallback
|| callback
)(data
.err
, data
.result
);
528 // If a callback is passed, run this as a controll flow
529 return callback
? wrappedTask() : wrappedTask
532 async
.waterfall = function (tasks
, callback
) {
533 callback
= callback
|| function () {};
534 if (!_isArray(tasks
)) {
535 var err
= new Error('First argument to waterfall must be an array of functions');
536 return callback(err
);
541 var wrapIterator = function (iterator
) {
542 return function (err
) {
544 callback
.apply(null, arguments
);
545 callback = function () {};
548 var args
= Array
.prototype.slice
.call(arguments
, 1);
549 var next
= iterator
.next();
551 args
.push(wrapIterator(next
));
556 async
.setImmediate(function () {
557 iterator
.apply(null, args
);
562 wrapIterator(async
.iterator(tasks
))();
565 var _parallel = function(eachfn
, tasks
, callback
) {
566 callback
= callback
|| function () {};
567 if (_isArray(tasks
)) {
568 eachfn
.map(tasks
, function (fn
, callback
) {
571 var args
= Array
.prototype.slice
.call(arguments
, 1);
572 if (args
.length
<= 1) {
575 callback
.call(null, err
, args
);
582 eachfn
.each(_keys(tasks
), function (k
, callback
) {
583 tasks
[k
](function (err
) {
584 var args
= Array
.prototype.slice
.call(arguments
, 1);
585 if (args
.length
<= 1) {
592 callback(err
, results
);
597 async
.parallel = function (tasks
, callback
) {
598 _parallel({ map
: async
.map
, each
: async
.each
}, tasks
, callback
);
601 async
.parallelLimit = function(tasks
, limit
, callback
) {
602 _parallel({ map
: _mapLimit(limit
), each
: _eachLimit(limit
) }, tasks
, callback
);
605 async
.series = function (tasks
, callback
) {
606 callback
= callback
|| function () {};
607 if (_isArray(tasks
)) {
608 async
.mapSeries(tasks
, function (fn
, callback
) {
611 var args
= Array
.prototype.slice
.call(arguments
, 1);
612 if (args
.length
<= 1) {
615 callback
.call(null, err
, args
);
622 async
.eachSeries(_keys(tasks
), function (k
, callback
) {
623 tasks
[k
](function (err
) {
624 var args
= Array
.prototype.slice
.call(arguments
, 1);
625 if (args
.length
<= 1) {
632 callback(err
, results
);
637 async
.iterator = function (tasks
) {
638 var makeCallback = function (index
) {
639 var fn = function () {
641 tasks
[index
].apply(null, arguments
);
645 fn
.next = function () {
646 return (index
< tasks
.length
- 1) ? makeCallback(index
+ 1): null;
650 return makeCallback(0);
653 async
.apply = function (fn
) {
654 var args
= Array
.prototype.slice
.call(arguments
, 1);
657 null, args
.concat(Array
.prototype.slice
.call(arguments
))
662 var _concat = function (eachfn
, arr
, fn
, callback
) {
664 eachfn(arr
, function (x
, cb
) {
665 fn(x
, function (err
, y
) {
666 r
= r
.concat(y
|| []);
673 async
.concat
= doParallel(_concat
);
674 async
.concatSeries
= doSeries(_concat
);
676 async
.whilst = function (test
, iterator
, callback
) {
678 iterator(function (err
) {
680 return callback(err
);
682 async
.whilst(test
, iterator
, callback
);
690 async
.doWhilst = function (iterator
, test
, callback
) {
691 iterator(function (err
) {
693 return callback(err
);
695 var args
= Array
.prototype.slice
.call(arguments
, 1);
696 if (test
.apply(null, args
)) {
697 async
.doWhilst(iterator
, test
, callback
);
705 async
.until = function (test
, iterator
, callback
) {
707 iterator(function (err
) {
709 return callback(err
);
711 async
.until(test
, iterator
, callback
);
719 async
.doUntil = function (iterator
, test
, callback
) {
720 iterator(function (err
) {
722 return callback(err
);
724 var args
= Array
.prototype.slice
.call(arguments
, 1);
725 if (!test
.apply(null, args
)) {
726 async
.doUntil(iterator
, test
, callback
);
734 async
.queue = function (worker
, concurrency
) {
735 if (concurrency
=== undefined) {
738 function _insert(q
, data
, pos
, callback
) {
742 if (!_isArray(data
)) {
745 if(data
.length
== 0) {
746 // call drain immediately if there are no tasks
747 return async
.setImmediate(function() {
753 _each(data
, function(task
) {
756 callback
: typeof callback
=== 'function' ? callback
: null
760 q
.tasks
.unshift(item
);
765 if (q
.saturated
&& q
.tasks
.length
=== q
.concurrency
) {
768 async
.setImmediate(q
.process
);
775 concurrency
: concurrency
,
781 push: function (data
, callback
) {
782 _insert(q
, data
, false, callback
);
788 unshift: function (data
, callback
) {
789 _insert(q
, data
, true, callback
);
791 process: function () {
792 if (!q
.paused
&& workers
< q
.concurrency
&& q
.tasks
.length
) {
793 var task
= q
.tasks
.shift();
794 if (q
.empty
&& q
.tasks
.length
=== 0) {
798 var next = function () {
801 task
.callback
.apply(task
, arguments
);
803 if (q
.drain
&& q
.tasks
.length
+ workers
=== 0) {
808 var cb
= only_once(next
);
809 worker(task
.data
, cb
);
812 length: function () {
813 return q
.tasks
.length
;
815 running: function () {
819 return q
.tasks
.length
+ workers
=== 0;
822 if (q
.paused
=== true) { return; }
826 resume: function () {
827 if (q
.paused
=== false) { return; }
835 async
.priorityQueue = function (worker
, concurrency
) {
837 function _compareTasks(a
, b
){
838 return a
.priority
- b
.priority
;
841 function _binarySearch(sequence
, item
, compare
) {
843 end
= sequence
.length
- 1;
845 var mid
= beg
+ ((end
- beg
+ 1) >>> 1);
846 if (compare(item
, sequence
[mid
]) >= 0) {
855 function _insert(q
, data
, priority
, callback
) {
859 if (!_isArray(data
)) {
862 if(data
.length
== 0) {
863 // call drain immediately if there are no tasks
864 return async
.setImmediate(function() {
870 _each(data
, function(task
) {
874 callback
: typeof callback
=== 'function' ? callback
: null
877 q
.tasks
.splice(_binarySearch(q
.tasks
, item
, _compareTasks
) + 1, 0, item
);
879 if (q
.saturated
&& q
.tasks
.length
=== q
.concurrency
) {
882 async
.setImmediate(q
.process
);
886 // Start with a normal queue
887 var q
= async
.queue(worker
, concurrency
);
889 // Override push to accept second parameter representing priority
890 q
.push = function (data
, priority
, callback
) {
891 _insert(q
, data
, priority
, callback
);
894 // Remove unshift function
900 async
.cargo = function (worker
, payload
) {
911 push: function (data
, callback
) {
912 if (!_isArray(data
)) {
915 _each(data
, function(task
) {
918 callback
: typeof callback
=== 'function' ? callback
: null
920 cargo
.drained
= false;
921 if (cargo
.saturated
&& tasks
.length
=== payload
) {
925 async
.setImmediate(cargo
.process
);
927 process
: function process() {
929 if (tasks
.length
=== 0) {
930 if(cargo
.drain
&& !cargo
.drained
) cargo
.drain();
931 cargo
.drained
= true;
935 var ts
= typeof payload
=== 'number'
936 ? tasks
.splice(0, payload
)
937 : tasks
.splice(0, tasks
.length
);
939 var ds
= _map(ts
, function (task
) {
943 if(cargo
.empty
) cargo
.empty();
945 worker(ds
, function () {
948 var args
= arguments
;
949 _each(ts
, function (data
) {
951 data
.callback
.apply(null, args
);
958 length: function () {
961 running: function () {
968 var _console_fn = function (name
) {
969 return function (fn
) {
970 var args
= Array
.prototype.slice
.call(arguments
, 1);
971 fn
.apply(null, args
.concat([function (err
) {
972 var args
= Array
.prototype.slice
.call(arguments
, 1);
973 if (typeof console
!== 'undefined') {
979 else if (console
[name
]) {
980 _each(args
, function (x
) {
988 async
.log
= _console_fn('log');
989 async
.dir
= _console_fn('dir');
990 /*async.info = _console_fn('info');
991 async.warn = _console_fn('warn');
992 async.error = _console_fn('error');*/
994 async
.memoize = function (fn
, hasher
) {
997 hasher
= hasher
|| function (x
) {
1000 var memoized = function () {
1001 var args
= Array
.prototype.slice
.call(arguments
);
1002 var callback
= args
.pop();
1003 var key
= hasher
.apply(null, args
);
1005 async
.nextTick(function () {
1006 callback
.apply(null, memo
[key
]);
1009 else if (key
in queues
) {
1010 queues
[key
].push(callback
);
1013 queues
[key
] = [callback
];
1014 fn
.apply(null, args
.concat([function () {
1015 memo
[key
] = arguments
;
1016 var q
= queues
[key
];
1018 for (var i
= 0, l
= q
.length
; i
< l
; i
++) {
1019 q
[i
].apply(null, arguments
);
1024 memoized
.memo
= memo
;
1025 memoized
.unmemoized
= fn
;
1029 async
.unmemoize = function (fn
) {
1030 return function () {
1031 return (fn
.unmemoized
|| fn
).apply(null, arguments
);
1035 async
.times = function (count
, iterator
, callback
) {
1037 for (var i
= 0; i
< count
; i
++) {
1040 return async
.map(counter
, iterator
, callback
);
1043 async
.timesSeries = function (count
, iterator
, callback
) {
1045 for (var i
= 0; i
< count
; i
++) {
1048 return async
.mapSeries(counter
, iterator
, callback
);
1051 async
.seq = function (/* functions... */) {
1052 var fns
= arguments
;
1053 return function () {
1055 var args
= Array
.prototype.slice
.call(arguments
);
1056 var callback
= args
.pop();
1057 async
.reduce(fns
, args
, function (newargs
, fn
, cb
) {
1058 fn
.apply(that
, newargs
.concat([function () {
1059 var err
= arguments
[0];
1060 var nextargs
= Array
.prototype.slice
.call(arguments
, 1);
1064 function (err
, results
) {
1065 callback
.apply(that
, [err
].concat(results
));
1070 async
.compose = function (/* functions... */) {
1071 return async
.seq
.apply(null, Array
.prototype.reverse
.call(arguments
));
1074 var _applyEach = function (eachfn
, fns
/*args...*/) {
1075 var go = function () {
1077 var args
= Array
.prototype.slice
.call(arguments
);
1078 var callback
= args
.pop();
1079 return eachfn(fns
, function (fn
, cb
) {
1080 fn
.apply(that
, args
.concat([cb
]));
1084 if (arguments
.length
> 2) {
1085 var args
= Array
.prototype.slice
.call(arguments
, 2);
1086 return go
.apply(this, args
);
1092 async
.applyEach
= doParallel(_applyEach
);
1093 async
.applyEachSeries
= doSeries(_applyEach
);
1095 async
.forever = function (fn
, callback
) {
1096 function next(err
) {
1099 return callback(err
);
1109 if (typeof module
!== 'undefined' && module
.exports
) {
1110 module
.exports
= async
;
1113 else if (typeof define
!== 'undefined' && define
.amd
) {
1114 define([], function () {
1118 // included directly via <script> tag