each.js

// Generated by CoffeeScript 1.4.0
var glob;

glob = require('glob');

/*
each(elements)
.mode(parallel=false|true|integer)
.on('item', callback)
.on('error', callback)
.on('end', callback)
.on('both', callback)
Chained and parallel async iterator in one elegant function
*/


module.exports = function(elements) {
  var arglength, eacher, endable, errors, events, isObject, keys, next, parallel, run, times, type;
  type = typeof elements;
  if (elements === null || type === 'undefined' || type === 'number' || type === 'string' || type === 'function' || type === 'boolean') {
    elements = [elements];
  } else if (!Array.isArray(elements)) {
    isObject = true;
  }
  arglength = arguments.length;
  if (isObject) {
    keys = Object.keys(elements);
  }
  errors = [];
  parallel = 1;
  events = {
    item: [],
    error: [],
    end: [],
    both: []
  };
  times = [];
  eacher = {};
  eacher.total = keys ? keys.length : elements.length;
  eacher.started = 0;
  eacher.done = 0;
  times = 1;
  endable = 1;
  eacher.paused = 0;
  eacher.readable = true;
  eacher.pause = function() {
    return eacher.paused++;
  };
  eacher.resume = function() {
    eacher.paused--;
    return run();
  };
  eacher.parallel = function(mode) {
    if (typeof mode === 'number') {
      parallel = mode;
    } else if (mode) {
      parallel = mode;
    } else {
      parallel = 1;
    }
    return eacher;
  };
  eacher.times = function(t) {
    times = t;
    return eacher;
  };
  eacher.files = function(pattern) {
    var p, _i, _len;
    if (Array.isArray(pattern)) {
      for (_i = 0, _len = pattern.length; _i < _len; _i++) {
        p = pattern[_i];
        this.files(p);
      }
      return this;
    }
    endable--;
    if (arglength === 0) {
      arglength = null;
      eacher.total = 0;
      elements = [];
    }
    glob(pattern, function(err, files) {
      var file, _j, _len1;
      eacher.total += files.length;
      for (_j = 0, _len1 = files.length; _j < _len1; _j++) {
        file = files[_j];
        elements.push(file);
      }
      return process.nextTick(function() {
        endable++;
        return run();
      });
    });
    return eacher;
  };
  eacher.on = function(ev, callback) {
    events[ev].push(callback);
    return eacher;
  };
  run = function() {
    var args, emit, emitError, error, index, lboth, lerror, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref, _ref1, _ref2, _ref3;
    if (eacher.paused) {
      return;
    }
    error = null;
    if (endable === 1 && (eacher.done === eacher.total * times || (errors.length && eacher.started === eacher.done))) {
      eacher.readable = false;
      if (errors.length) {
        if (parallel !== 1) {
          if (errors.length === 1) {
            error = errors[0];
          } else {
            error = new Error("Multiple errors (" + errors.length + ")");
            error.errors = errors;
          }
        } else {
          error = errors[0];
        }
        lerror = events.error.length;
        lboth = events.both.length;
        emitError = lerror || (!lerror && !lboth);
        _ref = events.error;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          emit = _ref[_i];
          if (emitError) {
            emit(error);
          }
        }
      } else {
        args = [];
        _ref1 = events.end;
        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
          emit = _ref1[_j];
          emit(eacher.done);
        }
      }
      _ref2 = events.both;
      for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
        emit = _ref2[_k];
        emit(error, eacher.done);
      }
      return;
    }
    if (errors.length !== 0) {
      return;
    }
    while ((parallel === true ? (eacher.total * times - eacher.started) > 0 : Math.min(parallel - eacher.started + eacher.done, eacher.total * times - eacher.started))) {
      if (errors.length !== 0) {
        break;
      }
      index = Math.floor(eacher.started / times);
      eacher.started++;
      try {
        _ref3 = events.item;
        for (_l = 0, _len3 = _ref3.length; _l < _len3; _l++) {
          emit = _ref3[_l];
          switch (emit.length) {
            case 1:
              args = [next];
              break;
            case 2:
              if (keys) {
                args = [elements[keys[index]], next];
              } else {
                args = [elements[index], next];
              }
              break;
            case 3:
              if (keys) {
                args = [keys[index], elements[keys[index]], next];
              } else {
                args = [elements[index], index, next];
              }
              break;
            case 4:
              if (keys) {
                args = [keys[index], elements[keys[index]], index, next];
              } else {
                return next(new Error('Invalid arguments in item callback'));
              }
              break;
            default:
              return next(new Error('Invalid arguments in item callback'));
          }
          emit.apply(null, args);
        }
      } catch (e) {
        if (eacher.readable) {
          next(e);
        }
      }
    }
    return null;
  };
  next = function(err) {
    if ((err != null) && err instanceof Error) {
      errors.push(err);
    }
    eacher.done++;
    return run();
  };
  process.nextTick(run);
  return eacher;
};