@automattic/vip 2.11.0 → 2.11.2

package/package/dist/lib/cli/envAlias.js

@@ -0,0 +1,60 @@
+"use strict";
+
+/**
+ * External dependencies
+ */
+exports.isAlias = function (alias) {
+  return /^@[A-Za-z0-9\.\-]+$/.test(alias);
+};
+
+exports.parseEnvAlias = function (alias) {
+  if (!exports.isAlias(alias)) {
+    throw new Error('Invalid environment alias. Aliases are in the format of @app-name or @app-name.environment-name');
+  } // Remove the '@'
+
+
+  const stripped = alias.substr(1).toLowerCase(); // in JS, .split() with a limit discards the extra ones, so can't use it
+  // Also convert to lowercase because mixed case environment names would cause problems
+
+  const [app, ...rest] = stripped.split('.');
+  let env = undefined; // Rejoin the env on '.' (if present), to handle instance names (env.instance-01)
+
+  if (rest && rest.length) {
+    env = rest.join('.');
+  }
+
+  return {
+    app,
+    env
+  };
+};
+
+exports.parseEnvAliasFromArgv = function (processArgv) {
+  // Clone to not affect original arvg
+  const argv = processArgv.slice(0); // If command included a `--` to indicate end of named args, lets only consider aliases
+  // _before_ it, so that it can be passed to other commands directly
+
+  const dashDashIndex = argv.indexOf('--');
+  let argsBeforeDashDash = argv;
+
+  if (dashDashIndex > -1) {
+    argsBeforeDashDash = argv.slice(0, dashDashIndex);
+  }
+
+  const alias = argsBeforeDashDash.find(arg => exports.isAlias(arg));
+
+  if (!alias) {
+    return {
+      argv
+    };
+  } // If we did have an alias, split it up into app/env
+
+
+  const parsedAlias = exports.parseEnvAlias(alias); // Splice out the alias
+
+  argv.splice(argv.indexOf(alias), 1);
+  return {
+    argv,
+    ...parsedAlias
+  };
+};

