Added Gulp.js for compiling SCSS stylesheets

node_modules/gulp-cli/lib/versioned/^3.7.0/format-error.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// Format orchestrator errors
+function formatError(e) {
+  if (!e.err) {
+    return e.message;
+  }
+
+  // PluginError
+  if (typeof e.err.showStack === 'boolean') {
+    return e.err.toString();
+  }
+
+  // Normal error
+  if (e.err.stack) {
+    return e.err.stack;
+  }
+
+  // Unknown (string, number, etc.)
+  return new Error(String(e.err)).stack;
+}
+
+module.exports = formatError;

node_modules/gulp-cli/lib/versioned/^3.7.0/index.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var taskTree = require('./task-tree');
+var copyTree = require('../../shared/log/copy-tree');
+
+var tildify = require('../../shared/tildify');
+var logTasks = require('../../shared/log/tasks');
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var logEvents = require('./log/events');
+var logTasksSimple = require('./log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+
+    var gulpInst = require(env.modulePath);
+    logEvents(gulpInst);
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      return logTasksSimple(env, gulpInst);
+    }
+    if (opts.tasks) {
+      tree = taskTree(gulpInst.tasks);
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+      return logTasks(tree, opts, function(task) {
+        return gulpInst.tasks[task].fn;
+      });
+    }
+    if (opts.tasksJson) {
+      tree = taskTree(gulpInst.tasks);
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean') {
+        return console.log(output);
+      }
+
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    gulpInst.start.apply(gulpInst, toRun);
+  });
+}
+
+module.exports = execute;

node_modules/gulp-cli/lib/versioned/^3.7.0/log/events.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var log = require('gulplog');
+var prettyTime = require('pretty-hrtime');
+
+var ansi = require('../../../shared/ansi');
+var exit = require('../../../shared/exit');
+var formatError = require('../format-error');
+
+// Wire up logging events
+function logEvents(gulpInst) {
+
+  // Exit with 0 or 1
+  var failed = false;
+  process.once('exit', function(code) {
+    if (code === 0 && failed) {
+      exit(1);
+    }
+  });
+
+  // Total hack due to poor error management in orchestrator
+  gulpInst.on('err', function() {
+    failed = true;
+  });
+
+  gulpInst.on('task_start', function(e) {
+    // TODO: batch these
+    // so when 5 tasks start at once it only logs one time with all 5
+    log.info('Starting', '\'' + ansi.cyan(e.task) + '\'...');
+  });
+
+  gulpInst.on('task_stop', function(e) {
+    var time = prettyTime(e.hrDuration);
+    log.info(
+      'Finished', '\'' + ansi.cyan(e.task) + '\'',
+      'after', ansi.magenta(time)
+    );
+  });
+
+  gulpInst.on('task_err', function(e) {
+    var msg = formatError(e);
+    var time = prettyTime(e.hrDuration);
+    log.error(
+      '\'' + ansi.cyan(e.task) + '\'',
+      ansi.red('errored after'),
+      ansi.magenta(time)
+    );
+    log.error(msg);
+  });
+
+  gulpInst.on('task_not_found', function(err) {
+    log.error(
+      ansi.red('Task \'' + err.task + '\' is not in your gulpfile')
+    );
+    log.error('Please check the documentation for proper gulpfile formatting');
+    exit(1);
+  });
+}
+
+module.exports = logEvents;

node_modules/gulp-cli/lib/versioned/^3.7.0/log/tasks-simple.js

@@ -0,0 +1,9 @@
+'use strict';
+
+function logTasksSimple(env, localGulp) {
+  console.log(Object.keys(localGulp.tasks)
+    .join('\n')
+    .trim());
+}
+
+module.exports = logTasksSimple;

node_modules/gulp-cli/lib/versioned/^3.7.0/task-tree.js

@@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = function(tasks) {
+  var map = {};
+  var arr = [];
+  Object.keys(tasks).forEach(function(taskname) {
+    var task = {
+      label: taskname,
+      type: 'task',
+      nodes: [],
+    };
+    map[taskname] = task;
+    arr.push(task);
+  });
+  Object.keys(tasks).forEach(function(taskname) {
+    var task = map[taskname];
+    tasks[taskname].dep.forEach(function(childname) {
+      var child = map[childname] || {
+        label: childname,
+        type: 'task',
+        nodes: [],
+      };
+      task.nodes.push(child);
+    });
+  });
+  return { label: 'Tasks', nodes: arr };
+};

node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.1/index.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('../^4.0.0/log/events');
+var logSyncTask = require('../^4.0.0/log/sync-task');
+var logTasksSimple = require('../^4.0.0/log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      return logTasksSimple(gulpInst.tree());
+    }
+    if (opts.tasks) {
+      tree = {};
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+      tree.nodes = gulpInst.tree({ deep: true });
+      return logTasks(tree, opts, function(taskname) {
+        return gulpInst.task(taskname);
+      });
+    }
+    if (opts.tasksJson) {
+      tree = {};
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+      tree.nodes = gulpInst.tree({ deep: true });
+
+      var output = JSON.stringify(copyTree(tree, opts));
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;

node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.2/index.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('../^4.0.0/log/events');
+var logSyncTask = require('../^4.0.0/log/sync-task');
+var logTasksSimple = require('../^4.0.0/log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var getTask = require('../^4.0.0/log/get-task');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      tree = gulpInst.tree();
+      return logTasksSimple(tree.nodes);
+    }
+    if (opts.tasks) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+
+      return logTasks(tree, opts, getTask(gulpInst));
+    }
+    if (opts.tasksJson) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;

