ember-try 1.4.0 → 2.0.0

package/lib/tasks/try-each.js

@@ -1,102 +1,118 @@
 'use strict';
 
 const CoreObject = require('core-object');
-const RSVP = require('rsvp');
-const mapSeries = require('promise-map-series');
 const chalk = require('chalk');
 const debug = require('debug')('ember-try:task:try-each');
 const runCommand = require('./../utils/run-command');
 
 module.exports = CoreObject.extend({
-  run(scenarios, options) {
+  async run(scenarios, options) {
     // Required lazily to improve startup speed.
     let ScenarioManager = require('./../utils/scenario-manager');
     let DependencyManagerAdapterFactory = require('./../utils/dependency-manager-adapter-factory');
     this.ResultSummary = require('./../utils/result-summary');
 
-    let task = this;
-    let dependencyManagerAdapters = task.dependencyManagerAdapters || DependencyManagerAdapterFactory.generateFromConfig(task.config, task.project.root);
-    debug('DependencyManagerAdapters: %s', dependencyManagerAdapters.map((item) => { return item.configKey; }));
-    task.ScenarioManager = new ScenarioManager({
-      ui: task.ui,
+    let dependencyManagerAdapters =
+      this.dependencyManagerAdapters ||
+      DependencyManagerAdapterFactory.generateFromConfig(this.config, this.project.root);
+    debug(
+      'DependencyManagerAdapters: %s',
+      dependencyManagerAdapters.map((item) => {
+        return item.configKey;
+      })
+    );
+    this.ScenarioManager = new ScenarioManager({
+      ui: this.ui,
       dependencyManagerAdapters,
     });
 
-    task._canceling = false;
-    task._on('SIGINT', () => {
-      task._canceling = true;
-      task.ui.writeLine('\nGracefully shutting down from SIGINT (Ctrl-C)');
-      return task.ScenarioManager.cleanup();
+    this._canceling = false;
+    this._on('SIGINT', () => {
+      this._canceling = true;
+      this.ui.writeLine('\nGracefully shutting down from SIGINT (Ctrl-C)');
+      return this.ScenarioManager.cleanup();
     });
 
-    return task.ScenarioManager.setup().then(() => {
+    try {
+      await this.ScenarioManager.setup();
       debug('Scenario Manager setup');
-      return mapSeries(scenarios, task._runCommandForThisScenario, task);
-    }).then((results) => {
-      return task._optionallyCleanup(options).then(() => {
-        debug('Output results');
-        task._printResults(results);
-        return task._exitAsAppropriate(results);
-      });
-    }).catch((err) => {
-      task.ui.writeLine(chalk.red('Error!'));
+
+      let results = [];
+      for (let scenario of scenarios) {
+        results.push(await this._runCommandForThisScenario(scenario));
+      }
+
+      await this._optionallyCleanup(options);
+
+      debug('Output results');
+      this._printResults(results);
+
+      return this._exitAsAppropriate(results);
+    } catch (err) {
+      this.ui.writeLine(chalk.red('Error!'));
+
       if (err) {
-        task.ui.writeLine(chalk.red(err));
-        task.ui.writeLine(chalk.red(err.stack));
+        this.ui.writeLine(chalk.red(err));
+        this.ui.writeLine(chalk.red(err.stack));
       }
+
       return 1; // Signifies exit code
-    });
+    }
   },
 
-  _runCommandForThisScenario(scenario) {
-    let task = this;
+  async _runCommandForThisScenario(scenario) {
+    if (this._canceling) {
+      return;
+    }
 
-    if (task._canceling) { return; }
+    let scenarioDependencyState = await this.ScenarioManager.changeTo(scenario);
 
-    return task.ScenarioManager.changeTo(scenario)
-      .then((scenarioDependencyState) => {
-        if (task._canceling) { return; }
+    if (this._canceling) {
+      return;
+    }
 
-        process.env.EMBER_TRY_CURRENT_SCENARIO = scenario.name;
-        task._writeHeader(`Scenario: ${scenario.name}`);
-        let command = task._determineCommandFor(scenario);
-        let runResults = {
-          scenario: scenario.name,
-          allowedToFail: !!scenario.allowedToFail,
-          dependencyState: scenarioDependencyState,
-          envState: scenario.env,
-          command: command.join(' '),
-        };
+    process.env.EMBER_TRY_CURRENT_SCENARIO = scenario.name;
+    this._writeHeader(`Scenario: ${scenario.name}`);
 
-        debug('With:\n', runResults);
+    let command = this._determineCommandFor(scenario);
+    let runResults = {
+      scenario: scenario.name,
+      allowedToFail: !!scenario.allowedToFail,
+      dependencyState: scenarioDependencyState,
+      envState: scenario.env,
+      command: command.join(' '),
+    };
 
-        return task._runCommand({ commandArgs: command, commandOptions: task._commandOptions(scenario.env) }).then((result) => {
-          if (task._canceling) { return; }
+    debug('With:\n', runResults);
 
-          runResults.result = result;
-          task._writeFooter(`Result: ${result}`);
-          return RSVP.resolve(runResults);
-        });
-      });
+    let result = await this._runCommand({
+      commandArgs: command,
+      commandOptions: this._commandOptions(scenario.env),
+    });
+
+    if (this._canceling) {
+      return;
+    }
+
+    runResults.result = result;
+    this._writeFooter(`Result: ${result}`);
+
+    return runResults;
   },
 
   _writeHeader(text) {
-    let task = this;
     let count = 75 - text.length;
     let separator = new Array(count + 1).join('=');
-    task.ui.writeLine(chalk.blue(`\n=== ${text} ${separator}\n`));
+    this.ui.writeLine(chalk.blue(`\n=== ${text} ${separator}\n`));
   },
 
   _writeFooter(text) {
-    let task = this;
-    task.ui.writeLine(chalk.blue(`\n${text}`));
-    task.ui.writeLine(chalk.blue('---\n'));
+    this.ui.writeLine(chalk.blue(`\n${text}`));
+    this.ui.writeLine(chalk.blue('---\n'));
   },
 
   _determineCommandFor(scenario) {
-    let task = this;
-
-    if (task.commandArgs && task.commandArgs.length) {
+    if (this.commandArgs && this.commandArgs.length) {
       return this.commandArgs;
     }
 
@@ -104,8 +120,8 @@ module.exports = CoreObject.extend({
       return scenario.command.split(' ');
     }
 
-    if (task.config.command) {
-      return task.config.command.split(' ');
+    if (this.config.command) {
+      return this.config.command.split(' ');
     }
 
     return this._defaultCommandArgs();
@@ -139,21 +155,17 @@ module.exports = CoreObject.extend({
     return this._exitBasedOnCondition(outcomes.indexOf(false) > -1);
   },
 
-  _optionallyCleanup(options) {
+  async _optionallyCleanup(options) {
     debug('Cleanup');
     delete process.env.EMBER_TRY_CURRENT_SCENARIO;
 
-    let task = this;
-    let promise;
     if (options && options.skipCleanup) {
       // Create a fake promise for consistency
       debug('Skip ScenarioManager cleanup');
-      promise = RSVP.Promise.resolve();
     } else {
       debug('Cleanup ScenarioManager');
-      promise = task.ScenarioManager.cleanup();
+      return await this.ScenarioManager.cleanup();
     }
-    return promise;
   },
 
   _exitBasedOnCondition(condition) {
@@ -170,5 +182,4 @@ module.exports = CoreObject.extend({
   _on(signal, fn) {
     process.on(signal, fn);
   },
-
 });

package/lib/utils/config.js

@@ -2,96 +2,88 @@
 
 const path = require('path');
 const fs = require('fs');
-const extend = require('extend');
-const RSVP = require('rsvp');
 const findByName = require('./find-by-name');
 const debug = require('debug')('ember-try:utils:config');
 
-const IMPLICIT_BOWER_VERSION = '^1.8.2';
+function getConfigPath(project) {
+  let possibleConfigPath;
+  if (project.pkg && project.pkg['ember-addon'] && project.pkg['ember-addon']['configPath']) {
+    let configDir = project.pkg['ember-addon']['configPath'];
 
-function getBaseConfig(options) {
-  let relativePath = options.configPath || path.join('config', 'ember-try.js');
-  let configFile = path.join(options.project.root, relativePath);
-  let configData;
+    possibleConfigPath = path.join(configDir, 'ember-try.js');
+  }
 
-  if (fs.existsSync(configFile)) {
-    configData = require(configFile);
+  if (fs.existsSync(possibleConfigPath)) {
+    debug(`using config from package.json ember-addon.configPath: ${possibleConfigPath}`);
 
-    if (typeof configData === 'function') {
-      configData = configData(options.project);
-    }
-  } else {
-    debug('Config file does not exist %s', configFile);
+    return possibleConfigPath;
   }
 
-  return RSVP.resolve(configData).then((data) => {
-    if (data && data.scenarios && !data.useVersionCompatibility && !options.versionCompatibility) {
-      return RSVP.resolve(data);
-    }
-
-    let versionCompatibility = options.versionCompatibility || versionCompatibilityFromPackageJSON(options.project.root);
-
-    if (versionCompatibility) {
-      // Required lazily to improve startup speed.
-      let autoScenarioConfigForEmber = require('ember-try-config');
-      return autoScenarioConfigForEmber({ versionCompatibility, project: options.project }).then((autoConfig) => {
-        return mergeAutoConfigAndConfigFileData(autoConfig, data);
-      });
-    } else {
-      return RSVP.reject(new Error('No ember-try configuration found. Please see the README for configuration options'));
-    }
-  });
+  debug('using config from config/ember-try.js');
+
+  return path.join('config', 'ember-try.js');
 }
 
-function config(options) {
-  return getBaseConfig(options).then((configData) => {
-    return addImplicitBowerToScenarios(configData);
-  });
+async function getBaseConfig(options) {
+  let relativeConfigPath = options.configPath || getConfigPath(options.project);
+  let configPath = path.join(options.project.root, relativeConfigPath);
+  let data;
+
+  if (fs.existsSync(configPath)) {
+    let configData = await require(configPath);
+
+    data = typeof configData === 'function' ? await configData(options.project) : configData;
+  } else {
+    debug('Config file does not exist %s', configPath);
+  }
+
+  if (data && data.scenarios && !data.useVersionCompatibility && !options.versionCompatibility) {
+    return data;
+  }
+
+  let versionCompatibility =
+    options.versionCompatibility || versionCompatibilityFromPackageJSON(options.project.root);
+  if (versionCompatibility) {
+    // Required lazily to improve startup speed.
+    let autoScenarioConfigForEmber = require('ember-try-config');
+
+    let autoConfig = await autoScenarioConfigForEmber({
+      versionCompatibility,
+      project: options.project,
+    });
+    return await mergeAutoConfigAndConfigFileData(autoConfig, data);
+  } else {
+    throw new Error(
+      'No ember-try configuration found. Please see the README for configuration options'
+    );
+  }
 }
 
-module.exports = config;
+async function config(options) {
+  const configData = await getBaseConfig(options);
 
-function addImplicitBowerToScenarios(configData) {
-  configData.scenarios.forEach((scenario) => {
-    if (!('bower' in scenario)) {
-      // Don't do anything for scenarios that don't include bower
-      return;
-    }
-
-    if ('npm' in scenario) {
-      let npm = scenario.npm;
-      if ((npm.dependencies && npm.dependencies.bower) ||
-          (npm.devDependencies && npm.devDependencies.bower)) {
-        // Dont' do anything for scenarios that already include bower in npm,
-        // either as a dependency or a dev dependency
-        return;
-      }
-    }
-
-    // add an implicit bower dev dependency to npm for this scenario
-    scenario.npm = scenario.npm || {};
-    scenario.npm.devDependencies = scenario.npm.devDependencies || {};
-    scenario.npm.devDependencies.bower = IMPLICIT_BOWER_VERSION;
-  });
   return configData;
 }
 
+module.exports = config;
+
 function mergeAutoConfigAndConfigFileData(autoConfig, configData) {
   configData = configData || {};
   configData.scenarios = configData.scenarios || [];
 
-  let conf = extend({}, autoConfig, configData);
+  let conf = Object.assign({}, autoConfig, configData);
 
   let overriddenScenarios = autoConfig.scenarios.map((scenario) => {
     let overriddenScenario = findByName(configData.scenarios, scenario.name);
-    return extend({}, scenario, overriddenScenario);
+    return Object.assign({}, scenario, overriddenScenario);
   });
 
   let additionalScenarios = configData.scenarios.filter((scenario) => {
     return !findByName(autoConfig.scenarios, scenario.name);
   });
 
-  conf.scenarios = [].concat(overriddenScenarios, additionalScenarios);
+  conf.scenarios = [...overriddenScenarios, ...additionalScenarios];
+
   return conf;
 }
 
@@ -99,9 +91,7 @@ function versionCompatibilityFromPackageJSON(root) {
   let packageJSONFile = path.join(root, 'package.json');
   if (fs.existsSync(packageJSONFile)) {
     let packageJSON = JSON.parse(fs.readFileSync(packageJSONFile));
+
     return packageJSON['ember-addon'] ? packageJSON['ember-addon'].versionCompatibility : null;
   }
 }
-
-// Used for internal testing purposes.
-module.exports._addImplicitBowerToScenarios = addImplicitBowerToScenarios;

package/lib/utils/dependency-manager-adapter-factory.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const BowerAdapter = require('../dependency-manager-adapters/bower');
 const NpmAdapter = require('../dependency-manager-adapters/npm');
+const PnpmAdapter = require('../dependency-manager-adapters/pnpm');
 const WorkspaceAdapter = require('../dependency-manager-adapters/workspace');
 
 module.exports = {
@@ -22,22 +22,40 @@ module.exports = {
       }
     });
 
-    if (config.useWorkspaces) {
-      if (hasBower) {
-        throw new Error('bower is not supported when using workspaces');
-      }
+    if (hasBower) {
+      throw new Error('[ember-try] bower configuration is no longer supported');
+    }
 
+    if (config.useWorkspaces) {
       adapters.push(
         new WorkspaceAdapter({
           cwd: root,
           managerOptions: config.npmOptions,
           useYarnCommand: config.useYarn,
-          buildManagerOptions: config.buildManagerOptions
+          buildManagerOptions: config.buildManagerOptions,
+        })
+      );
+    } else if (config.usePnpm) {
+      console.warn(
+        'pnpm support is experimental for now. if you notice any problems please open an issue.'
+      );
+
+      adapters.push(
+        new PnpmAdapter({
+          cwd: root,
+          managerOptions: config.npmOptions,
+          buildManagerOptions: config.buildManagerOptions,
+        })
+      );
+    } else if (hasNpm) {
+      adapters.push(
+        new NpmAdapter({
+          cwd: root,
+          managerOptions: config.npmOptions,
+          useYarnCommand: config.useYarn,
+          buildManagerOptions: config.buildManagerOptions,
         })
       );
-    } else if (hasNpm || hasBower) {
-      adapters.push(new NpmAdapter({ cwd: root, managerOptions: config.npmOptions, useYarnCommand: config.useYarn, buildManagerOptions: config.buildManagerOptions }));
-      adapters.push(new BowerAdapter({ cwd: root, managerOptions: config.bowerOptions }));
     }
 
     return adapters;

package/lib/utils/find-ember-path.js

@@ -1,15 +1,14 @@
 'use strict';
 
 const path = require('path');
-const RSVP = require('rsvp');
-const resolve = RSVP.denodeify(require('resolve'));
+const utils = require('util');
+const resolve = utils.promisify(require('resolve'));
 
-module.exports = function(root) {
+module.exports = async function (root) {
   /* Find ember-cli's entry point module relative to
      the current projects root */
-  return resolve('ember-cli', { basedir: root })
-    .then((emberPath) => {
-      // Return the path to the ember command script
-      return path.join(emberPath, '..', '..', '..', 'bin', 'ember');
-    });
+  let emberPath = await resolve('ember-cli', { basedir: root });
+
+  // Return the path to the ember command script
+  return path.join(emberPath, '..', '..', '..', 'bin', 'ember');
 };

package/lib/utils/result-summary.js

@@ -35,7 +35,6 @@ module.exports = CoreObject.extend({
         task.ui.writeLine(`with env: ${JSON.stringify(scenario.envState, null, 2)}`);
       }
       task._printDependencyTable(scenario.dependencyState);
-      task._deprecateBowerSupport(scenario.dependencyState);
     });
 
     task.ui.writeLine('');
@@ -48,12 +47,19 @@ module.exports = CoreObject.extend({
     task.ui.writeLine('');
   },
   _printDependencyTable(dependencyStatus) {
-    if (!dependencyStatus.length) { return; }
+    if (!dependencyStatus.length) {
+      return;
+    }
     let task = this;
     let colorForDepFn;
     let tableRow;
     let table = new Table({
-      head: [chalk.gray('Dependency'), chalk.gray('Expected'), chalk.gray('Used'), chalk.gray('Type')],
+      head: [
+        chalk.gray('Dependency'),
+        chalk.gray('Expected'),
+        chalk.gray('Used'),
+        chalk.gray('Type'),
+      ],
       colWidths: [20, 20, 30, 10],
     });
     dependencyStatus.forEach((dep) => {
@@ -62,7 +68,12 @@ module.exports = CoreObject.extend({
       } else {
         colorForDepFn = chalk.yellow;
       }
-      tableRow = [dep.name, dep.versionExpected || 'Not Installed', dep.versionSeen || 'Not Installed', dep.packageManager].map((column) => {
+      tableRow = [
+        dep.name,
+        dep.versionExpected || 'Not Installed',
+        dep.versionSeen || 'Not Installed',
+        dep.packageManager,
+      ].map((column) => {
         return colorForDepFn(column);
       });
       table.push(tableRow);
@@ -70,15 +81,6 @@ module.exports = CoreObject.extend({
     task.ui.writeLine(table);
     task.ui.writeLine('');
   },
-  _deprecateBowerSupport(dependencyStatus) {
-    if (!dependencyStatus.length) { return; }
-    let anyBower = dependencyStatus.some(function(element) {
-      return element.packageManager === 'bower';
-    });
-    if (anyBower) {
-      this.ui.writeLine(chalk.yellow('DEPRECATION: The next major version of `ember-try` (v2.0) will drop support for installing dependencies with `bower`.'));
-    }
-  },
   _printResultsSummary(countFailed, countPassed, allowedFailCount, total) {
     let task = this;
     if (countFailed) {

package/lib/utils/run-command.js

@@ -1,31 +1,26 @@
 'use strict';
 
-const RSVP = require('rsvp');
-const extend = require('extend');
 const findEmberPath = require('./find-ember-path');
 const run = require('./run');
 
-module.exports = function(root, commandArgs, opts) {
-  let options = extend({ cwd: root }, opts);
-  let runPromise;
-  let command = commandArgs[0];
-  let actualArgs = commandArgs.slice(1);
+module.exports = async function (root, commandArgs, opts) {
+  let options = Object.assign({ cwd: root }, opts);
+  let [command, ...actualArgs] = commandArgs;
 
-  if (command === 'ember') {
-    runPromise = findEmberPath(root).then((emberPath) => {
-      return run('node', [].concat(`"${emberPath}"`, actualArgs), options);
-    });
-  } else {
-    runPromise = run(command, actualArgs, options);
-  }
+  try {
+    if (command === 'ember') {
+      let emberPath = await findEmberPath(root);
+      await run('node', [`"${emberPath}"`, ...actualArgs], options);
+    } else {
+      await run(command, actualArgs, options);
+    }
 
-  return runPromise.then(() => {
-    return RSVP.resolve(true);
-  }).catch((errorCode) => {
+    return true;
+  } catch (errorCode) {
     if (errorCode !== 1) {
-      return RSVP.reject(`The command ${commandArgs.join(' ')} exited ${errorCode}`);
+      throw new Error(`The command ${commandArgs.join(' ')} exited ${errorCode}`);
     } else {
-      return RSVP.resolve(false);
+      return false;
     }
-  });
+  }
 };

package/lib/utils/run.js

@@ -3,22 +3,22 @@
 const execa = require('execa');
 const debug = require('debug')('ember-try:utils:run');
 
-module.exports = function run(command, args, opts) {
-  opts = opts || {};
-
-  opts.stdio = opts.stdio || 'inherit';
+module.exports = async function run(command, args, _options) {
+  let options = Object.assign({ stdio: 'inherit', shell: true }, _options);
 
   if (process.env.SHUT_UP) {
-    opts.stdio = 'ignore';
+    options.stdio = 'ignore';
   }
 
   let cmdArgs = `${command} ${args.join(' ')}`;
-  let child = execa.shell(cmdArgs, opts);
-
-  debug('spawned with execa.shell', cmdArgs, opts);
+  try {
+    debug('spawning execa.shell', cmdArgs, options);
 
-  return child.catch((error) => {
+    return await execa(cmdArgs, options);
+  } catch (error) {
     debug('error', error);
-    return Promise.reject(error.code);
-  });
+
+    // TODO: should refactor this to throw an error (easier to track down stack traces)
+    throw error.exitCode;
+  }
 };

package/lib/utils/scenario-manager.js

@@ -1,44 +1,33 @@
 'use strict';
 
 const CoreObject = require('core-object');
-const RSVP = require('rsvp');
-const mapSeries = require('promise-map-series');
 
 module.exports = CoreObject.extend({
-  init() {
-    this._super.apply(this, arguments);
-    this._checkDependencyManagerAdapters();
-  },
+  async setup() {
+    let { ui } = this;
 
-  _checkDependencyManagerAdapters() {
-    if (!this.dependencyManagerAdapters || this.dependencyManagerAdapters.length === 0) {
-      throw new Error('No dependency manager adapter');
+    for (let depManager of this.dependencyManagerAdapters) {
+      await depManager.setup({ ui });
     }
   },
 
-  setup() {
-    let ui = this.ui;
-
-    return mapSeries(this.dependencyManagerAdapters, (depManager) => {
-      return depManager.setup({ ui });
-    });
-  },
-
-  changeTo(scenario) {
-    return mapSeries(this.dependencyManagerAdapters, (depManager) => {
+  async changeTo(scenario) {
+    let results = [];
+    for (let depManager of this.dependencyManagerAdapters) {
       if (scenario[depManager.configKey]) {
-        return depManager.changeToDependencySet(scenario[depManager.configKey]);
+        let depManagerResults = await depManager.changeToDependencySet(
+          scenario[depManager.configKey]
+        );
+        results.push(...depManagerResults);
       }
-      return RSVP.resolve([]);
-    }).then((results) => {
-      return RSVP.resolve([].concat.apply([], results));
-    });
+    }
+
+    return results;
   },
 
-  cleanup() {
-    return mapSeries(this.dependencyManagerAdapters, (depManager) => {
-      return depManager.cleanup();
-    });
+  async cleanup() {
+    for (let depManager of this.dependencyManagerAdapters) {
+      await depManager.cleanup();
+    }
   },
 });
-