libs/js/jquery-mobile-1.2.0/node_modules/testswarm/node_modules/request/node_modules/form-data/node_modules/async/lib/async.js

   1 /*global setTimeout: false, console: false */
   2 (function () {
   3
   4     var async = {};
   5
   6     // global on the server, window in the browser
   7     var root = this,
   8         previous_async = root.async;
   9
  10     if (typeof module !== 'undefined' && module.exports) {
  11         module.exports = async;
  12     }
  13     else {
  14         root.async = async;
  15     }
  16
  17     async.noConflict = function () {
  18         root.async = previous_async;
  19         return async;
  20     };
  21
  22     //// cross-browser compatiblity functions ////
  23
  24     var _forEach = function (arr, iterator) {
  25         if (arr.forEach) {
  26             return arr.forEach(iterator);
  27         }
  28         for (var i = 0; i < arr.length; i += 1) {
  29             iterator(arr[i], i, arr);
  30         }
  31     };
  32
  33     var _map = function (arr, iterator) {
  34         if (arr.map) {
  35             return arr.map(iterator);
  36         }
  37         var results = [];
  38         _forEach(arr, function (x, i, a) {
  39             results.push(iterator(x, i, a));
  40         });
  41         return results;
  42     };
  43
  44     var _reduce = function (arr, iterator, memo) {
  45         if (arr.reduce) {
  46             return arr.reduce(iterator, memo);
  47         }
  48         _forEach(arr, function (x, i, a) {
  49             memo = iterator(memo, x, i, a);
  50         });
  51         return memo;
  52     };
  53
  54     var _keys = function (obj) {
  55         if (Object.keys) {
  56             return Object.keys(obj);
  57         }
  58         var keys = [];
  59         for (var k in obj) {
  60             if (obj.hasOwnProperty(k)) {
  61                 keys.push(k);
  62             }
  63         }
  64         return keys;
  65     };
  66
  67     var _indexOf = function (arr, item) {
  68         if (arr.indexOf) {
  69             return arr.indexOf(item);
  70         }
  71         for (var i = 0; i < arr.length; i += 1) {
  72             if (arr[i] === item) {
  73                 return i;
  74             }
  75         }
  76         return -1;
  77     };
  78
  79     //// exported async module functions ////
  80
  81     //// nextTick implementation with browser-compatible fallback ////
  82     if (typeof process === 'undefined' || !(process.nextTick)) {
  83         async.nextTick = function (fn) {
  84             setTimeout(fn, 0);
  85         };
  86     }
  87     else {
  88         async.nextTick = process.nextTick;
  89     }
  90
  91     async.forEach = function (arr, iterator, callback) {
  92         if (!arr.length) {
  93             return callback();
  94         }
  95         var completed = 0;
  96         _forEach(arr, function (x) {
  97             iterator(x, function (err) {
  98                 if (err) {
  99                     callback(err);
 100                     callback = function () {};
 101                 }
 102                 else {
 103                     completed += 1;
 104                     if (completed === arr.length) {
 105                         callback();
 106                     }
 107                 }
 108             });
 109         });
 110     };
 111
 112     async.forEachSeries = function (arr, iterator, callback) {
 113         if (!arr.length) {
 114             return callback();
 115         }
 116         var completed = 0;
 117         var iterate = function () {
 118             iterator(arr[completed], function (err) {
 119                 if (err) {
 120                     callback(err);
 121                     callback = function () {};
 122                 }
 123                 else {
 124                     completed += 1;
 125                     if (completed === arr.length) {
 126                         callback();
 127                     }
 128                     else {
 129                         iterate();
 130                     }
 131                 }
 132             });
 133         };
 134         iterate();
 135     };
 136
 137
 138     var doParallel = function (fn) {
 139         return function () {
 140             var args = Array.prototype.slice.call(arguments);
 141             return fn.apply(null, [async.forEach].concat(args));
 142         };
 143     };
 144     var doSeries = function (fn) {
 145         return function () {
 146             var args = Array.prototype.slice.call(arguments);
 147             return fn.apply(null, [async.forEachSeries].concat(args));
 148         };
 149     };
 150
 151
 152     var _asyncMap = function (eachfn, arr, iterator, callback) {
 153         var results = [];
 154         arr = _map(arr, function (x, i) {
 155             return {index: i, value: x};
 156         });
 157         eachfn(arr, function (x, callback) {
 158             iterator(x.value, function (err, v) {
 159                 results[x.index] = v;
 160                 callback(err);
 161             });
 162         }, function (err) {
 163             callback(err, results);
 164         });
 165     };
 166     async.map = doParallel(_asyncMap);
 167     async.mapSeries = doSeries(_asyncMap);
 168
 169
 170     // reduce only has a series version, as doing reduce in parallel won't
 171     // work in many situations.
 172     async.reduce = function (arr, memo, iterator, callback) {
 173         async.forEachSeries(arr, function (x, callback) {
 174             iterator(memo, x, function (err, v) {
 175                 memo = v;
 176                 callback(err);
 177             });
 178         }, function (err) {
 179             callback(err, memo);
 180         });
 181     };
 182     // inject alias
 183     async.inject = async.reduce;
 184     // foldl alias
 185     async.foldl = async.reduce;
 186
 187     async.reduceRight = function (arr, memo, iterator, callback) {
 188         var reversed = _map(arr, function (x) {
 189             return x;
 190         }).reverse();
 191         async.reduce(reversed, memo, iterator, callback);
 192     };
 193     // foldr alias
 194     async.foldr = async.reduceRight;
 195
 196     var _filter = function (eachfn, arr, iterator, callback) {
 197         var results = [];
 198         arr = _map(arr, function (x, i) {
 199             return {index: i, value: x};
 200         });
 201         eachfn(arr, function (x, callback) {
 202             iterator(x.value, function (v) {
 203                 if (v) {
 204                     results.push(x);
 205                 }
 206                 callback();
 207             });
 208         }, function (err) {
 209             callback(_map(results.sort(function (a, b) {
 210                 return a.index - b.index;
 211             }), function (x) {
 212                 return x.value;
 213             }));
 214         });
 215     };
 216     async.filter = doParallel(_filter);
 217     async.filterSeries = doSeries(_filter);
 218     // select alias
 219     async.select = async.filter;
 220     async.selectSeries = async.filterSeries;
 221
 222     var _reject = function (eachfn, arr, iterator, callback) {
 223         var results = [];
 224         arr = _map(arr, function (x, i) {
 225             return {index: i, value: x};
 226         });
 227         eachfn(arr, function (x, callback) {
 228             iterator(x.value, function (v) {
 229                 if (!v) {
 230                     results.push(x);
 231                 }
 232                 callback();
 233             });
 234         }, function (err) {
 235             callback(_map(results.sort(function (a, b) {
 236                 return a.index - b.index;
 237             }), function (x) {
 238                 return x.value;
 239             }));
 240         });
 241     };
 242     async.reject = doParallel(_reject);
 243     async.rejectSeries = doSeries(_reject);
 244
 245     var _detect = function (eachfn, arr, iterator, main_callback) {
 246         eachfn(arr, function (x, callback) {
 247             iterator(x, function (result) {
 248                 if (result) {
 249                     main_callback(x);
 250                 }
 251                 else {
 252                     callback();
 253                 }
 254             });
 255         }, function (err) {
 256             main_callback();
 257         });
 258     };
 259     async.detect = doParallel(_detect);
 260     async.detectSeries = doSeries(_detect);
 261
 262     async.some = function (arr, iterator, main_callback) {
 263         async.forEach(arr, function (x, callback) {
 264             iterator(x, function (v) {
 265                 if (v) {
 266                     main_callback(true);
 267                     main_callback = function () {};
 268                 }
 269                 callback();
 270             });
 271         }, function (err) {
 272             main_callback(false);
 273         });
 274     };
 275     // any alias
 276     async.any = async.some;
 277
 278     async.every = function (arr, iterator, main_callback) {
 279         async.forEach(arr, function (x, callback) {
 280             iterator(x, function (v) {
 281                 if (!v) {
 282                     main_callback(false);
 283                     main_callback = function () {};
 284                 }
 285                 callback();
 286             });
 287         }, function (err) {
 288             main_callback(true);
 289         });
 290     };
 291     // all alias
 292     async.all = async.every;
 293
 294     async.sortBy = function (arr, iterator, callback) {
 295         async.map(arr, function (x, callback) {
 296             iterator(x, function (err, criteria) {
 297                 if (err) {
 298                     callback(err);
 299                 }
 300                 else {
 301                     callback(null, {value: x, criteria: criteria});
 302                 }
 303             });
 304         }, function (err, results) {
 305             if (err) {
 306                 return callback(err);
 307             }
 308             else {
 309                 var fn = function (left, right) {
 310                     var a = left.criteria, b = right.criteria;
 311                     return a < b ? -1 : a > b ? 1 : 0;
 312                 };
 313                 callback(null, _map(results.sort(fn), function (x) {
 314                     return x.value;
 315                 }));
 316             }
 317         });
 318     };
 319
 320     async.auto = function (tasks, callback) {
 321         callback = callback || function () {};
 322         var keys = _keys(tasks);
 323         if (!keys.length) {
 324             return callback(null);
 325         }
 326
 327         var completed = [];
 328
 329         var listeners = [];
 330         var addListener = function (fn) {
 331             listeners.unshift(fn);
 332         };
 333         var removeListener = function (fn) {
 334             for (var i = 0; i < listeners.length; i += 1) {
 335                 if (listeners[i] === fn) {
 336                     listeners.splice(i, 1);
 337                     return;
 338                 }
 339             }
 340         };
 341         var taskComplete = function () {
 342             _forEach(listeners, function (fn) {
 343                 fn();
 344             });
 345         };
 346
 347         addListener(function () {
 348             if (completed.length === keys.length) {
 349                 callback(null);
 350             }
 351         });
 352
 353         _forEach(keys, function (k) {
 354             var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
 355             var taskCallback = function (err) {
 356                 if (err) {
 357                     callback(err);
 358                     // stop subsequent errors hitting callback multiple times
 359                     callback = function () {};
 360                 }
 361                 else {
 362                     completed.push(k);
 363                     taskComplete();
 364                 }
 365             };
 366             var requires = task.slice(0, Math.abs(task.length - 1)) || [];
 367             var ready = function () {
 368                 return _reduce(requires, function (a, x) {
 369                     return (a && _indexOf(completed, x) !== -1);
 370                 }, true);
 371             };
 372             if (ready()) {
 373                 task[task.length - 1](taskCallback);
 374             }
 375             else {
 376                 var listener = function () {
 377                     if (ready()) {
 378                         removeListener(listener);
 379                         task[task.length - 1](taskCallback);
 380                     }
 381                 };
 382                 addListener(listener);
 383             }
 384         });
 385     };
 386
 387     async.waterfall = function (tasks, callback) {
 388         if (!tasks.length) {
 389             return callback();
 390         }
 391         callback = callback || function () {};
 392         var wrapIterator = function (iterator) {
 393             return function (err) {
 394                 if (err) {
 395                     callback(err);
 396                     callback = function () {};
 397                 }
 398                 else {
 399                     var args = Array.prototype.slice.call(arguments, 1);
 400                     var next = iterator.next();
 401                     if (next) {
 402                         args.push(wrapIterator(next));
 403                     }
 404                     else {
 405                         args.push(callback);
 406                     }
 407                     async.nextTick(function () {
 408                         iterator.apply(null, args);
 409                     });
 410                 }
 411             };
 412         };
 413         wrapIterator(async.iterator(tasks))();
 414     };
 415
 416     async.parallel = function (tasks, callback) {
 417         callback = callback || function () {};
 418         if (tasks.constructor === Array) {
 419             async.map(tasks, function (fn, callback) {
 420                 if (fn) {
 421                     fn(function (err) {
 422                         var args = Array.prototype.slice.call(arguments, 1);
 423                         if (args.length <= 1) {
 424                             args = args[0];
 425                         }
 426                         callback.call(null, err, args);
 427                     });
 428                 }
 429             }, callback);
 430         }
 431         else {
 432             var results = {};
 433             async.forEach(_keys(tasks), function (k, callback) {
 434                 tasks[k](function (err) {
 435                     var args = Array.prototype.slice.call(arguments, 1);
 436                     if (args.length <= 1) {
 437                         args = args[0];
 438                     }
 439                     results[k] = args;
 440                     callback(err);
 441                 });
 442             }, function (err) {
 443                 callback(err, results);
 444             });
 445         }
 446     };
 447
 448     async.series = function (tasks, callback) {
 449         callback = callback || function () {};
 450         if (tasks.constructor === Array) {
 451             async.mapSeries(tasks, function (fn, callback) {
 452                 if (fn) {
 453                     fn(function (err) {
 454                         var args = Array.prototype.slice.call(arguments, 1);
 455                         if (args.length <= 1) {
 456                             args = args[0];
 457                         }
 458                         callback.call(null, err, args);
 459                     });
 460                 }
 461             }, callback);
 462         }
 463         else {
 464             var results = {};
 465             async.forEachSeries(_keys(tasks), function (k, callback) {
 466                 tasks[k](function (err) {
 467                     var args = Array.prototype.slice.call(arguments, 1);
 468                     if (args.length <= 1) {
 469                         args = args[0];
 470                     }
 471                     results[k] = args;
 472                     callback(err);
 473                 });
 474             }, function (err) {
 475                 callback(err, results);
 476             });
 477         }
 478     };
 479
 480     async.iterator = function (tasks) {
 481         var makeCallback = function (index) {
 482             var fn = function () {
 483                 if (tasks.length) {
 484                     tasks[index].apply(null, arguments);
 485                 }
 486                 return fn.next();
 487             };
 488             fn.next = function () {
 489                 return (index < tasks.length - 1) ? makeCallback(index + 1): null;
 490             };
 491             return fn;
 492         };
 493         return makeCallback(0);
 494     };
 495
 496     async.apply = function (fn) {
 497         var args = Array.prototype.slice.call(arguments, 1);
 498         return function () {
 499             return fn.apply(
 500                 null, args.concat(Array.prototype.slice.call(arguments))
 501             );
 502         };
 503     };
 504
 505     var _concat = function (eachfn, arr, fn, callback) {
 506         var r = [];
 507         eachfn(arr, function (x, cb) {
 508             fn(x, function (err, y) {
 509                 r = r.concat(y || []);
 510                 cb(err);
 511             });
 512         }, function (err) {
 513             callback(err, r);
 514         });
 515     };
 516     async.concat = doParallel(_concat);
 517     async.concatSeries = doSeries(_concat);
 518
 519     async.whilst = function (test, iterator, callback) {
 520         if (test()) {
 521             iterator(function (err) {
 522                 if (err) {
 523                     return callback(err);
 524                 }
 525                 async.whilst(test, iterator, callback);
 526             });
 527         }
 528         else {
 529             callback();
 530         }
 531     };
 532
 533     async.until = function (test, iterator, callback) {
 534         if (!test()) {
 535             iterator(function (err) {
 536                 if (err) {
 537                     return callback(err);
 538                 }
 539                 async.until(test, iterator, callback);
 540             });
 541         }
 542         else {
 543             callback();
 544         }
 545     };
 546
 547     async.queue = function (worker, concurrency) {
 548         var workers = 0;
 549         var tasks = [];
 550         var q = {
 551             concurrency: concurrency,
 552             saturated: null,
 553             empty: null,
 554             drain: null,
 555             push: function (data, callback) {
 556                 tasks.push({data: data, callback: callback});
 557                 if(q.saturated && tasks.length == concurrency) q.saturated();
 558                 async.nextTick(q.process);
 559             },
 560             process: function () {
 561                 if (workers < q.concurrency && tasks.length) {
 562                     var task = tasks.splice(0, 1)[0];
 563                     if(q.empty && tasks.length == 0) q.empty();
 564                     workers += 1;
 565                     worker(task.data, function () {
 566                         workers -= 1;
 567                         if (task.callback) {
 568                             task.callback.apply(task, arguments);
 569                         }
 570                         if(q.drain && tasks.length + workers == 0) q.drain();
 571                         q.process();
 572                     });
 573                 }
 574             },
 575             length: function () {
 576                 return tasks.length;
 577             },
 578             running: function () {
 579                 return workers;
 580             }
 581         };
 582         return q;
 583     };
 584
 585     var _console_fn = function (name) {
 586         return function (fn) {
 587             var args = Array.prototype.slice.call(arguments, 1);
 588             fn.apply(null, args.concat([function (err) {
 589                 var args = Array.prototype.slice.call(arguments, 1);
 590                 if (typeof console !== 'undefined') {
 591                     if (err) {
 592                         if (console.error) {
 593                             console.error(err);
 594                         }
 595                     }
 596                     else if (console[name]) {
 597                         _forEach(args, function (x) {
 598                             console[name](x);
 599                         });
 600                     }
 601                 }
 602             }]));
 603         };
 604     };
 605     async.log = _console_fn('log');
 606     async.dir = _console_fn('dir');
 607     /*async.info = _console_fn('info');
 608     async.warn = _console_fn('warn');
 609     async.error = _console_fn('error');*/
 610
 611     async.memoize = function (fn, hasher) {
 612         var memo = {};
 613         hasher = hasher || function (x) {
 614             return x;
 615         };
 616         return function () {
 617             var args = Array.prototype.slice.call(arguments);
 618             var callback = args.pop();
 619             var key = hasher.apply(null, args);
 620             if (key in memo) {
 621                 callback.apply(null, memo[key]);
 622             }
 623             else {
 624                 fn.apply(null, args.concat([function () {
 625                     memo[key] = arguments;
 626                     callback.apply(null, arguments);
 627                 }]));
 628             }
 629         };
 630     };
 631
 632 }());