ember-try 3.0.0 → 5.0.0

package/lib/dependency-manager-adapters/workspace.js

@@ -1,24 +1,26 @@
 'use strict';
 
-const CoreObject = require('core-object');
 const fs = require('fs-extra');
 const path = require('path');
 const debug = require('debug')('ember-try:dependency-manager-adapter:workspaces');
 const walkSync = require('walk-sync');
+const { PACKAGE_JSON } = require('../utils/package-managers');
+const YarnAdapter = require('./yarn');
 
-const NpmAdapter = require('./npm');
+module.exports = class {
+  constructor(options) {
+    this.buildManagerOptions = options.buildManagerOptions;
+    this.cwd = options.cwd;
+    this.managerOptions = options.managerOptions;
+    this.run = options.run || require('../utils/run');
 
-module.exports = CoreObject.extend({
-  init() {
-    this._super.apply(this, arguments);
-    this.run = this.run || require('../utils/run');
-
-    if (!this.useYarnCommand) {
+    if (options.packageManager !== 'yarn') {
       throw new Error(
-        'workspaces are currently only supported by Yarn, you must set `useYarn` to true'
+        'workspaces are currently only supported by Yarn, you must set `packageManager` to `yarn`',
       );
     }
-    let packageJSON = JSON.parse(fs.readFileSync(this.packageJSON));
+
+    let packageJSON = JSON.parse(fs.readFileSync(PACKAGE_JSON));
     let workspaceGlobs;
 
     if (Array.isArray(packageJSON.workspaces)) {
@@ -31,7 +33,7 @@ module.exports = CoreObject.extend({
 
     if (!workspaceGlobs || !workspaceGlobs.length) {
       throw new Error(
-        'you must define the `workspaces` property in package.json with at least one workspace to use workspaces with ember-try'
+        'you must define the `workspaces` property in package.json with at least one workspace to use workspaces with ember-try',
       );
     }
 
@@ -43,25 +45,18 @@ module.exports = CoreObject.extend({
     });
 
     this._packageAdapters = workspacePaths.map((workspacePath) => {
-      return new NpmAdapter({
+      return new YarnAdapter({
         cwd: workspacePath,
         run: this.run,
         managerOptions: this.managerOptions,
-        useYarnCommand: true,
         buildManagerOptions: this.buildManagerOptions,
       });
     });
-  },
-
-  packageJSON: 'package.json',
-
-  setup(options) {
-    if (!options) {
-      options = {};
-    }
+  }
 
-    return Promise.all(this._packageAdapters.map((adapter) => adapter.setup(options)));
-  },
+  setup() {
+    return Promise.all(this._packageAdapters.map((adapter) => adapter.setup()));
+  }
 
   async changeToDependencySet(depSet) {
     // TODO: What should this do for tables? Nesting? Needs different output
@@ -83,11 +78,11 @@ module.exports = CoreObject.extend({
     debug('Switched to dependencies: \n', currentDeps);
 
     return currentDeps;
-  },
+  }
 
   cleanup() {
     return Promise.all(this._packageAdapters.map((adapter) => adapter.cleanup()));
-  },
+  }
 
   _install(depSet) {
     let mgrOptions = this.managerOptions || [];
@@ -113,9 +108,9 @@ module.exports = CoreObject.extend({
     debug('Run yarn install with options %s', mgrOptions);
 
     return this.run('yarn', ['install', ...mgrOptions], { cwd: this.cwd });
-  },
+  }
 
   _findCurrentVersionOf(dep) {
     return this._packageAdapters[0]._findCurrentVersionOf(dep);
-  },
-});
+  }
+};

package/lib/dependency-manager-adapters/yarn.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { LOCKFILE } = require('../utils/package-managers');
+const { BaseAdapter } = require('./base');
+
+module.exports = class YarnAdapter extends BaseAdapter {
+  defaultInstallOptions = ['--no-lockfile', '--ignore-engines'];
+  lockfile = LOCKFILE.yarn;
+  name = 'yarn';
+  overridesKey = 'resolutions';
+};

package/lib/tasks/reset.js

@@ -1,21 +1,26 @@
 'use strict';
 
-const CoreObject = require('core-object');
 const debug = require('debug')('ember-try:commands:reset');
 const ScenarioManager = require('../utils/scenario-manager');
 const DependencyManagerAdapterFactory = require('./../utils/dependency-manager-adapter-factory');
 
-module.exports = CoreObject.extend({
+module.exports = class ResetTask {
+  constructor(options) {
+    this.config = options.config;
+    this.cwd = options.cwd;
+  }
+
   run() {
-    let dependencyAdapters =
-      this.dependencyManagerAdapters ||
-      DependencyManagerAdapterFactory.generateFromConfig(this.config, this.project.root);
+    let dependencyAdapters = DependencyManagerAdapterFactory.generateFromConfig(
+      this.config,
+      this.cwd,
+    );
     debug(
       'DependencyManagerAdapters: %s',
       dependencyAdapters.map((item) => {
         return item.configKey;
-      })
+      }),
     );
     return new ScenarioManager({ dependencyManagerAdapters: dependencyAdapters }).cleanup();
-  },
-});
+  }
+};

package/lib/tasks/try-each.js

@@ -1,11 +1,18 @@
 'use strict';
 
-const CoreObject = require('core-object');
-const chalk = require('chalk');
 const debug = require('debug')('ember-try:task:try-each');
-const runCommand = require('./../utils/run-command');
+const { error, info, log } = require('../utils/console');
+const runCommand = require('../utils/run-command');
+
+module.exports = class TryEachTask {
+  constructor(options) {
+    this.commandArgs = options.commandArgs;
+    this.commandOptions = options.commandOptions;
+    this.config = options.config;
+    this.cwd = options.cwd;
+    this.dependencyManagerAdapters = options.dependencyManagerAdapters;
+  }
 
-module.exports = CoreObject.extend({
   async run(scenarios, options) {
     // Required lazily to improve startup speed.
     let ScenarioManager = require('./../utils/scenario-manager');
@@ -14,22 +21,21 @@ module.exports = CoreObject.extend({
 
     let dependencyManagerAdapters =
       this.dependencyManagerAdapters ||
-      DependencyManagerAdapterFactory.generateFromConfig(this.config, this.project.root);
+      DependencyManagerAdapterFactory.generateFromConfig(this.config, this.cwd);
     debug(
       'DependencyManagerAdapters: %s',
       dependencyManagerAdapters.map((item) => {
         return item.configKey;
-      })
+      }),
     );
     this.ScenarioManager = new ScenarioManager({
-      ui: this.ui,
       dependencyManagerAdapters,
     });
 
     this._canceling = false;
     this._on('SIGINT', () => {
       this._canceling = true;
-      this.ui.writeLine('\nGracefully shutting down from SIGINT (Ctrl-C)');
+      log('\nGracefully shutting down from SIGINT (Ctrl-C)');
       return this.ScenarioManager.cleanup();
     });
 
@@ -49,16 +55,16 @@ module.exports = CoreObject.extend({
 
       return this._exitAsAppropriate(results);
     } catch (err) {
-      this.ui.writeLine(chalk.red('Error!'));
+      error('Error!');
 
       if (err) {
-        this.ui.writeLine(chalk.red(err));
-        this.ui.writeLine(chalk.red(err.stack));
+        error(err);
+        error(err.stack);
       }
 
       return 1; // Signifies exit code
     }
-  },
+  }
 
   async _runCommandForThisScenario(scenario) {
     if (this._canceling) {
@@ -98,18 +104,18 @@ module.exports = CoreObject.extend({
     this._writeFooter(`Result: ${result}`);
 
     return runResults;
-  },
+  }
 
   _writeHeader(text) {
     let count = 75 - text.length;
     let separator = new Array(count + 1).join('=');
-    this.ui.writeLine(chalk.blue(`\n=== ${text} ${separator}\n`));
-  },
+    info(`\n=== ${text} ${separator}\n`);
+  }
 
   _writeFooter(text) {
-    this.ui.writeLine(chalk.blue(`\n${text}`));
-    this.ui.writeLine(chalk.blue('---\n'));
-  },
+    info(`\n${text}`);
+    info('---\n');
+  }
 
   _determineCommandFor(scenario) {
     if (this.commandArgs && this.commandArgs.length) {
@@ -125,11 +131,11 @@ module.exports = CoreObject.extend({
     }
 
     return this._defaultCommandArgs();
-  },
+  }
 
   _runCommand(options) {
-    return runCommand(this.project.root, options.commandArgs, options.commandOptions);
-  },
+    return runCommand(this.cwd, options.commandArgs, options.commandOptions);
+  }
 
   _commandOptions(env) {
     let options = this.commandOptions || {};
@@ -137,15 +143,15 @@ module.exports = CoreObject.extend({
       options.env = Object.assign({}, process.env, env);
     }
     return options;
-  },
+  }
 
   _defaultCommandArgs() {
     return ['ember', 'test'];
-  },
+  }
 
   _printResults(results) {
-    new this.ResultSummary({ ui: this.ui, results }).print();
-  },
+    new this.ResultSummary({ results }).print();
+  }
 
   _exitAsAppropriate(results) {
     let outcomes = results.map((result) => {
@@ -153,7 +159,7 @@ module.exports = CoreObject.extend({
     });
 
     return this._exitBasedOnCondition(outcomes.indexOf(false) > -1);
-  },
+  }
 
   async _optionallyCleanup(options) {
     debug('Cleanup');
@@ -166,20 +172,20 @@ module.exports = CoreObject.extend({
       debug('Cleanup ScenarioManager');
       return await this.ScenarioManager.cleanup();
     }
-  },
+  }
 
   _exitBasedOnCondition(condition) {
     let exitCode = condition ? 1 : 0;
     debug('Exit %s', exitCode);
     return exitCode;
-  },
+  }
 
   _exit(code) {
     debug('Exit %s', code);
     process.exit(code);
-  },
+  }
 
   _on(signal, fn) {
     process.on(signal, fn);
-  },
-});
+  }
+};

