ember-try 1.2.0 → 2.0.0

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

@@ -2,11 +2,11 @@
 
 const CoreObject = require('core-object');
 const fs = require('fs-extra');
-const RSVP = require('rsvp');
+const util = require('util');
+const copy = util.promisify(fs.copy);
 const path = require('path');
-const extend = require('extend');
 const debug = require('debug')('ember-try:dependency-manager-adapter:npm');
-const rimraf = RSVP.denodeify(require('rimraf'));
+const rimraf = util.promisify(require('rimraf'));
 const chalk = require('chalk');
 
 module.exports = CoreObject.extend({
@@ -16,64 +16,92 @@ module.exports = CoreObject.extend({
   },
   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',
-  setup(options) {
+  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 this._backupOriginalDependencies();
-  },
-  changeToDependencySet(depSet) {
-    let adapter = this;
 
-    adapter.applyDependencySet(depSet);
+    return await this._backupOriginalDependencies();
+  },
 
-    return adapter._install().then(() => {
-      let deps = extend({}, depSet.dependencies || {}, depSet.devDependencies || {});
-      let currentDeps = Object.keys(deps).map((dep) => {
-        return {
-          name: dep,
-          versionExpected: deps[dep],
-          versionSeen: adapter._findCurrentVersionOf(dep),
-          packageManager: adapter.useYarnCommand ? 'yarn' : 'npm',
-        };
-      });
+  async changeToDependencySet(depSet) {
+    this.applyDependencySet(depSet);
 
-      debug('Switched to dependencies: \n', currentDeps);
+    await this._install(depSet);
 
-      return RSVP.Promise.resolve(currentDeps);
+    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;
   },
-  cleanup() {
-    let adapter = this;
 
-    return this._restoreOriginalDependencies().then(() => {
+  async cleanup() {
+    try {
+      await this._restoreOriginalDependencies();
+
       debug('Remove backup package.json and node_modules');
 
-      let cleanupTasks = [rimraf(path.join(adapter.cwd, adapter.packageJSONBackupFileName)),
-        rimraf(path.join(adapter.cwd, adapter.nodeModulesBackupLocation))];
+      let cleanupTasks = [
+        rimraf(path.join(this.cwd, this.packageJSONBackupFileName)),
+        rimraf(path.join(this.cwd, this.nodeModulesBackupLocation)),
+      ];
 
-      return RSVP.all(cleanupTasks);
-    }).catch((e) => {
+      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.'));
+          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)) {
@@ -82,37 +110,56 @@ module.exports = CoreObject.extend({
       return null;
     }
   },
-  _install() {
-    let adapter = this;
+
+  async _install(depSet) {
     let mgrOptions = this.managerOptions || [];
+    let cmd = this.useYarnCommand ? 'yarn' : 'npm';
 
-    debug('Run npm install with options %s', mgrOptions);
+    // buildManagerOptions overrides all default
+    if (typeof this.buildManagerOptions === 'function') {
+      mgrOptions = this.buildManagerOptions(depSet);
 
-    let cmd = this.useYarnCommand ? 'yarn' : 'npm';
-    if (this.useYarnCommand) {
-      if (mgrOptions.indexOf('--no-lockfile') === -1) {
-        mgrOptions = mgrOptions.concat(['--no-lockfile']);
+      if (!Array.isArray(mgrOptions)) {
+        throw new Error('buildManagerOptions must return an array of options');
       }
-      // npm warns on incompatible engines
-      // yarn errors, not a good experience
-      if (mgrOptions.indexOf('--ignore-engines') === -1) {
-        mgrOptions = mgrOptions.concat(['--ignore-engines']);
+    } 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']);
       }
-    } else if (mgrOptions.indexOf('--no-shrinkwrap') === -1) {
-      mgrOptions = mgrOptions.concat(['--no-shrinkwrap']);
     }
 
-    return this.run(cmd, [].concat(['install'], mgrOptions), { cwd: this.cwd }).then(() => {
-      if (!adapter.useYarnCommand) {
-        return adapter.run(adapter.configKey, ['prune'], { cwd: adapter.cwd });
+    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) {
 
+  applyDependencySet(depSet) {
     debug('Changing to dependency set: %s', JSON.stringify(depSet));
 
-    if (!depSet) { return RSVP.resolve([]); }
+    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));
@@ -122,11 +169,12 @@ module.exports = CoreObject.extend({
 
     fs.writeFileSync(packageJSONFile, JSON.stringify(newPackageJSON, null, 2));
   },
-  _packageJSONForDependencySet(packageJSON, depSet) {
 
+  _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');
@@ -134,48 +182,99 @@ module.exports = CoreObject.extend({
 
     return packageJSON;
   },
+
   _overridePackageJSONDependencies(packageJSON, depSet, kindOfDependency) {
-    if (!depSet[kindOfDependency]) { return; }
-    let pkgs = Object.keys(depSet[kindOfDependency]);
+    if (!depSet[kindOfDependency]) {
+      return;
+    }
 
-    pkgs.forEach((pkg) => {
+    let packageNames = Object.keys(depSet[kindOfDependency]);
+
+    packageNames.forEach((packageName) => {
       if (!packageJSON[kindOfDependency]) {
         packageJSON[kindOfDependency] = {};
       }
 
-      let version = depSet[kindOfDependency][pkg];
+      let version = depSet[kindOfDependency][packageName];
       if (version === null) {
-        delete packageJSON[kindOfDependency][pkg];
+        delete packageJSON[kindOfDependency][packageName];
       } else {
-        packageJSON[kindOfDependency][pkg] = version;
+        packageJSON[kindOfDependency][packageName] = version;
       }
     });
   },
-  _restoreOriginalDependencies() {
-    let copy = RSVP.denodeify(fs.copy);
 
+  _restoreOriginalDependencies() {
     debug('Restoring original package.json and node_modules');
 
     let restoreTasks = [
-      copy(path.join(this.cwd, this.packageJSONBackupFileName),
-        path.join(this.cwd, this.packageJSON)),
-      copy(path.join(this.cwd, this.nodeModulesBackupLocation),
-        path.join(this.cwd, this.nodeModules), { clobber: true }),
+      copy(
+        path.join(this.cwd, this.packageJSONBackupFileName),
+        path.join(this.cwd, this.packageJSON)
+      ),
     ];
 
-    return RSVP.all(restoreTasks);
+    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() {
-    let copy = RSVP.denodeify(fs.copy);
 
+  _backupOriginalDependencies() {
     debug('Backing up package.json and node_modules');
 
     let backupTasks = [
-      copy(path.join(this.cwd, this.packageJSON),
-        path.join(this.cwd, this.packageJSONBackupFileName)),
-      copy(path.join(this.cwd, this.nodeModules),
-        path.join(this.cwd, this.nodeModulesBackupLocation), { clobber: true })];
+      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 RSVP.all(backupTasks);
+    return Promise.all(backupTasks);
   },
 });

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

@@ -0,0 +1,170 @@
+'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 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');
+  },
+
+  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);
+    }
+  },
+
+  async changeToDependencySet(depSet) {
+    await 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: 'pnpm',
+      };
+    });
+
+    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('--frozen-lockfile=false')) {
+      mgrOptions.push('--frozen-lockfile=false');
+    }
+
+    // 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);
+    }
+  },
+
+  _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;
+      }
+    }
+  },
+});

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

@@ -2,9 +2,7 @@
 
 const CoreObject = require('core-object');
 const fs = require('fs-extra');
-const RSVP = require('rsvp');
 const path = require('path');
-const extend = require('extend');
 const debug = require('debug')('ember-try:dependency-manager-adapter:workspaces');
 const walkSync = require('walk-sync');
 
@@ -16,85 +14,105 @@ module.exports = CoreObject.extend({
     this.run = this.run || require('../utils/run');
 
     if (!this.useYarnCommand) {
-      throw new Error('workspaces are currently only supported by Yarn, you must set `useYarn` to true');
+      throw new Error(
+        'workspaces are currently only supported by Yarn, you must set `useYarn` to true'
+      );
     }
-  },
-
-  packageJSON: 'package.json',
+    let packageJSON = JSON.parse(fs.readFileSync(this.packageJSON));
+    let workspaceGlobs;
 
-  setup(options) {
-    if (!options) {
-      options = {};
+    if (Array.isArray(packageJSON.workspaces)) {
+      workspaceGlobs = packageJSON.workspaces;
     }
 
-    let packageJSON = JSON.parse(fs.readFileSync(this.packageJSON));
-    let workspaceGlobs = packageJSON.workspaces;
+    if (packageJSON.workspaces && Array.isArray(packageJSON.workspaces.packages)) {
+      workspaceGlobs = packageJSON.workspaces.packages;
+    }
 
     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');
+      throw new Error(
+        'you must define the `workspaces` property in package.json with at least one workspace to use workspaces with ember-try'
+      );
     }
 
     // workspaces is a list of globs, loop over the list and find
     // all paths that contain a `package.json` file
-    let workspacePaths = walkSync('.', { globs: workspaceGlobs }).filter(workspacePath => {
+    let workspacePaths = walkSync('.', { globs: workspaceGlobs }).filter((workspacePath) => {
       let packageJSONPath = path.join(this.cwd, workspacePath, 'package.json');
       return fs.existsSync(packageJSONPath);
     });
 
-    this._packageAdapters = workspacePaths.map(workspacePath => {
+    this._packageAdapters = workspacePaths.map((workspacePath) => {
       return new NpmAdapter({
         cwd: workspacePath,
         run: this.run,
         managerOptions: this.managerOptions,
         useYarnCommand: true,
+        buildManagerOptions: this.buildManagerOptions,
       });
     });
+  },
 
-    return RSVP.all(this._packageAdapters.map(adapter => adapter.setup(options)));
+  packageJSON: 'package.json',
+
+  setup(options) {
+    if (!options) {
+      options = {};
+    }
+
+    return Promise.all(this._packageAdapters.map((adapter) => adapter.setup(options)));
   },
 
-  changeToDependencySet(depSet) {
+  async changeToDependencySet(depSet) {
     // TODO: What should this do for tables? Nesting? Needs different output
-    this._packageAdapters.forEach(adapter => {
+    this._packageAdapters.forEach((adapter) => {
       adapter.applyDependencySet(depSet);
     });
 
-    return this._install().then(() => {
-      let deps = extend({}, depSet.dependencies || {}, depSet.devDependencies || {});
-      let currentDeps = Object.keys(deps).map((dep) => {
-        return {
-          name: dep,
-          versionExpected: deps[dep],
-          versionSeen: this._findCurrentVersionOf(dep),
-          packageManager: 'yarn',
-        };
-      });
+    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: 'yarn',
+      };
+    });
 
-      debug('Switched to dependencies: \n', currentDeps);
+    debug('Switched to dependencies: \n', currentDeps);
 
-      return RSVP.Promise.resolve(currentDeps);
-    });
+    return currentDeps;
   },
 
   cleanup() {
-    return RSVP.all(this._packageAdapters.map(adapter => adapter.cleanup()));
+    return Promise.all(this._packageAdapters.map((adapter) => adapter.cleanup()));
   },
 
-  _install() {
+  _install(depSet) {
     let mgrOptions = this.managerOptions || [];
 
-    debug('Run yarn install with options %s', mgrOptions);
-
-    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']);
+    // 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.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']);
+      }
     }
 
-    return this.run('yarn', [].concat(['install'], mgrOptions), { cwd: this.cwd });
+    debug('Run yarn install with options %s', mgrOptions);
+
+    return this.run('yarn', ['install', ...mgrOptions], { cwd: this.cwd });
   },
 
   _findCurrentVersionOf(dep) {