Add production dependencies

node_modules/gulp-cli/lib/shared/log/blacklist-error.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var log = require('gulplog');
+
+var ansi = require('../ansi');
+var exit = require('../exit');
+
+/* istanbul ignore next */
+function logBlacklistError(err) {
+  log.error(ansi.red('Error: failed to retrieve plugins black-list'));
+  log.error(err.message); // Avoid duplicating for each version
+  exit(1);
+}
+
+module.exports = logBlacklistError;

node_modules/gulp-cli/lib/shared/log/copy-tree.js

@@ -0,0 +1,81 @@
+'use strict';
+
+function copyNode(node) {
+  var newNode = {};
+  Object.keys(node).forEach(function(key) {
+    newNode[key] = node[key];
+  });
+  return newNode;
+}
+
+var defaultNodeFactory = {
+  topNode: copyNode,
+  taskNode: copyNode,
+  childNode: copyNode,
+};
+
+function copyTree(tree, opts, nodeFactory) {
+  opts = opts || {};
+
+  var depth = opts.tasksDepth;
+  depth = typeof depth === 'number' ? ((depth < 1) ? 1 : depth) : null;
+
+  nodeFactory = nodeFactory || defaultNodeFactory;
+
+  var newTree = nodeFactory.topNode(tree);
+  newTree.nodes = [];
+
+  if (Array.isArray(tree.nodes)) {
+    tree.nodes.forEach(visit);
+  }
+
+  function visit(node) {
+    var newNode = nodeFactory.taskNode(node);
+    newNode.nodes = [];
+    newTree.nodes.push(newNode);
+
+    if (opts.compactTasks) {
+      forEach(node.nodes, copyNotRecursively, newNode);
+
+    } else if (!depth || depth > 1) {
+      forEach(node.nodes, copyRecursively, depth, 2, newNode);
+    }
+  }
+
+  function copyNotRecursively(child, newParent) {
+    var newChild = nodeFactory.childNode(child);
+    newChild.nodes = [];
+    newParent.nodes.push(newChild);
+
+    if (child.branch) {
+      forEach(child.nodes, copyNotRecursively, newChild);
+    }
+  }
+
+  function copyRecursively(child, maxDepth, nowDepth, newParent) {
+    var newChild = nodeFactory.childNode(child);
+    newChild.nodes = [];
+    newParent.nodes.push(newChild);
+
+    if (!maxDepth || maxDepth > nowDepth) {
+      forEach(child.nodes, copyRecursively, maxDepth, nowDepth + 1, newChild);
+    }
+  }
+
+  return newTree;
+}
+
+function forEach(nodes, fn) {
+  if (!Array.isArray(nodes)) {
+    return;
+  }
+
+  var args = Array.prototype.slice.call(arguments, 2);
+
+  for (var i = 0, n = nodes.length; i < n; i++) {
+    fn.apply(nodes[i], [nodes[i]].concat(args));
+  }
+}
+
+module.exports = copyTree;
+

node_modules/gulp-cli/lib/shared/log/tasks.js

