ember-try 3.0.0 → 4.0.0

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

@@ -1,295 +1,11 @@
 'use strict';
 
-const CoreObject = require('core-object');
-const fs = require('fs-extra');
-const util = require('util');
-const copy = util.promisify(fs.copy);
-const path = require('path');
-const debug = require('debug')('ember-try:dependency-manager-adapter:npm');
-const rimraf = util.promisify(require('rimraf'));
-const chalk = require('chalk');
-const semver = require('semver');
-
-module.exports = CoreObject.extend({
-  init() {
-    this._super.apply(this, arguments);
-    this.run = this.run || require('../utils/run');
-  },
-  useYarnCommand: false,
-  yarnLock: 'yarn.lock',
-  yarnLockBackupFileName: 'yarn.lock.ember-try',
-  configKey: 'npm',
-  packageJSON: 'package.json',
-  packageJSONBackupFileName: 'package.json.ember-try',
-  nodeModules: 'node_modules',
-  nodeModulesBackupLocation: '.node_modules.ember-try',
-  npmShrinkWrap: 'npm-shrinkwrap.json',
-  npmShrinkWrapBackupFileName: 'npm-shrinkwrap.json.ember-try',
-  packageLock: 'package-lock.json',
-  packageLockBackupFileName: 'package-lock.json.ember-try',
-
-  async setup(options) {
-    if (!options) {
-      options = {};
-    }
-
-    this._runYarnCheck(options.ui);
-
-    return await this._backupOriginalDependencies();
-  },
-
-  async changeToDependencySet(depSet) {
-    this.applyDependencySet(depSet);
-
-    await this._install(depSet);
-
-    let deps = Object.assign({}, depSet.dependencies, depSet.devDependencies);
-    let currentDeps = Object.keys(deps).map((dep) => {
-      return {
-        name: dep,
-        versionExpected: deps[dep],
-        versionSeen: this._findCurrentVersionOf(dep),
-        packageManager: this.useYarnCommand ? 'yarn' : 'npm',
-      };
-    });
-
-    debug('Switched to dependencies: \n', currentDeps);
-
-    return currentDeps;
-  },
-
-  async cleanup() {
-    try {
-      await this._restoreOriginalDependencies();
-
-      debug('Remove backup package.json and node_modules');
-
-      let cleanupTasks = [
-        rimraf(path.join(this.cwd, this.packageJSONBackupFileName)),
-        rimraf(path.join(this.cwd, this.nodeModulesBackupLocation)),
-      ];
-
-      if (fs.existsSync(path.join(this.cwd, this.yarnLockBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.yarnLockBackupFileName)));
-      }
-
-      if (fs.existsSync(path.join(this.cwd, this.npmShrinkWrapBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.npmShrinkWrapBackupFileName)));
-      }
-
-      if (fs.existsSync(path.join(this.cwd, this.packageLockBackupFileName))) {
-        cleanupTasks.push(rimraf(path.join(this.cwd, this.packageLockBackupFileName)));
-      }
-
-      return await Promise.all(cleanupTasks);
-    } catch (e) {
-      console.log('Error cleaning up npm scenario:', e); // eslint-disable-line no-console
-    }
-  },
-
-  _runYarnCheck(ui) {
-    if (!this.useYarnCommand) {
-      try {
-        if (fs.statSync(path.join(this.cwd, this.yarnLock)).isFile()) {
-          ui.writeLine(
-            chalk.yellow(
-              'Detected a yarn.lock file. Add `useYarn: true` to your `config/ember-try.js` configuration file if you want to use Yarn to install npm dependencies.'
-            )
-          );
-        }
-      } catch (e) {
-        // If no yarn.lock is found, no need to warn.
-      }
-    }
-  },
-
-  _findCurrentVersionOf(packageName) {
-    let filename = path.join(this.cwd, this.nodeModules, packageName, this.packageJSON);
-    if (fs.existsSync(filename)) {
-      return JSON.parse(fs.readFileSync(filename)).version;
-    } else {
-      return null;
-    }
-  },
-
-  async _install(depSet) {
-    let mgrOptions = this.managerOptions || [];
-    let cmd = this.useYarnCommand ? 'yarn' : 'npm';
-
-    // buildManagerOptions overrides all default
-    if (typeof this.buildManagerOptions === 'function') {
-      mgrOptions = this.buildManagerOptions(depSet);
-
-      if (!Array.isArray(mgrOptions)) {
-        throw new Error('buildManagerOptions must return an array of options');
-      }
-    } else {
-      if (this.useYarnCommand) {
-        if (mgrOptions.indexOf('--no-lockfile') === -1) {
-          mgrOptions = mgrOptions.concat(['--no-lockfile']);
-        }
-        // npm warns on incompatible engines
-        // yarn errors, not a good experience
-        if (mgrOptions.indexOf('--ignore-engines') === -1) {
-          mgrOptions = mgrOptions.concat(['--ignore-engines']);
-        }
-      } else if (mgrOptions.indexOf('--no-shrinkwrap') === -1) {
-        mgrOptions = mgrOptions.concat(['--no-shrinkwrap']);
-      }
-    }
-
-    debug('Run npm/yarn install with options %s', mgrOptions);
-
-    await this.run(cmd, [].concat(['install'], mgrOptions), { cwd: this.cwd });
-
-    if (!this.useYarnCommand) {
-      let res = await this.run('npm', ['--version'], { cwd: this.cwd, stdio: 'pipe' });
-      let version = res.stdout;
-      if (version.match(/^4./)) {
-        debug('Running npm prune because version is %s', version);
-        return await this.run(this.configKey, ['prune'], { cwd: this.cwd });
-      }
-
-      debug('Not running npm prune because version is %s', version);
-    }
-  },
-
-  applyDependencySet(depSet) {
-    debug('Changing to dependency set: %s', JSON.stringify(depSet));
-
-    if (!depSet) {
-      return;
-    }
-
-    let backupPackageJSON = path.join(this.cwd, this.packageJSONBackupFileName);
-    let packageJSONFile = path.join(this.cwd, this.packageJSON);
-    let packageJSON = JSON.parse(fs.readFileSync(backupPackageJSON));
-    let newPackageJSON = this._packageJSONForDependencySet(packageJSON, depSet);
-
-    debug('Write package.json with: \n', JSON.stringify(newPackageJSON));
-
-    fs.writeFileSync(packageJSONFile, JSON.stringify(newPackageJSON, null, 2));
-  },
-
-  _packageJSONForDependencySet(packageJSON, depSet) {
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'dependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'devDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'peerDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'ember');
-
-    if (this.useYarnCommand) {
-      this._overridePackageJSONDependencies(packageJSON, depSet, 'resolutions');
-    } else {
-      this._overridePackageJSONDependencies(packageJSON, depSet, 'overrides');
-    }
-
-    return packageJSON;
-  },
-
-  _overridePackageJSONDependencies(packageJSON, depSet, kindOfDependency) {
-    if (!depSet[kindOfDependency]) {
-      return;
-    }
-
-    let packageNames = Object.keys(depSet[kindOfDependency]);
-
-    packageNames.forEach((packageName) => {
-      if (!packageJSON[kindOfDependency]) {
-        packageJSON[kindOfDependency] = {};
-      }
-
-      let version = depSet[kindOfDependency][packageName];
-      if (version === null) {
-        delete packageJSON[kindOfDependency][packageName];
-      } else {
-        packageJSON[kindOfDependency][packageName] = version;
-
-        // in npm we need to always add an override if the version is a pre-release
-        if (
-          !this.useYarnCommand &&
-          (semver.prerelease(version) || /^https*:\/\/.*\.tg*z/.test(version))
-        ) {
-          if (!packageJSON.overrides) {
-            packageJSON.overrides = {};
-          }
-
-          packageJSON.overrides[packageName] = `$${packageName}`;
-        }
-      }
-    });
-  },
-
-  _restoreOriginalDependencies() {
-    debug('Restoring original package.json and node_modules');
-
-    let restoreTasks = [
-      copy(
-        path.join(this.cwd, this.packageJSONBackupFileName),
-        path.join(this.cwd, this.packageJSON)
-      ),
-    ];
-
-    let nodeModulesBackupLocation = path.join(this.cwd, this.nodeModulesBackupLocation);
-    if (fs.existsSync(nodeModulesBackupLocation)) {
-      restoreTasks.push(
-        copy(nodeModulesBackupLocation, path.join(this.cwd, this.nodeModules), { clobber: true })
-      );
-    }
-
-    let yarnLockBackupFileName = path.join(this.cwd, this.yarnLockBackupFileName);
-    if (fs.existsSync(yarnLockBackupFileName)) {
-      restoreTasks.push(copy(yarnLockBackupFileName, path.join(this.cwd, this.yarnLock)));
-    }
-
-    let npmShrinkWrapBackupFileName = path.join(this.cwd, this.npmShrinkWrapBackupFileName);
-    if (fs.existsSync(npmShrinkWrapBackupFileName)) {
-      restoreTasks.push(copy(npmShrinkWrapBackupFileName, path.join(this.cwd, this.npmShrinkWrap)));
-    }
-
-    let packageLockBackupFileName = path.join(this.cwd, this.packageLockBackupFileName);
-    if (fs.existsSync(packageLockBackupFileName)) {
-      restoreTasks.push(copy(packageLockBackupFileName, path.join(this.cwd, this.packageLock)));
-    }
-
-    return Promise.all(restoreTasks);
-  },
-
-  _backupOriginalDependencies() {
-    debug('Backing up package.json and node_modules');
-
-    let backupTasks = [
-      copy(
-        path.join(this.cwd, this.packageJSON),
-        path.join(this.cwd, this.packageJSONBackupFileName)
-      ),
-    ];
-
-    let nodeModulesPath = path.join(this.cwd, this.nodeModules);
-    if (fs.existsSync(nodeModulesPath)) {
-      backupTasks.push(
-        copy(nodeModulesPath, path.join(this.cwd, this.nodeModulesBackupLocation), {
-          clobber: true,
-        })
-      );
-    }
-
-    let yarnLockPath = path.join(this.cwd, this.yarnLock);
-    if (fs.existsSync(yarnLockPath)) {
-      backupTasks.push(copy(yarnLockPath, path.join(this.cwd, this.yarnLockBackupFileName)));
-    }
-
-    let npmShrinkWrapPath = path.join(this.cwd, this.npmShrinkWrap);
-    if (fs.existsSync(npmShrinkWrapPath)) {
-      backupTasks.push(
-        copy(npmShrinkWrapPath, path.join(this.cwd, this.npmShrinkWrapBackupFileName))
-      );
-    }
-
-    let packageLockPath = path.join(this.cwd, this.packageLock);
-    if (fs.existsSync(packageLockPath)) {
-      backupTasks.push(copy(packageLockPath, path.join(this.cwd, this.packageLockBackupFileName)));
-    }
-
-    return Promise.all(backupTasks);
-  },
-});
+const { LOCKFILE } = require('../utils/package-managers');
+const { BaseAdapter } = require('./base');
+
+module.exports = class NpmAdapter extends BaseAdapter {
+  defaultInstallOptions = ['--no-package-lock'];
+  lockfile = LOCKFILE.npm;
+  name = 'npm';
+  overridesKey = 'overrides';
+};

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

