Added Gulp.js for compiling SCSS stylesheets

node_modules/undertaker/lib/get-task.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function get(name) {
+  return this._registry.get(name);
+}
+
+module.exports = get;

node_modules/undertaker/lib/helpers/buildTree.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var map = require('collection-map');
+
+var metadata = require('./metadata');
+
+function buildTree(tasks) {
+  return map(tasks, 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,7 @@
+'use strict';
+
+// WeakMap for storing metadata
+var WM = require('es6-weak-map');
+var metadata = new WM();
+
+module.exports = metadata;

node_modules/undertaker/lib/helpers/normalizeArgs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var assert = require('assert');
+
+var map = require('arr-map');
+var flatten = require('arr-flatten');
+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);
+      if (similar.length > 0) {
+        assert(false, 'Task never defined: ' + task + ' - did you mean? ' + similar.join(', '));
+      } else {
+        assert(false, 'Task never defined: ' + task);
+      }
+    }
+    return fn;
+  }
+
+  var flattenArgs = flatten(args);
+  assert(flattenArgs.length, 'One or more tasks should be combined using series or parallel');
+
+  return map(flattenArgs, getFunction);
+}
+
+function similarTasks(registry, queryTask) {
+  if (typeof queryTask !== 'string') {
+    return [];
+  }
+
+  var tasks = registry.tasks();
+  var similarTasks = [];
+  for (var task in tasks) {
+    if (tasks.hasOwnProperty(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;

node_modules/undertaker/lib/last-run.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var retrieveLastRun = require('last-run');
+
+var metadata = require('./helpers/metadata');
+
+function lastRun(task, timeResolution) {
+  if (timeResolution == null) {
+    timeResolution = process.env.UNDERTAKER_TIME_RESOLUTION;
+  }
+
+  var fn = task;
+  if (typeof task === 'string') {
+    fn = this._getTask(task);
+  }
+
+  var meta = metadata.get(fn);
+
+  if (meta) {
+    fn = meta.orig || fn;
+  }
+
+  return retrieveLastRun(fn, timeResolution);
+}
+
+module.exports = lastRun;

node_modules/undertaker/lib/parallel.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var bach = require('bach');
+
+var metadata = require('./helpers/metadata');
+var buildTree = require('./helpers/buildTree');
+var normalizeArgs = require('./helpers/normalizeArgs');
+var createExtensions = require('./helpers/createExtensions');
+
+function parallel() {
+  var create = this._settle ? bach.settleParallel : bach.parallel;
+
+  var args = normalizeArgs(this._registry, arguments);
+  var extensions = createExtensions(this);
+  var fn = create(args, extensions);
+  var name = '<parallel>';
+
+  metadata.set(fn, {
+    name: name,
+    branch: true,
+    tree: {
+      label: name,
+      type: 'function',
+      branch: true,
+      nodes: buildTree(args),
+    },
+  });
+  return fn;
+}
+
+module.exports = parallel;

node_modules/undertaker/lib/registry.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var reduce = require('object.reduce');
+
+var validateRegistry = require('./helpers/validateRegistry');
+
+function setTasks(inst, task, name) {
+  inst.set(name, task);
+  return inst;
+}
+
+function registry(newRegistry) {
+  if (!newRegistry) {
+    return this._registry;
+  }
+
+  validateRegistry(newRegistry);
+
+  var tasks = this._registry.tasks();
+
+  this._registry = reduce(tasks, setTasks, newRegistry);
+  this._registry.init(this);
+}
+
+module.exports = registry;

node_modules/undertaker/lib/series.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var bach = require('bach');
+
+var metadata = require('./helpers/metadata');
+var buildTree = require('./helpers/buildTree');
+var normalizeArgs = require('./helpers/normalizeArgs');
+var createExtensions = require('./helpers/createExtensions');
+
+function series() {
+  var create = this._settle ? bach.settleSeries : bach.series;
+
+  var args = normalizeArgs(this._registry, arguments);
+  var extensions = createExtensions(this);
+  var fn = create(args, extensions);
+  var name = '<series>';
+
+  metadata.set(fn, {
+    name: name,
+    branch: true,
+    tree: {
+      label: name,
+      type: 'function',
+      branch: true,
+      nodes: buildTree(args),
+    },
+  });
+  return fn;
+}
+
+module.exports = series;

node_modules/undertaker/lib/set-task.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var assert = require('assert');
+
+var metadata = require('./helpers/metadata');
+
+function set(name, fn) {
+  assert(name, 'Task name must be specified');
+  assert(typeof name === 'string', 'Task name must be a string');
+  assert(typeof fn === 'function', 'Task function must be specified');
+
+  function taskWrapper() {
+    return fn.apply(this, arguments);
+  }
+
+  function unwrap() {
+    return fn;
+  }
+
+  taskWrapper.unwrap = unwrap;
+  taskWrapper.displayName = name;
+
+  var meta = metadata.get(fn) || {};
+  var nodes = [];
+  if (meta.branch) {
+    nodes.push(meta.tree);
+  }
+
+  var task = this._registry.set(name, taskWrapper) || taskWrapper;
+
+  metadata.set(task, {
+    name: name,
+    orig: fn,
+    tree: {
+      label: name,
+      type: 'task',
+      nodes: nodes,
+    },
+  });
+}
+
+module.exports = set;

node_modules/undertaker/lib/task.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function task(name, fn) {
+  if (typeof name === 'function') {
+    fn = name;
+    name = fn.displayName || fn.name;
+  }
+
+  if (!fn) {
+    return this._getTask(name);
+  }
+
+  this._setTask(name, fn);
+}
+
+module.exports = task;

node_modules/undertaker/lib/tree.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var defaults = require('object.defaults');
+var map = require('collection-map');
+
+var metadata = require('./helpers/metadata');
+
+function tree(opts) {
+  opts = defaults(opts || {}, {
+    deep: false,
+  });
+
+  var tasks = this._registry.tasks();
+  var nodes = map(tasks, function(task) {
+    var meta = metadata.get(task);
+
+    if (opts.deep) {
+      return meta.tree;
+    }
+
+    return meta.tree.label;
+  });
+
+  return {
+    label: 'Tasks',
+    nodes: nodes,
+  };
+}
+
+module.exports = tree;