@@ -0,0 +1,166 @@
+'use strict';
+
+var archy = require('archy');
+var log = require('gulplog');
+
+var sortBy = require('array-sort');
+var isObject = require('isobject');
+
+var ansi = require('../ansi');
+var copyTree = require('./copy-tree');
+
+function logTasks(tree, opts, getTask) {
+  if (opts.sortTasks) {
+    tree.nodes = sortBy(tree.nodes, 'label');
+  }
+
+  var lineInfos = [];
+  var entryObserver = getLineInfoCollector(lineInfos);
+  var nodeFactory = getNodeFactory(getTask, entryObserver);
+
+  tree = copyTree(tree, opts, nodeFactory);
+  var spacer = getSpacerForLineIndents(tree, lineInfos);
+  var lines = getLinesContainingOnlyBranches(tree);
+
+  log.info(tree.label);
+  printTreeList(lines, spacer, lineInfos);
+}
+
+function getLineInfoCollector(lineInfos) {
+  return {
+    topTask: function(node) {
+      lineInfos.push({
+        name: node.label,
+        desc: node.desc,
+        type: 'top',
+      });
+    },
+    option: function(opt) {
+      lineInfos.push({
+        name: opt.label,
+        desc: opt.desc,
+        type: 'option',
+      });
+    },
+    childTask: function(node) {
+      lineInfos.push({
+        name: node.label,
+        type: 'child',
+      });
+    },
+  };
+}
+
+function getNodeFactory(getTask, entryObserver) {
+  return {
+    topNode: function(node) {
+      return {
+        label: node.label,
+      };
+    },
+
+    taskNode: function(node) {
+      /* istanbul ignore next */
+      var task = getTask(node.label) || {};
+
+      var newNode = {
+        label: node.label,
+        desc: typeof task.description === 'string' ? task.description : '',
+        opts: [],
+      };
+      entryObserver.topTask(newNode);
+
+      if (isObject(task.flags)) {
+        Object.keys(task.flags).sort().forEach(function(flag) {
+          if (flag.length === 0) {
+            return;
+          }
+          /* istanbul ignore next */
+          var opt = {
+            label: flag,
+            desc: typeof task.flags[flag] === 'string' ? task.flags[flag] : '',
+          };
+          entryObserver.option(opt);
+          newNode.opts.push(opt);
+          newNode.label += '\n' + opt.label; // The way of archy for options.
+        });
+      }
+
+      return newNode;
+    },
+
+    childNode: function(node) {
+      var newChild = {
+        label: node.label,
+      };
+      entryObserver.childTask(newChild);
+      newChild.label = ''; // Because don't use child tasks to calc indents.
+
+      return newChild;
+    },
+  };
+}
+
+function getSpacerForLineIndents(tree, lineInfos) {
+  var maxSize = 0;
+  var sizes = [];
+
+  archy(tree)
+    .split('\n')
+    .slice(1, -1)
+    .forEach(function(line, index) {
+      var info = lineInfos[index];
+      if (info.type === 'top' || info.type === 'option') {
+        maxSize = Math.max(maxSize, line.length);
+        sizes.push(line.length);
+      } else {
+        sizes.push(0);
+      }
+    });
+
+  maxSize += 3;
+
+  return function(index) {
+    return Array(maxSize - sizes[index]).join(' ');
+  };
+}
+
+function getLinesContainingOnlyBranches(tree) {
+  tree.nodes.forEach(function(node) {
+    node.label = '';
+    node.opts.forEach(function() {
+      node.label += '\n';
+    });
+  });
+
+  return archy(tree)
+    .split('\n')
+    .slice(1, -1);
+}
+
+function printTreeList(lines, spacer, lineInfos) {
+  lines.forEach(function(branch, index) {
+    var info = lineInfos[index];
+
+    var line = ansi.white(branch);
+
+    if (info.type === 'top') {
+      line += ansi.cyan(info.name);
+      if (info.desc.length > 0) {
+        line += spacer(index) + ansi.white(info.desc);
+      }
+    } else if (info.type === 'option') {
+      line += ansi.magenta(info.name);
+      if (info.desc.length > 0) {
+        line += spacer(index) + ansi.white('…' + info.desc);
+      }
+    } else { // If (info.type === 'child') {
+      line += ansi.white(info.name);
+    }
+
+    log.info(line);
+  });
+}
+
+module.exports = logTasks;
+

node_modules/gulp-cli/lib/shared/log/to-console.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var fancyLog = require('fancy-log');
+
+/* istanbul ignore next */
+function noop() {}
+
+// The sorting of the levels is
+// significant.
+var levels = [
+  'error', // -L: Logs error events.
+  'warn',  // -LL: Logs warn and error events.
+  'info',  // -LLL: Logs info, warn and error events.
+  'debug', // -LLLL: Logs all log levels.
+];
+
+function cleanup(log) {
+  levels.forEach(removeListeners);
+
+  function removeListeners(level) {
+    if (level === 'error') {
+      log.removeListener(level, noop);
+      log.removeListener(level, fancyLog.error);
+    } else {
+      log.removeListener(level, fancyLog);
+    }
+  }
+}
+
+function toConsole(log, opts) {
+  // Remove previous listeners to enable to call this twice.
+  cleanup(log);
+
+  // Return immediately if logging is
+  // not desired.
+  if (opts.tasksSimple || opts.tasksJson || opts.help || opts.version || opts.silent) {
+    // Keep from crashing process when silent.
+    log.on('error', noop);
+    return;
+  }
+
+  // Default loglevel to info level (3).
+  var loglevel = opts.logLevel || 3;
+
+  levels
+    .filter(function(item, i) {
+      return i < loglevel;
+    })
+    .forEach(function(level) {
+      if (level === 'error') {
+        log.on(level, fancyLog.error);
+      } else {
+        log.on(level, fancyLog);
+      }
+    });
+}
+
+module.exports = toConsole;

node_modules/gulp-cli/lib/shared/log/verify.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var log = require('gulplog');
+
+var ansi = require('../ansi');
+var exit = require('../exit');
+
+function logVerify(blacklisted) {
+  var pluginNames = Object.keys(blacklisted);
+
+  if (!pluginNames.length) {
+    log.info(
+      ansi.green('There are no blacklisted plugins in this project')
+    );
+    exit(0);
+  }
+
+  log.warn(ansi.red('Blacklisted plugins found in this project:'));
+
+  pluginNames.map(function(pluginName) {
+    var reason = blacklisted[pluginName];
+    log.warn(ansi.bgred(pluginName) + ': ' + reason);
+  });
+
+  exit(1);
+}
+
+module.exports = logVerify;