package/lib/utils/backup.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const debug = require('debug')('ember-try:backup');
+const { copy, existsSync } = require('fs-extra');
+const { createHash } = require('node:crypto');
+const { join } = require('node:path');
+const { promisify } = require('node:util');
+const remove = promisify(require('rimraf'));
+const tempDir = require('temp-dir');
+
+module.exports = class Backup {
+  constructor({ cwd }) {
+    this.cwd = cwd;
+    this.dir = join(tempDir, 'ember-try', createHash('sha256').update(cwd).digest('hex'));
+
+    debug(`Created backup directory ${this.dir}`);
+  }
+
+  /**
+   * Adds a file to the backup directory.
+   *
+   * @param {String} filename Filename relative to the current working directory.
+   * @returns {Promise<void>}
+   */
+  addFile(filename) {
+    let originalFile = join(this.cwd, filename);
+
+    if (existsSync(originalFile)) {
+      debug(`Adding ${originalFile} to backup directory`);
+
+      return copy(originalFile, this.pathForFile(filename));
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Adds multiple files to the backup directory.
+   *
+   * @param {Array<String>} filenames Filenames relative to the current working directory.
+   * @returns {Promise<void>}
+   */
+  addFiles(filenames) {
+    return Promise.all(filenames.map((filename) => this.addFile(filename)));
+  }
+
+  /**
+   * Cleans up the backup directory.
+   *
+   * @returns {Promise<void>}
+   */
+  cleanUp() {
+    debug(`Cleaning up backup directory ${this.dir}`);
+
+    return remove(this.dir);
+  }
+
+  /**
+   * Returns the absolute path for a file in the backup directory.
+   *
+   * @param {String} filename Filename relative to the current working directory.
+   * @returns {String}
+   */
+  pathForFile(filename) {
+    return join(this.dir, filename);
+  }
+
+  /**
+   * Restores a file from the backup directory.
+   *
+   * @param {String} filename Filename relative to the current working directory.
+   * @returns {Promise<void>}
+   */
+  restoreFile(filename) {
+    let backupFile = this.pathForFile(filename);
+
+    if (existsSync(backupFile)) {
+      debug(`Restoring ${backupFile} from backup directory`);
+
+      return copy(backupFile, join(this.cwd, filename));
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Restores multiple files from the backup directory.
+   *
+   * @param {Array<String>} filenames Filenames relative to the current working directory.
+   * @returns {Promise<void>}
+   */
+  restoreFiles(filenames) {
+    return Promise.all(filenames.map((filename) => this.restoreFile(filename)));
+  }
+};

package/lib/utils/config.js

@@ -2,15 +2,15 @@
 
 const path = require('path');
 const fs = require('fs');
-const findByName = require('./find-by-name');
+const { prefix, warn } = require('./console');
 const debug = require('debug')('ember-try:utils:config');
 
-function getConfigPath(project) {
+function getConfigPath(cwd) {
+  let packageFile = readPackageFile(cwd);
   let possibleConfigPath;
-  if (project.pkg && project.pkg['ember-addon'] && project.pkg['ember-addon']['configPath']) {
-    let configDir = project.pkg['ember-addon']['configPath'];
 
-    possibleConfigPath = path.join(configDir, 'ember-try.js');
+  if (packageFile['ember-addon']?.['configPath']) {
+    possibleConfigPath = path.join(packageFile['ember-addon']['configPath'], 'ember-try.js');
   }
 
   if (fs.existsSync(possibleConfigPath)) {
@@ -25,14 +25,14 @@ function getConfigPath(project) {
 }
 
 async function getBaseConfig(options) {
-  let relativeConfigPath = options.configPath || getConfigPath(options.project);
-  let configPath = path.join(options.project.root, relativeConfigPath);
+  let relativeConfigPath = options.configPath || getConfigPath(options.cwd);
+  let configPath = path.join(options.cwd, relativeConfigPath);
   let data;
 
   if (fs.existsSync(configPath)) {
     let configData = await require(configPath);
 
-    data = typeof configData === 'function' ? await configData(options.project) : configData;
+    data = typeof configData === 'function' ? await configData() : configData;
   } else {
     debug('Config file does not exist %s', configPath);
   }
@@ -42,19 +42,18 @@ async function getBaseConfig(options) {
   }
 
   let versionCompatibility =
-    options.versionCompatibility || versionCompatibilityFromPackageJSON(options.project.root);
+    options.versionCompatibility || versionCompatibilityFromPackageJSON(options.cwd);
   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'
+      'No ember-try configuration found. Please see the README for configuration options',
     );
   }
 }
@@ -62,6 +61,22 @@ async function getBaseConfig(options) {
 async function config(options) {
   const configData = await getBaseConfig(options);
 
+  for (const packageManager of [
+    ['pnpm', 'usePnpm'],
+    ['yarn', 'useYarn'],
+  ]) {
+    const [name, oldOption] = packageManager;
+
+    if (typeof configData[oldOption] === 'boolean') {
+      warn(
+        `${prefix('ember-try DEPRECATION')} The \`${oldOption}\` config option is deprecated. Please use \`packageManager: '${name}'\` instead.`,
+      );
+
+      delete configData[oldOption];
+      configData.packageManager = name;
+    }
+  }
+
   return configData;
 }
 
@@ -74,12 +89,12 @@ function mergeAutoConfigAndConfigFileData(autoConfig, configData) {
   let conf = Object.assign({}, autoConfig, configData);
 
   let overriddenScenarios = autoConfig.scenarios.map((scenario) => {
-    let overriddenScenario = findByName(configData.scenarios, scenario.name);
+    let overriddenScenario = configData.scenarios.find((s) => s.name === scenario.name);
     return Object.assign({}, scenario, overriddenScenario);
   });
 
   let additionalScenarios = configData.scenarios.filter((scenario) => {
-    return !findByName(autoConfig.scenarios, scenario.name);
+    return !autoConfig.scenarios.find((s) => s.name === scenario.name);
   });
 
   conf.scenarios = [...overriddenScenarios, ...additionalScenarios];
@@ -87,11 +102,18 @@ function mergeAutoConfigAndConfigFileData(autoConfig, configData) {
   return conf;
 }
 
-function versionCompatibilityFromPackageJSON(root) {
-  let packageJSONFile = path.join(root, 'package.json');
-  if (fs.existsSync(packageJSONFile)) {
-    let packageJSON = JSON.parse(fs.readFileSync(packageJSONFile));
+function versionCompatibilityFromPackageJSON(cwd) {
+  let packageFile = readPackageFile(cwd);
 
-    return packageJSON['ember-addon'] ? packageJSON['ember-addon'].versionCompatibility : null;
+  return packageFile['ember-addon']?.versionCompatibility ?? null;
+}
+
+function readPackageFile(cwd) {
+  let packageFile = path.join(cwd, 'package.json');
+
+  if (fs.existsSync(packageFile)) {
+    return JSON.parse(fs.readFileSync(packageFile));
+  } else {
+    return {};
   }
 }

package/lib/utils/console.js

@@ -0,0 +1,51 @@
+const chalk = require('chalk');
+
+let logFunction = originalLogFunction;
+
+function error(message) {
+  logFunction(message, console.error, chalk.red);
+}
+
+function info(message) {
+  logFunction(message, console.info, chalk.blue);
+}
+
+function log(message) {
+  logFunction(message, console.log);
+}
+
+function prefix(string) {
+  return chalk.inverse(` ${string} `);
+}
+
+function success(message) {
+  logFunction(message, console.log, chalk.green);
+}
+
+function warn(message) {
+  logFunction(message, console.warn, chalk.yellow);
+}
+
+function originalLogFunction(message, consoleLogFunction, chalkColorFunction) {
+  consoleLogFunction(chalkColorFunction ? chalkColorFunction(message) : message);
+}
+
+function mockLog(mockedLogFunction) {
+  logFunction = mockedLogFunction;
+}
+
+function restoreLog() {
+  logFunction = originalLogFunction;
+}
+
+module.exports = {
+  error,
+  info,
+  log,
+  prefix,
+  success,
+  warn,
+
+  _mockLog: mockLog,
+  _restoreLog: restoreLog,
+};

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

@@ -3,11 +3,11 @@
 const NpmAdapter = require('../dependency-manager-adapters/npm');
 const PnpmAdapter = require('../dependency-manager-adapters/pnpm');
 const WorkspaceAdapter = require('../dependency-manager-adapters/workspace');
+const YarnAdapter = require('../dependency-manager-adapters/yarn');
 
 module.exports = {
-  generateFromConfig(config, root) {
+  generateFromConfig(config, cwd) {
     let hasNpm = false;
-    let hasBower = false;
     let adapters = [];
     if (!config || !config.scenarios) {
       return [];
@@ -17,40 +17,40 @@ module.exports = {
       if (scenario.npm) {
         hasNpm = true;
       }
-      if (scenario.bower || scenario.dependencies || scenario.devDependencies) {
-        hasBower = true;
-      }
     });
 
-    if (hasBower) {
-      throw new Error('[ember-try] bower configuration is no longer supported');
-    }
-
     if (config.useWorkspaces) {
       adapters.push(
         new WorkspaceAdapter({
-          cwd: root,
+          cwd,
           managerOptions: config.npmOptions,
-          useYarnCommand: config.useYarn,
+          packageManager: config.packageManager,
           buildManagerOptions: config.buildManagerOptions,
-        })
+        }),
       );
-    } else if (config.usePnpm) {
+    } else if (config.packageManager === 'pnpm') {
       adapters.push(
         new PnpmAdapter({
-          cwd: root,
+          cwd,
+          managerOptions: config.npmOptions,
+          buildManagerOptions: config.buildManagerOptions,
+        }),
+      );
+    } else if (config.packageManager === 'yarn') {
+      adapters.push(
+        new YarnAdapter({
+          cwd,
           managerOptions: config.npmOptions,
           buildManagerOptions: config.buildManagerOptions,
-        })
+        }),
       );
     } else if (hasNpm) {
       adapters.push(
         new NpmAdapter({
-          cwd: root,
+          cwd,
           managerOptions: config.npmOptions,
-          useYarnCommand: config.useYarn,
           buildManagerOptions: config.buildManagerOptions,
-        })
+        }),
       );
     }
 

package/lib/utils/package-managers.js

@@ -0,0 +1,9 @@
+const LOCKFILE = {
+  npm: 'package-lock.json',
+  pnpm: 'pnpm-lock.yaml',
+  yarn: 'yarn.lock',
+};
+
+const PACKAGE_JSON = 'package.json';
+
+module.exports = { LOCKFILE, PACKAGE_JSON };