node_modules/gulp-cli/lib/versioned/^4.0.0/format-error.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// Format orchestrator errors
+/* istanbul ignore next */
+function formatError(e) {
+  if (!e.error) {
+    return e.message;
+  }
+
+  // PluginError
+  if (typeof e.error.showStack === 'boolean') {
+    return e.error.toString();
+  }
+
+  // Normal error
+  if (e.error.stack) {
+    return e.error.stack;
+  }
+
+  // Unknown (string, number, etc.)
+  return new Error(String(e.error)).stack;
+}
+
+module.exports = formatError;

node_modules/gulp-cli/lib/versioned/^4.0.0/index.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('./log/events');
+var logSyncTask = require('./log/sync-task');
+var logTasksSimple = require('./log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var getTask = require('./log/get-task');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      tree = gulpInst.tree();
+      return logTasksSimple(tree.nodes);
+    }
+    if (opts.tasks) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+
+      return logTasks(tree, opts, getTask(gulpInst));
+    }
+    if (opts.tasksJson) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;

node_modules/gulp-cli/lib/versioned/^4.0.0/log/events.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var log = require('gulplog');
+var prettyTime = require('pretty-hrtime');
+
+var ansi = require('../../../shared/ansi');
+var formatError = require('../format-error');
+
+// Wire up logging events
+function logEvents(gulpInst) {
+
+  var loggedErrors = [];
+
+  gulpInst.on('start', function(evt) {
+    /* istanbul ignore next */
+    // TODO: batch these
+    // so when 5 tasks start at once it only logs one time with all 5
+    var level = evt.branch ? 'debug' : 'info';
+    log[level]('Starting', '\'' + ansi.cyan(evt.name) + '\'...');
+  });
+
+  gulpInst.on('stop', function(evt) {
+    var time = prettyTime(evt.duration);
+    /* istanbul ignore next */
+    var level = evt.branch ? 'debug' : 'info';
+    log[level](
+      'Finished', '\'' + ansi.cyan(evt.name) + '\'',
+      'after', ansi.magenta(time)
+    );
+  });
+
+  gulpInst.on('error', function(evt) {
+    var msg = formatError(evt);
+    var time = prettyTime(evt.duration);
+    var level = evt.branch ? 'debug' : 'error';
+    log[level](
+      '\'' + ansi.cyan(evt.name) + '\'',
+      ansi.red('errored after'),
+      ansi.magenta(time)
+    );
+
+    // If we haven't logged this before, log it and add to list
+    if (loggedErrors.indexOf(evt.error) === -1) {
+      log.error(msg);
+      loggedErrors.push(evt.error);
+    }
+  });
+}
+
+module.exports = logEvents;

node_modules/gulp-cli/lib/versioned/^4.0.0/log/get-task.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var isObject = require('isobject');
+
+function getTask(gulpInst) {
+  return function(name) {
+    var task = gulpInst.task(name);
+    return {
+      description: getDescription(task),
+      flags: getFlags(task),
+    };
+  };
+}
+
+function getDescription(task) {
+  if (typeof task.description === 'string') {
+    return task.description;
+  }
+  /* istanbul ignore else */
+  if (typeof task.unwrap === 'function') {
+    var origFn = task.unwrap();
+    if (typeof origFn.description === 'string') {
+      return origFn.description;
+    }
+  }
+  return undefined;
+}
+
+function getFlags(task) {
+  if (isObject(task.flags)) {
+    return task.flags;
+  }
+  /* istanbul ignore else */
+  if (typeof task.unwrap === 'function') {
+    var origFn = task.unwrap();
+    if (isObject(origFn.flags)) {
+      return origFn.flags;
+    }
+  }
+  return undefined;
+}
+
+module.exports = getTask;

node_modules/gulp-cli/lib/versioned/^4.0.0/log/sync-task.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var log = require('gulplog');
+var ansi = require('../../../shared/ansi');
+
+var tasks = {};
+
+function warn() {
+  var taskKeys = Object.keys(tasks);
+
+  if (!taskKeys.length) {
+    return;
+  }
+
+  var taskNames = taskKeys.map(function(key) {
+    return tasks[key];
+  }).join(', ');
+
+  process.exitCode = 1;
+
+  log.warn(
+    ansi.red('The following tasks did not complete:'),
+    ansi.cyan(taskNames)
+  );
+  log.warn(
+    ansi.red('Did you forget to signal async completion?')
+  );
+}
+
+function start(e) {
+  tasks[e.uid] = e.name;
+}
+
+function clear(e) {
+  delete tasks[e.uid];
+}
+
+function clearAll() {
+  tasks = {};
+}
+
+function logSyncTask(gulpInst, opts) {
+
+  process.once('exit', warn);
+  gulpInst.on('start', start);
+  gulpInst.on('stop', clear);
+  // When not running in --continue mode, we need to clear everything on error to avoid
+  // false positives.
+  gulpInst.on('error', opts.continue ? clear : clearAll);
+}
+
+module.exports = logSyncTask;

node_modules/gulp-cli/lib/versioned/^4.0.0/log/tasks-simple.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function logTasksSimple(nodes) {
+  console.log(nodes.join('\n').trim());
+}
+
+module.exports = logTasksSimple;