Initial import with skill sheet working

node_modules/undertaker/lib/helpers/buildTree.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var metadata = require('./metadata');
+
+function buildTree(tasks) {
+  return Object.values(tasks).map(function(task) {
+    var meta = metadata.get(task);
+    if (meta) {
+      return meta.tree;
+    }
+
+    var name = task.displayName || task.name || '<anonymous>';
+    meta = {
+      name: name,
+      tree: {
+        label: name,
+        type: 'function',
+        nodes: [],
+      },
+    };
+
+    metadata.set(task, meta);
+    return meta.tree;
+  });
+}
+
+module.exports = buildTree;

node_modules/undertaker/lib/helpers/createExtensions.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var captureLastRun = require('last-run').capture;
+var releaseLastRun = require('last-run').release;
+
+var metadata = require('./metadata');
+
+var uid = 0;
+
+function Storage(fn) {
+  var meta = metadata.get(fn);
+
+  this.fn = meta.orig || fn;
+  this.uid = uid++;
+  this.name = meta.name;
+  this.branch = meta.branch || false;
+  this.captureTime = Date.now();
+  this.startHr = [];
+}
+
+Storage.prototype.capture = function() {
+  captureLastRun(this.fn, this.captureTime);
+};
+
+Storage.prototype.release = function() {
+  releaseLastRun(this.fn);
+};
+
+function createExtensions(ee) {
+  return {
+    create: function(fn) {
+      return new Storage(fn);
+    },
+    before: function(storage) {
+      storage.startHr = process.hrtime();
+      ee.emit('start', {
+        uid: storage.uid,
+        name: storage.name,
+        branch: storage.branch,
+        time: Date.now(),
+      });
+    },
+    after: function(result, storage) {
+      if (result && result.state === 'error') {
+        return this.error(result.value, storage);
+      }
+      storage.capture();
+      ee.emit('stop', {
+        uid: storage.uid,
+        name: storage.name,
+        branch: storage.branch,
+        duration: process.hrtime(storage.startHr),
+        time: Date.now(),
+      });
+    },
+    error: function(error, storage) {
+      if (Array.isArray(error)) {
+        error = error[0];
+      }
+      storage.release();
+      ee.emit('error', {
+        uid: storage.uid,
+        name: storage.name,
+        branch: storage.branch,
+        error: error,
+        duration: process.hrtime(storage.startHr),
+        time: Date.now(),
+      });
+    },
+  };
+}
+
+module.exports = createExtensions;

node_modules/undertaker/lib/helpers/metadata.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var metadata = new WeakMap();
+
+module.exports = metadata;

node_modules/undertaker/lib/helpers/normalizeArgs.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var assert = require('assert');
+
+var levenshtein = require('fast-levenshtein');
+
+function normalizeArgs(registry, args) {
+  function getFunction(task) {
+    if (typeof task === 'function') {
+      return task;
+    }
+
+    var fn = registry.get(task);
+    if (!fn) {
+      var similar = similarTasks(registry, task);
+      var err;
+      if (similar.length > 0) {
+        err = new Error('Task never defined: ' + task + ' - did you mean? ' + similar.join(', '));
+        err.task = task;
+        err.similar = similar;
+      } else {
+        err = new Error('Task never defined: ' + task);
+        err.task = task;
+      }
+      throw err;
+    }
+    return fn;
+  }
+
+  var flattenArgs = Array.prototype.concat.apply([], args);
+  assert(flattenArgs.length, 'One or more tasks should be combined using series or parallel');
+
+  return flattenArgs.map(getFunction);
+}
+
+function similarTasks(registry, queryTask) {
+  if (typeof queryTask !== 'string') {
+    return [];
+  }
+
+  var tasks = registry.tasks();
+  var similarTasks = [];
+  for (var task in tasks) {
+    if (Object.prototype.hasOwnProperty.call(tasks, task)) {
+      var distance = levenshtein.get(task, queryTask);
+      var allowedDistance = Math.floor(0.4 * task.length) + 1;
+      if (distance < allowedDistance) {
+        similarTasks.push(task);
+      }
+    }
+  }
+  return similarTasks;
+}
+
+module.exports = normalizeArgs;

node_modules/undertaker/lib/helpers/validateRegistry.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var assert = require('assert');
+
+function isFunction(fn) {
+  return typeof fn === 'function';
+}
+
+function isConstructor(registry) {
+  if (!(registry && registry.prototype)) {
+    return false;
+  }
+
+  var hasProtoGet = isFunction(registry.prototype.get);
+  var hasProtoSet = isFunction(registry.prototype.set);
+  var hasProtoInit = isFunction(registry.prototype.init);
+  var hasProtoTasks = isFunction(registry.prototype.tasks);
+
+  if (hasProtoGet || hasProtoSet || hasProtoInit || hasProtoTasks) {
+    return true;
+  }
+
+  return false;
+}
+
+function validateRegistry(registry) {
+  try {
+    assert(isFunction(registry.get), 'Custom registry must have `get` function');
+    assert(isFunction(registry.set), 'Custom registry must have `set` function');
+    assert(isFunction(registry.init), 'Custom registry must have `init` function');
+    assert(isFunction(registry.tasks), 'Custom registry must have `tasks` function');
+  } catch (err) {
+    if (isConstructor(registry)) {
+      assert(false, 'Custom registries must be instantiated, but it looks like you passed a constructor');
+    } else {
+      throw err;
+    }
+  }
+}
+
+module.exports = validateRegistry;