package/package/dist/lib/cli/exit.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withError = withError;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _env = _interopRequireDefault(require("../env"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+function withError(message) {
+  console.log(`${_chalk.default.red('Error: ')} ${message.toString().replace(/^Error:\s*/, '')}`); // Debug ouput is printed below error output both for information
+  // hierarchy and to make it more likely that the user copies it to their
+  // clipboard when dragging across output.
+
+  console.log(`${_chalk.default.yellow('Debug: ')} VIP-CLI v${_env.default.app.version}, Node ${_env.default.node.version}, ${_env.default.os.name} ${_env.default.os.version}`);
+  process.exit(1);
+}

package/package/dist/lib/cli/format.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatData = formatData;
+exports.formatEnvironment = formatEnvironment;
+exports.table = table;
+exports.keyValue = keyValue;
+exports.requoteArgs = requoteArgs;
+exports.capitalize = capitalize;
+exports.getGlyphForStatus = getGlyphForStatus;
+exports.formatSearchReplaceValues = exports.RunningSprite = exports.RUNNING_SPRITE_GLYPHS = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** @format */
+
+/**
+ * External dependencies
+ */
+function formatData(data, format, opts) {
+  if (!data || !data.length) {
+    return '';
+  }
+
+  switch (format) {
+    case 'ids':
+      return ids(data, opts);
+
+    case 'json':
+      return JSON.stringify(data, null, '\t');
+
+    case 'csv':
+      return csv(data, opts);
+
+    case 'keyValue':
+      return keyValue(data, opts);
+
+    case 'table':
+    default:
+      return table(data, opts);
+  }
+}
+
+function formatEnvironment(environment) {
+  if ('production' === environment.toLowerCase()) {
+    return _chalk.default.red(environment.toUpperCase());
+  }
+
+  return _chalk.default.blueBright(environment.toLowerCase());
+}
+
+function ids(data) {
+  const fields = Object.keys(data[0]).map(key => key.toLowerCase());
+
+  if (0 > fields.indexOf('id')) {
+    return 'No ID field found';
+  }
+
+  const id = [];
+  data.forEach(datum => id.push(datum.id));
+  return id.join(' ');
+}
+
+function csv(data) {
+  const {
+    Parser
+  } = require('json2csv');
+
+  const fields = Object.keys(data[0]);
+  const parser = new Parser({
+    fields: formatFields(fields)
+  });
+  return parser.parse(data);
+}
+
+function table(data) {
+  const Table = require('cli-table');
+
+  const fields = Object.keys(data[0]);
+  const dataTable = new Table({
+    head: formatFields(fields),
+    style: {
+      head: ['blueBright']
+    }
+  });
+  data.forEach(datum => {
+    const row = [];
+    fields.forEach(field => row.push(datum[field]));
+    dataTable.push(row);
+  });
+  return dataTable.toString();
+}
+
+function formatFields(fields) {
+  return fields.map(field => {
+    return field.split(/(?=[A-Z])/).join(' ').toLowerCase();
+  });
+}
+
+function keyValue(values) {
+  const lines = [];
+  const pairs = values.length > 0;
+  pairs ? lines.push('===================================') : '';
+
+  for (const {
+    key,
+    value
+  } of values) {
+    let formattedValue = value;
+
+    switch (key.toLowerCase()) {
+      case 'environment':
+        formattedValue = formatEnvironment(value);
+        break;
+    }
+
+    lines.push(`+ ${key}: ${formattedValue}`);
+  }
+
+  lines.push('===================================');
+  return lines.join('\n');
+}
+
+function requoteArgs(args) {
+  return args.map(arg => {
+    if (arg.includes('--') && arg.includes('=') && arg.includes(' ')) {
+      return arg.replace(/^--(.*)=(.*)$/, '--$1="$2"');
+    }
+
+    if (arg.includes(' ')) {
+      return `"${arg}"`;
+    }
+
+    return arg;
+  });
+}
+
+function capitalize(str) {
+  if (typeof str !== 'string' || !str.length) {
+    return '';
+  }
+
+  return str[0].toUpperCase() + str.slice(1);
+}
+
+const RUNNING_SPRITE_GLYPHS = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+exports.RUNNING_SPRITE_GLYPHS = RUNNING_SPRITE_GLYPHS;
+
+class RunningSprite {
+  constructor() {
+    this.count = 0;
+  }
+
+  next() {
+    if (++this.count >= RUNNING_SPRITE_GLYPHS.length) {
+      this.count = 0;
+    }
+  }
+
+  toString() {
+    const glyph = RUNNING_SPRITE_GLYPHS[this.count];
+    this.next(); // TODO: throttle
+
+    return glyph;
+  }
+
+}
+
+exports.RunningSprite = RunningSprite;
+
+function getGlyphForStatus(status, runningSprite) {
+  switch (status) {
+    default:
+      return '';
+
+    case 'pending':
+      return '○';
+
+    case 'running':
+      return _chalk.default.blueBright(runningSprite);
+
+    case 'success':
+      return _chalk.default.green('✓');
+
+    case 'failed':
+      return _chalk.default.red('✕');
+
+    case 'unknown':
+      return _chalk.default.yellow('✕');
+
+    case 'skipped':
+      return _chalk.default.green('-');
+  }
+} // Format Search and Replace values to output
+
+
+const formatSearchReplaceValues = (values, message) => {
+  // Convert single pair S-R values to arrays
+  const searchReplaceValues = typeof values === 'string' ? [values] : values;
+  const formattedOutput = searchReplaceValues.map(pairs => {
+    // Turn each S-R pair into its own array, then trim away whitespace
+    const [from, to] = pairs.split(',').map(pair => pair.trim());
+    const output = message(from, to);
+    return output;
+  });
+  return formattedOutput;
+};
+
+exports.formatSearchReplaceValues = formatSearchReplaceValues;

package/package/dist/lib/cli/pager.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = pager;
+exports.end = end;
+
+var _child_process = require("child_process");
+
+var _stream = require("stream");
+
+/**
+ * External dependencies
+ */
+let proc;
+
+function pager() {
+  let less;
+
+  switch (process.platform) {
+    case 'win32':
+      // PROGRA~1 is the short name for Program Files
+      // we're using it here to avoid the space which is broken by .split( ' ' )
+      less = 'C:\\PROGRA~1\\Git\\usr\\bin\\less.exe -FRX';
+      break;
+
+    default:
+      less = 'less -FRX';
+  }
+
+  const args = (process.env.PAGER || less).split(' ');
+  const bin = args.shift(); // passthrough pipe so we can change the output pipe if necessary
+
+  const pipe = new _stream.PassThrough();
+  proc = (0, _child_process.spawn)(bin, args, {
+    stdio: ['pipe', process.stdout, process.stderr]
+  });
+  proc.on('exit', () => {
+    proc.stdin.emit('done');
+  }); // If we can't spawn less, pipe directly to stdout
+
+  pipe.pipe(proc.stdin);
+  proc.on('error', () => {
+    pipe.pipe(process.stdout);
+  });
+  return pipe;
+}
+
+function end() {
+  proc.end();
+}

package/package/dist/lib/cli/progress.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProgressTracker = void 0;
+
+var _singleLineLog = require("single-line-log");
+
+var _format = require("./format");
+
+/** @format */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const PRINT_INTERVAL = process.env.DEBUG ? 5000 : 200; // How often the report is printed. Mainly affects the "spinner" animation.
+
+const COMPLETED_STEP_SLUGS = ['success', 'skipped'];
+
+class ProgressTracker {
+  // Track the state of each step
+  // Spinnerz go brrrr
+  // This gets printed before the step status
+  // This gets printed after the step status
+  constructor(steps) {
+    this.runningSprite = new _format.RunningSprite();
+    this.hasFailure = false;
+    this.stepsFromCaller = this.mapSteps(steps);
+    this.stepsFromServer = new Map();
+    this.prefix = '';
+    this.suffix = '';
+  }
+
+  getSteps() {
+    return new Map([...this.stepsFromCaller, ...this.stepsFromServer]);
+  }
+
+  mapSteps(steps) {
+    return steps.reduce((map, {
+      id,
+      name,
+      status
+    }) => {
+      map.set(id, {
+        id,
+        name,
+        status: status || 'pending'
+      });
+      return map;
+    }, new Map());
+  }
+
+  setUploadPercentage(percentage) {
+    const uploadStep = this.stepsFromCaller.get('upload');
+
+    if (!uploadStep) {
+      return;
+    }
+
+    this.stepsFromCaller.set('upload', { ...uploadStep,
+      percentage
+    });
+  }
+
+  setStepsFromServer(steps) {
+    const formattedSteps = steps.map(({
+      name,
+      status
+    }, index) => ({
+      id: `server-${index}-${name}`,
+      name,
+      status
+    }));
+
+    if (!steps.some(({
+      status
+    }) => status === 'running')) {
+      const firstPendingStepIndex = steps.findIndex(({
+        status
+      }) => status === 'pending');
+
+      if (firstPendingStepIndex !== -1) {
+        // "Promote" the first "pending" to "running"
+        formattedSteps[firstPendingStepIndex].status = 'running';
+      }
+    }
+
+    this.stepsFromServer = this.mapSteps(formattedSteps);
+  }
+
+  getNextStep() {
+    if (this.allStepsSucceeded()) {
+      return undefined;
+    }
+
+    const steps = [...this.getSteps().values()];
+    return steps.find(({
+      status
+    }) => status === 'pending');
+  }
+
+  stepRunning(stepId) {
+    this.setStatusForStepId(stepId, 'running');
+  }
+
+  stepFailed(stepId) {
+    this.setStatusForStepId(stepId, 'failed');
+  }
+
+  stepSkipped(stepId) {
+    this.setStatusForStepId(stepId, 'skipped');
+  }
+
+  stepSuccess(stepId) {
+    this.setStatusForStepId(stepId, 'success'); // The stepSuccess helper automatically sets the next step to "running"
+
+    const nextStep = this.getNextStep();
+
+    if (nextStep) {
+      this.stepRunning(nextStep.id);
+      return;
+    }
+  }
+
+  allStepsSucceeded() {
+    return ![...this.getSteps().values()].some(({
+      status
+    }) => status !== 'success');
+  }
+
+  setStatusForStepId(stepId, status) {
+    const step = this.stepsFromCaller.get(stepId);
+
+    if (!step) {
+      // Only allowed to update existing steps with this method
+      throw new Error(`Step name ${stepId} is not valid.`);
+    }
+
+    if (COMPLETED_STEP_SLUGS.includes(step.status)) {
+      throw new Error(`Step name ${stepId} is already completed.`);
+    }
+
+    if (status === 'failed') {
+      this.hasFailure = true;
+    }
+
+    this.stepsFromCaller.set(stepId, { ...step,
+      status
+    });
+  }
+
+  startPrinting(prePrintCallback = () => {}) {
+    this.printInterval = setInterval(() => {
+      prePrintCallback();
+      this.print();
+    }, PRINT_INTERVAL);
+  }
+
+  stopPrinting() {
+    if (this.printInterval) {
+      clearInterval(this.printInterval);
+    }
+  }
+
+  print({
+    clearAfter = false
+  } = {}) {
+    if (!this.hasPrinted) {
+      this.hasPrinted = true;
+
+      _singleLineLog.stdout.clear();
+    }
+
+    const stepValues = [...this.getSteps().values()];
+    const logs = stepValues.reduce((accumulator, {
+      name,
+      id,
+      percentage,
+      status
+    }) => {
+      const statusIcon = (0, _format.getGlyphForStatus)(status, this.runningSprite);
+      let suffix = '';
+
+      if (id === 'upload') {
+        if (status === 'running' && percentage) {
+          suffix = percentage;
+        }
+      }
+
+      return `${accumulator}${statusIcon} ${name} ${suffix}\n`;
+    }, ''); // Output the logs
+
+    (0, _singleLineLog.stdout)(`${this.prefix || ''}${logs}${this.suffix || ''}`);
+
+    if (clearAfter) {
+      // Break out of the "Single log line" buffer
+      _singleLineLog.stdout.clear();
+    }
+  }
+
+}
+
+exports.ProgressTracker = ProgressTracker;

package/package/dist/lib/cli/prompt.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confirm = confirm;
+
+var _enquirer = require("enquirer");
+
+var _format = require("./format");
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+
+/* eslint-disable no-duplicate-imports */
+
+/* eslint-enable no-duplicate-imports */
+async function confirm(values, message, skipPrompt = false) {
+  console.log((0, _format.keyValue)(values));
+
+  if (!skipPrompt) {
+    const answer = await (0, _enquirer.prompt)({
+      type: 'confirm',
+      name: 'confirm',
+      message: message,
+      default: false
+    });
+    return answer.confirm;
+  }
+
+  return true;
+}

package/package/dist/lib/cli/repo.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getRepoFromGitConfig;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _ini = _interopRequireDefault(require("ini"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * External dependencies
+ */
+async function getRepoFromGitConfig() {
+  const file = await find();
+
+  if (!file.length) {
+    return '';
+  }
+
+  const config = _ini.default.parse(_fs.default.readFileSync(file, 'utf-8')); // Find the first 'wpcomvip' remote
+
+
+  for (const key in config) {
+    if ('remote' !== key.substring(0, 6)) {
+      continue;
+    }
+
+    if (!config[key].url) {
+      continue;
+    }
+
+    if (0 > config[key].url.indexOf('wpcomvip/')) {
+      continue;
+    }
+
+    let repo = config[key].url;
+    repo = repo.replace(/.git$/, '');
+    repo = repo.replace('https://github.com/', '');
+    repo = repo.replace('git@github.com:', '');
+    return repo;
+  }
+
+  return;
+}
+
+async function find(dir) {
+  dir = dir || process.cwd();
+  const test = dir + '/.git/config';
+
+  if (await exists(test)) {
+    return test;
+  } // Bail if we went all the way and didn't find it
+
+
+  const directory = _path.default.parse(dir);
+
+  if (directory.dir === directory.root) {
+    return '';
+  } // cd ..
+
+
+  const up = dir.split(_path.default.sep);
+  up.pop();
+  return find(up.join(_path.default.sep));
+}
+
+async function exists(file) {
+  return new Promise(resolve => {
+    _fs.default.access(file, _fs.default.constants.F_OK, err => resolve(!err));
+  });
+}