all files / scripts/utils/ async.js

100% Statements 47/47
90% Branches 18/20
92.86% Functions 13/14
100% Lines 47/47
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86        629×     272× 1247× 619× 619×   619×   1247× 1247×   1247×   272×       272× 272×   271×   270× 763× 757× 129× 129×       628× 628× 628× 493×     135×   628× 613×         270×                            
//Small subset of async
 
var utilities = require('./utilityFunctions');
 
var async = {};
 
async.setImmediate = function (fn) {
  setTimeout(fn, 0);
};
 
async.iterator = function (tasks) {
  var makeCallback = function (index) {
    var fn = function () {
      Eif (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);
};
 
 
async.waterfall = function (tasks, callback) {
  callback = callback || function () { };
  if (!utilities.isArray(tasks)) {
    var err = new Error('First argument to waterfall must be an array of functions');
    return callback(err);
  }
  if (!tasks.length) {
    return callback();
  }
  var wrapIterator = function (iterator) {
    return function (err) {
      if (err) {
        callback.apply(null, arguments);
        callback = function () {
        };
      }
      else {
        var args = Array.prototype.slice.call(arguments, 1);
        var next = iterator.next();
        if (next) {
          args.push(wrapIterator(next));
        }
        else {
          args.push(callback);
        }
        async.setImmediate(function () {
          iterator.apply(null, args);
        });
      }
    };
  };
  wrapIterator(async.iterator(tasks))();
};
 
async.when = function (condition, callback) {
  if (!utilities.isFunction(callback)) {
    throw new Error("async.when error: missing callback argument");
  }
 
  var isAllowed = utilities.isFunction(condition) ? condition : function () {
    return !!condition;
  };
 
  return function () {
    var args = utilities.arrayLikeObjToArray(arguments);
    var next = args.pop();
 
    if (isAllowed.apply(null, args)) {
      return callback.apply(this, arguments);
    }
 
    args.unshift(null);
    return next.apply(null, args);
  };
};
 
module.exports = async;