@@ -1,172 +1,64 @@
 '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:pnpm');
+const semver = require('semver');
+const { LOCKFILE } = require('../utils/package-managers');
+const { BaseAdapter } = require('./base');
 
-const PACKAGE_JSON = 'package.json';
-const PACKAGE_JSON_BACKUP = 'package.json.ember-try';
-const PNPM_LOCKFILE = 'pnpm-lock.yaml';
-
-// Note: the upstream convention is to append `.ember-try` _after_ the file
-// extension, however this breaks syntax highlighting, so I've chosen to
-// insert it right before the file extension.
-const PNPM_LOCKFILE_BACKUP = 'pnpm-lock.ember-try.yaml';
-
-module.exports = CoreObject.extend({
-  // This still needs to be `npm` because we're still reading the dependencies
-  // from the `npm` key of the ember-try config.
-  configKey: 'npm',
-
-  init() {
-    this._super.apply(this, arguments);
-    this.run = this.run || require('../utils/run');
-  },
+module.exports = class PnpmAdapter extends BaseAdapter {
+  defaultInstallOptions = ['--no-lockfile', '--ignore-scripts'];
+  lockfile = LOCKFILE.pnpm;
+  name = 'pnpm';
+  overridesKey = 'pnpm.overrides';
 
   async setup() {
-    let pkg = path.join(this.cwd, PACKAGE_JSON);
-    let pkgBackup = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-    debug(`Copying ${PACKAGE_JSON}`);
-    await fs.copy(pkg, pkgBackup);
-
-    let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-    let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-    if (fs.existsSync(lockFile)) {
-      debug(`Copying ${PNPM_LOCKFILE}`);
-      await fs.copy(lockFile, lockFileBackup);
+    await this._throwOnResolutionMode();
+    await super.setup();
+  }
+
+  /**
+   * pnpm versions 8.0.0 through 8.6.* have the `resolution-mode` setting inverted to
+   * `lowest-direct`, which breaks ember-try. This method throws a helpful error in the following
+   * case: pnpm version is within dangerous range and `pnpm config get resolution-mode` reports an
+   * empty value.
+   *
+   * @returns Promise<void>
+   */
+  async _throwOnResolutionMode() {
+    let version = await this._getPnpmVersion();
+    let resolutionMode = await this._getResolutionMode();
+
+    if (this._isResolutionModeWrong(version, resolutionMode)) {
+      throw new Error(
+        'You are using an old version of pnpm that uses wrong resolution mode that violates ember-try expectations. Please either upgrade pnpm or set `resolution-mode` to `highest` in `.npmrc`.',
+      );
     }
-  },
-
-  async changeToDependencySet(depSet) {
-    await this.applyDependencySet(depSet);
+  }
 
-    await this._install(depSet);
+  async _getPnpmVersion() {
+    let result = await this.run('pnpm', ['--version'], { cwd: this.cwd, stdio: 'pipe' });
+    return result.stdout.split('\n')[0];
+  }
 
-    let deps = Object.assign({}, depSet.dependencies, depSet.devDependencies);
-    let currentDeps = Object.keys(deps).map((dep) => {
-      return {
-        name: dep,
-        versionExpected: deps[dep],
-        versionSeen: this._findCurrentVersionOf(dep),
-        packageManager: 'pnpm',
-      };
+  async _getResolutionMode() {
+    let result = await this.run('pnpm', ['config', 'get', 'resolution-mode'], {
+      cwd: this.cwd,
+      stdio: 'pipe',
     });
 
-    debug('Switched to dependencies: \n', currentDeps);
-
-    return currentDeps;
-  },
-
-  async cleanup() {
-    try {
-      debug(`Restoring original ${PACKAGE_JSON}`);
-      let pkg = path.join(this.cwd, PACKAGE_JSON);
-      let pkgBackup = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-      await fs.copy(pkgBackup, pkg);
-      await fs.remove(pkgBackup);
-
-      debug(`Restoring original ${PNPM_LOCKFILE}`);
-      let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-      let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-      await fs.copy(lockFileBackup, lockFile);
-      await fs.remove(lockFileBackup);
-
-      await this._install();
-    } catch (e) {
-      console.log('Error cleaning up scenario:', e); // eslint-disable-line no-console
-    }
-  },
-
-  _findCurrentVersionOf(packageName) {
-    let filename = path.join(this.cwd, 'node_modules', packageName, PACKAGE_JSON);
-    if (fs.existsSync(filename)) {
-      return JSON.parse(fs.readFileSync(filename)).version;
-    } else {
-      return null;
-    }
-  },
-
-  async _install(depSet) {
-    let mgrOptions = this.managerOptions || [];
-
-    // buildManagerOptions overrides all default
-    if (typeof this.buildManagerOptions === 'function') {
-      mgrOptions = this.buildManagerOptions(depSet);
-
-      if (!Array.isArray(mgrOptions)) {
-        throw new Error('buildManagerOptions must return an array of options');
-      }
-    } else {
-      if (!mgrOptions.includes('--no-lockfile')) {
-        mgrOptions.push('--no-lockfile');
-      }
-    }
-
-    // Note: We are explicitly *not* using `--no-lockfile` here, so that we
-    // only have to resolve the dependencies that have actually changed.
-
-    debug('Run pnpm install with options %s', mgrOptions);
-
-    await this.run('pnpm', [].concat(['install'], mgrOptions), { cwd: this.cwd });
-  },
-
-  async applyDependencySet(depSet) {
-    debug('Changing to dependency set: %s', JSON.stringify(depSet));
-
-    if (!depSet) {
-      return;
-    }
-
-    let backupPackageJSON = path.join(this.cwd, PACKAGE_JSON_BACKUP);
-    let packageJSONFile = path.join(this.cwd, PACKAGE_JSON);
-    let packageJSON = JSON.parse(fs.readFileSync(backupPackageJSON));
-    let newPackageJSON = this._packageJSONForDependencySet(packageJSON, depSet);
-
-    debug('Write package.json with: \n', JSON.stringify(newPackageJSON));
-    fs.writeFileSync(packageJSONFile, JSON.stringify(newPackageJSON, null, 2));
-
-    // We restore the original lockfile here, so that we always create a minimal
-    // diff compared to the original locked dependency set.
-
-    let lockFile = path.join(this.cwd, PNPM_LOCKFILE);
-    let lockFileBackup = path.join(this.cwd, PNPM_LOCKFILE_BACKUP);
-    if (fs.existsSync(lockFileBackup)) {
-      debug(`Restoring original ${PNPM_LOCKFILE}`);
-      await fs.copy(lockFileBackup, lockFile);
+    return result.stdout.split('\n')[0];
+  }
+
+  _isResolutionModeWrong(versionStr, resolutionMode) {
+    // The `resolution-mode` is not set explicitly, and the current pnpm version makes it default
+    // to `lowest-direct`
+    if (
+      !resolutionMode.length &&
+      semver.gte(versionStr, '8.0.0') &&
+      semver.lt(versionStr, '8.7.0')
+    ) {
+      return true;
     }
-  },
 
-  _packageJSONForDependencySet(packageJSON, depSet) {
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'dependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'devDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'peerDependencies');
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'ember');
-
-    // see https://pnpm.io/package_json#pnpmoverrides
-    this._overridePackageJSONDependencies(packageJSON, depSet, 'overrides');
-
-    return packageJSON;
-  },
-
-  _overridePackageJSONDependencies(packageJSON, depSet, kindOfDependency) {
-    if (!depSet[kindOfDependency]) {
-      return;
-    }
-
-    let packageNames = Object.keys(depSet[kindOfDependency]);
-
-    for (let packageName of packageNames) {
-      if (!packageJSON[kindOfDependency]) {
-        packageJSON[kindOfDependency] = {};
-      }
-
-      let version = depSet[kindOfDependency][packageName];
-      if (version === null) {
-        delete packageJSON[kindOfDependency][packageName];
-      } else {
-        packageJSON[kindOfDependency][packageName] = version;
-      }
-    }
-  },
-});
+    return false;
+  }
+};

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();
-  },
-});
+  }
+};