New: First implementation

Author: phated

.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - '0.10'

index.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var inherits = require('util').inherits;
+var EventEmitter = require('events').EventEmitter;
+
+var bach = require('bach');
+var DefaultRegistry = require('undertaker-registry');
+
+var metadata = require('./lib/metadata');
+var normalizeArgs = require('./lib/normalizeArgs');
+var createExtensions = require('./lib/createExtensions');
+
+function Undertaker(Registry){
+  EventEmitter.call(this);
+
+  Registry = Registry || DefaultRegistry;
+
+  this.registry = new Registry();
+}
+
+inherits(Undertaker, EventEmitter);
+
+Undertaker.prototype.get = function get(name){
+  var wrapper = this.registry.get(name);
+
+  if(!wrapper){
+    return;
+  }
+
+  var meta = metadata.get(wrapper);
+
+  if(meta){
+    return meta.orig;
+  }
+
+  return wrapper;
+};
+
+Undertaker.prototype.set = function set(name, fn){
+  function taskWrapper(){
+    /* jshint validthis: true */
+    return fn.apply(this, arguments);
+  }
+
+  metadata.set(taskWrapper, {
+    name: name,
+    orig: fn
+  });
+
+  this.registry.set(name, taskWrapper);
+};
+
+Undertaker.prototype.task = function task(name, fn){
+  if(typeof name === 'function'){
+    fn = name;
+    name = fn.name;
+  }
+
+  if(!fn){
+    return this.get(name);
+  }
+
+  this.set(name, fn);
+};
+
+Undertaker.prototype.series = function series(){
+  var args = normalizeArgs(this.registry, arguments);
+  var extensions = createExtensions(this);
+  var fn = bach.series(args, extensions);
+  metadata.set(fn, { name: 'series' });
+  return fn;
+};
+
+Undertaker.prototype.parallel = function parallel(){
+  var args = normalizeArgs(this.registry, arguments);
+  var extensions = createExtensions(this);
+  var fn = bach.parallel(args, extensions);
+  metadata.set(fn, { name: 'parallel' });
+  return fn;
+};
+
+module.exports = Undertaker;

lib/createExtensions.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var uid = 0;
+
+var metadata = require('./metadata');
+
+function Storage(name){
+  this.uid = uid++;
+  this.name = name;
+}
+
+function createExtensions(ee){
+  return {
+    create: function(fn){
+      var meta = metadata.get(fn);
+      var name;
+
+      if(meta){
+        name = meta.name;
+      } else {
+        name = fn.name;
+      }
+
+      return new Storage(name);
+    },
+    before: function(storage){
+      storage.startHr = process.hrtime();
+      ee.emit('start', {
+        uid: storage.uid,
+        name: storage.name,
+        time: Date.now()
+      });
+    },
+    after: function(storage){
+      ee.emit('stop', {
+        uid: storage.uid,
+        name: storage.name,
+        duration: process.hrtime(storage.startHr),
+        time: Date.now()
+      });
+    },
+    error: function(storage){
+      ee.emit('error', {
+        uid: storage.uid,
+        name: storage.name,
+        duration: process.hrtime(storage.startHr),
+        time: Date.now()
+      });
+    }
+  };
+}
+
+module.exports = createExtensions;

lib/metadata.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var WM = require('es6-weak-map');
+
+// WeakMap for storing metadata
+var metadata = new WM();
+
+module.exports = metadata;

lib/normalizeArgs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var assert = require('assert');
+
+var _ = require('lodash');
+
+function normalizeArgs(registry, args){
+  function getFunction(task){
+    if(typeof task === 'function'){
+      return task;
+    }
+
+    var fn = registry.get(task);
+    assert(fn, 'Task never defined: ' + task);
+    return fn;
+  }
+
+  return _.map(_.flatten(args), getFunction);
+}
+
+module.exports = normalizeArgs;

package.json

@@ -0,0 +1,33 @@
+{
+  "name": "undertaker",
+  "version": "0.0.0",
+  "description": "undertaker ==========",
+  "main": "index.js",
+  "scripts": {
+    "test": "lab -cv"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phated/undertaker"
+  },
+  "keywords": [
+    "task",
+    "registry",
+    "runner"
+  ],
+  "author": "Blaine Bublitz <[email protected]> (http://iceddev.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/phated/undertaker/issues"
+  },
+  "homepage": "https://github.com/phated/undertaker",
+  "devDependencies": {
+    "lab": "^4.1.0"
+  },
+  "dependencies": {
+    "bach": "^0.2.0",
+    "es6-weak-map": "^0.1.1",
+    "lodash": "^2.4.1",
+    "undertaker-registry": "0.0.0"
+  }
+}

test/parallel.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var lab = exports.lab = require('lab').script();
+var describe = lab.describe;
+var it = lab.it;
+var before = lab.before;
+var beforeEach = lab.beforeEach;
+var after = lab.after;
+var afterEach = lab.afterEach;
+var expect = require('lab').expect;
+
+var Undertaker = require('../');
+
+function fn1(done){
+  done(null, 1);
+}
+
+function fn2(done){
+  setTimeout(function(){
+    done(null, 2);
+  }, 500);
+}
+
+function fn3(done){
+  done(null, 3);
+}
+
+function fnError(done){
+  done(new Error('An Error Occurred'));
+}
+
+describe('parallel', function(){
+
+  var taker;
+
+  beforeEach(function(done){
+    taker = new Undertaker();
+    taker.task('test1', fn1);
+    taker.task('test2', fn2);
+    taker.task('test3', fn3);
+    taker.task('error', fnError);
+    done();
+  });
+
+  it('should take all string names', function(done){
+    taker.parallel('test1', 'test2', 'test3')(function(err, results){
+      expect(results).to.deep.equal([1, 2, 3]);
+      done(err);
+    });
+  });
+
+  it('should take all functions', function(done){
+    taker.parallel(fn1, fn2, fn3)(function(err, results){
+      expect(results).to.deep.equal([1, 2, 3]);
+      done(err);
+    });
+  });
+
+  it('should take string names and functions', function(done){
+    taker.parallel('test1', fn2, 'test3')(function(err, results){
+      expect(results).to.deep.equal([1, 2, 3]);
+      done(err);
+    });
+  });
+
+  it('should take nested parallel', function(done){
+    var parallel1 = taker.parallel('test1', 'test2', 'test3');
+    taker.parallel('test1', parallel1, 'test3')(function(err, results){
+      expect(results).to.deep.equal([1, [1, 2, 3], 3]);
+      done(err);
+    });
+  });
+
+  it('should stop processing on error', function(done){
+    taker.on('error', function(err){
+      // to keep the process from crashing
+    });
+    taker.parallel('test1', 'error', 'test3')(function(err, results){
+      expect(err).to.be.an.instanceof(Error);
+      expect(results).to.deep.equal([1, undefined, undefined]);
+      done();
+    });
+  });
+
+  it('should throw on unregistered task', function(done){
+    function unregistered(){
+      taker.parallel('unregistered');
+    }
+
+    expect(unregistered).to.throw('Task never defined: unregistered');
+    done();
+  });
+});

test/registry.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var lab = exports.lab = require('lab').script();
+var describe = lab.describe;
+var it = lab.it;
+var before = lab.before;
+var beforeEach = lab.beforeEach;
+var after = lab.after;
+var afterEach = lab.afterEach;
+var expect = require('lab').expect;
+
+var Undertaker = require('../');
+
+var DefaultRegistry = require('undertaker-registry');
+
+function CustomRegistry(){}
+
+describe('registry', function(){
+
+  it('should take a custom registry', function(done){
+    var taker = new Undertaker(CustomRegistry);
+    expect(taker.registry).to.be.an.instanceof(CustomRegistry);
+    expect(taker.registry).to.not.be.an.instanceof(DefaultRegistry);
+    done();
+  });
+
+  it('should default to undertaker-registry if not constructed with custom registry', function(done){
+    var taker = new Undertaker();
+    expect(taker.registry).to.be.an.instanceof(DefaultRegistry);
+    expect(taker.registry).to.not.be.an.instanceof(CustomRegistry);
+    done();
+  });
+});