yeoman-generator 2.0.5 → 3.2.0

package/lib/actions/help.js

@@ -13,33 +13,23 @@ const help = module.exports;
 /**
  * Tries to get the description from a USAGE file one folder above the
  * source root otherwise uses a default description
+ *
+ * @return {String} Help message of the generator
  */
-help.help = function () {
+help.help = function() {
   const filepath = path.resolve(this.sourceRoot(), '../USAGE');
   const exists = fs.existsSync(filepath);
 
-  let out = [
-    'Usage:',
-    '  ' + this.usage(),
-    ''
-  ];
+  let out = ['Usage:', '  ' + this.usage(), ''];
 
   // Build options
   if (Object.keys(this._options).length > 0) {
-    out = out.concat([
-      'Options:',
-      this.optionsHelp(),
-      ''
-    ]);
+    out = out.concat(['Options:', this.optionsHelp(), '']);
   }
 
   // Build arguments
   if (this._arguments.length > 0) {
-    out = out.concat([
-      'Arguments:',
-      this.argumentsHelp(),
-      ''
-    ]);
+    out = out.concat(['Arguments:', this.argumentsHelp(), '']);
   }
 
   // Append USAGE file is any
@@ -63,8 +53,10 @@ function formatArg(config) {
 /**
  * Output usage information for this given generator, depending on its arguments
  * or options
+ *
+ * @return {String} Usage information of the generator
  */
-help.usage = function () {
+help.usage = function() {
   const options = Object.keys(this._options).length ? '[options]' : '';
   let name = this.options.namespace;
   let args = '';
@@ -89,7 +81,7 @@ help.usage = function () {
  * @param {String} description
  */
 
-help.desc = function (description) {
+help.desc = function(description) {
   this.description = description || '';
   return this;
 };
@@ -98,7 +90,7 @@ help.desc = function (description) {
  * Get help text for arguments
  * @returns {String} Text of options in formatted table
  */
-help.argumentsHelp = function () {
+help.argumentsHelp = function() {
   const rows = this._arguments.map(config => {
     return [
       '',
@@ -116,7 +108,7 @@ help.argumentsHelp = function () {
  * Get help text for options
  * @returns {String} Text of options in formatted table
  */
-help.optionsHelp = function () {
+help.optionsHelp = function() {
   const options = _.reject(this._options, x => x.hide);
 
   const rows = options.map(opt => {
@@ -125,7 +117,7 @@ help.optionsHelp = function () {
       opt.alias ? `-${opt.alias}, ` : '',
       `--${opt.name}`,
       opt.description ? `# ${opt.description}` : '',
-      (opt.default !== undefined && opt.default !== '') ? 'Default: ' + opt.default : ''
+      opt.default !== undefined && opt.default !== '' ? 'Default: ' + opt.default : ''
     ];
   });
 

package/lib/actions/install.js

@@ -2,7 +2,6 @@
 const assert = require('assert');
 const _ = require('lodash');
 const dargs = require('dargs');
-const async = require('async');
 const chalk = require('chalk');
 
 /**
@@ -15,63 +14,82 @@ const install = module.exports;
  * Combine package manager cmd line arguments and run the `install` command.
  *
  * During the `install` step, every command will be scheduled to run once, on the
- * run loop. This means you can use `Promise.then` to log information, but don't
- * return it or mix it with `this.async` as it'll dead lock the process.
+ * run loop.
  *
  * @param {String} installer Which package manager to use
  * @param {String|Array} [paths] Packages to install. Use an empty string for `npm install`
  * @param {Object} [options] Options to pass to `dargs` as arguments
  * @param {Object} [spawnOptions] Options to pass `child_process.spawn`. ref
  *                                https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
- * @return {Promise} Resolved on installation success, rejected otherwise
  */
 
-install.runInstall = function (installer, paths, options, spawnOptions) {
-  return new Promise((resolve, reject) => {
-    options = options || {};
-    spawnOptions = spawnOptions || {};
-    paths = Array.isArray(paths) ? paths : (paths && paths.split(' ')) || [];
+install.scheduleInstallTask = function(installer, paths, options, spawnOptions) {
+  options = options || {};
+  spawnOptions = spawnOptions || {};
+  paths = Array.isArray(paths) ? paths : (paths && paths.split(' ')) || [];
 
-    let args = ['install'].concat(paths).concat(dargs(options));
+  let args = ['install'].concat(paths).concat(dargs(options));
 
-    // Yarn uses the `add` command to specifically add a package to a project
-    if (installer === 'yarn' && paths.length > 0) {
-      args[0] = 'add';
-    }
+  // Yarn uses the `add` command to specifically add a package to a project
+  if (installer === 'yarn' && paths.length > 0) {
+    args[0] = 'add';
+  }
 
-    // Only for npm, use a minimum cache of one day
-    if (installer === 'npm') {
-      args = args.concat(['--cache-min', 24 * 60 * 60]);
-    }
+  // Only for npm, use a minimum cache of one day
+  if (installer === 'npm') {
+    args = args.concat(['--cache-min', 24 * 60 * 60]);
+  }
 
-    // Return early if we're skipping installation
-    if (this.options.skipInstall) {
-      this.log('Skipping install command: ' + chalk.yellow(installer + ' ' + args.join(' ')));
-      return resolve();
-    }
+  // Return early if we're skipping installation
+  if (this.options.skipInstall || this.options['skip-install']) {
+    this.log(
+      'Skipping install command: ' + chalk.yellow(installer + ' ' + args.join(' '))
+    );
+    return;
+  }
 
-    this.env.runLoop.add('install', done => {
+  this.env.runLoop.add(
+    'install',
+    done => {
       this.emit(`${installer}Install`, paths);
       this.spawnCommand(installer, args, spawnOptions)
-        .on('error', err => {
-          this.log(chalk.red('Could not finish installation. \n') +
-            'Please install ' + installer + ' with ' +
-            chalk.yellow('npm install -g ' + installer) + ' and try again. \n' +
-            'If ' + installer + ' is already installed, try running the following command manually: ' + chalk.yellow(installer + ' ' + args.join(' '))
+        .on('error', error => {
+          this.log(
+            chalk.red('Could not finish installation. \n') +
+              'Please install ' +
+              installer +
+              ' with ' +
+              chalk.yellow('npm install -g ' + installer) +
+              ' and try again. \n' +
+              'If ' +
+              installer +
+              ' is already installed, try running the following command manually: ' +
+              chalk.yellow(installer + ' ' + args.join(' '))
           );
-          reject(err);
+          if (this.options.forceInstall || this.options['force-install']) {
+            this.emit('error', error);
+          }
           done();
         })
-        .on('exit', () => {
+        .on('exit', (code, signal) => {
           this.emit(`${installer}Install:end`, paths);
-          resolve();
+          if (
+            (code || signal) &&
+            (this.options.forceInstall || this.options['force-install'])
+          ) {
+            this.emit(
+              'error',
+              new Error(`Installation of ${installer} failed with code ${code || signal}`)
+            );
+          }
           done();
         });
-    }, {
+    },
+    {
       once: installer + ' ' + args.join(' '),
       run: false
-    });
-  });
+    }
+  );
 };
 
 /**
@@ -82,30 +100,30 @@ install.runInstall = function (installer, paths, options, spawnOptions) {
  * this.installDependencies({
  *   bower: true,
  *   npm: true
- * }).then(() => console.log('Everything is ready!'));
+ * });
  *
  * @example
  * this.installDependencies({
  *   yarn: {force: true},
  *   npm: false
- * }).then(() => console.log('Everything is ready!'));
+ * });
  *
  * @param {Object} [options]
  * @param {Boolean|Object} [options.npm=true] - whether to run `npm install` or can be options to pass to `dargs` as arguments
  * @param {Boolean|Object} [options.bower=true] - whether to run `bower install` or can be options to pass to `dargs` as arguments
  * @param {Boolean|Object} [options.yarn=false] - whether to run `yarn install` or can be options to pass to `dargs` as arguments
  * @param {Boolean} [options.skipMessage=false] - whether to log the used commands
- * @return {Promise} Resolved once done, rejected if errors
  */
-install.installDependencies = function (options) {
+install.installDependencies = function(options) {
   options = options || {};
-  const commands = [];
   const msg = {
     commands: [],
-    template: _.template('\n\nI\'m all done. ' +
-    '<%= skipInstall ? "Just run" : "Running" %> <%= commands %> ' +
-    '<%= skipInstall ? "" : "for you " %>to install the required dependencies.' +
-    '<% if (!skipInstall) { %> If this fails, try running the command yourself.<% } %>\n\n')
+    template: _.template(
+      "\n\nI'm all done. " +
+        '<%= skipInstall ? "Just run" : "Running" %> <%= commands %> ' +
+        '<%= skipInstall ? "" : "for you " %>to install the required dependencies.' +
+        '<% if (!skipInstall) { %> If this fails, try running the command yourself.<% } %>\n\n'
+    )
   };
 
   const getOptions = options => {
@@ -114,53 +132,36 @@ install.installDependencies = function (options) {
 
   if (options.npm !== false) {
     msg.commands.push('npm install');
-    commands.push(cb => {
-      this.npmInstall(null, getOptions(options.npm)).then(
-        val => cb(null, val),
-        cb
-      );
-    });
+    this.npmInstall(null, getOptions(options.npm));
   }
 
   if (options.yarn) {
     msg.commands.push('yarn install');
-    commands.push(cb => {
-      this.yarnInstall(null, getOptions(options.yarn)).then(
-        val => cb(null, val),
-        cb
-      );
-    });
+    this.yarnInstall(null, getOptions(options.yarn));
   }
 
   if (options.bower !== false) {
     msg.commands.push('bower install');
-    commands.push(cb => {
-      this.bowerInstall(null, getOptions(options.bower)).then(
-        val => cb(null, val),
-        cb
-      );
-    });
+    this.bowerInstall(null, getOptions(options.bower));
   }
 
-  assert(msg.commands.length, 'installDependencies needs at least one of `npm`, `bower` or `yarn` to run.');
+  assert(
+    msg.commands.length,
+    'installDependencies needs at least one of `npm`, `bower` or `yarn` to run.'
+  );
 
   if (!options.skipMessage) {
-    const tplValues = _.extend({
-      skipInstall: false
-    }, this.options, {
-      commands: chalk.yellow.bold(msg.commands.join(' && '))
-    });
+    const tplValues = _.extend(
+      {
+        skipInstall: false
+      },
+      this.options,
+      {
+        commands: chalk.yellow.bold(msg.commands.join(' && '))
+      }
+    );
     this.log(msg.template(tplValues));
   }
-
-  return new Promise((resolve, reject) => {
-    async.parallel(commands, (err, results) => {
-      if (err) {
-        return reject(err);
-      }
-      resolve(results);
-    });
-  });
 };
 
 /**
@@ -171,10 +172,9 @@ install.installDependencies = function (options) {
  * @param {String|Array} [cmpnt] Components to install
  * @param {Object} [options] Options to pass to `dargs` as arguments
  * @param {Object} [spawnOptions] Options to pass `child_process.spawn`.
- * @return {Promise} Resolved if install successful, rejected otherwise
  */
-install.bowerInstall = function (cmpnt, options, spawnOptions) {
-  return this.runInstall('bower', cmpnt, options, spawnOptions);
+install.bowerInstall = function(cmpnt, options, spawnOptions) {
+  this.scheduleInstallTask('bower', cmpnt, options, spawnOptions);
 };
 
 /**
@@ -185,10 +185,9 @@ install.bowerInstall = function (cmpnt, options, spawnOptions) {
  * @param {String|Array} [pkgs] Packages to install
  * @param {Object} [options] Options to pass to `dargs` as arguments
  * @param {Object} [spawnOptions] Options to pass `child_process.spawn`.
- * @return {Promise} Resolved if install successful, rejected otherwise
  */
-install.npmInstall = function (pkgs, options, spawnOptions) {
-  return this.runInstall('npm', pkgs, options, spawnOptions);
+install.npmInstall = function(pkgs, options, spawnOptions) {
+  this.scheduleInstallTask('npm', pkgs, options, spawnOptions);
 };
 
 /**
@@ -199,8 +198,7 @@ install.npmInstall = function (pkgs, options, spawnOptions) {
  * @param {String|Array} [pkgs] Packages to install
  * @param {Object} [options] Options to pass to `dargs` as arguments
  * @param {Object} [spawnOptions] Options to pass `child_process.spawn`.
- * @return {Promise} Resolved if install successful, rejected otherwise
  */
-install.yarnInstall = function (pkgs, options, spawnOptions) {
-  return this.runInstall('yarn', pkgs, options, spawnOptions);
+install.yarnInstall = function(pkgs, options, spawnOptions) {
+  this.scheduleInstallTask('yarn', pkgs, options, spawnOptions);
 };

package/lib/actions/spawn-command.js

@@ -11,23 +11,25 @@ const spawnCommand = module.exports;
 /**
  * Normalize a command across OS and spawn it (asynchronously).
  *
- * @param {String} command
- * @param {Array} args
- * @param {object} [opt]
+ * @param {String} command program to execute
+ * @param {Array} args list of arguments to pass to the program
+ * @param {object} [opt] any cross-spawn options
+ * @return {String} spawned process reference
  */
 spawnCommand.spawnCommand = (command, args, opt) => {
   opt = opt || {};
-  return spawn(command, args, _.defaults(opt, {stdio: 'inherit'}));
+  return spawn(command, args, _.defaults(opt, { stdio: 'inherit' }));
 };
 
 /**
  * Normalize a command across OS and spawn it (synchronously).
  *
- * @param {String} command
- * @param {Array} args
- * @param {object} [opt]
+ * @param {String} command program to execute
+ * @param {Array} args list of arguments to pass to the program
+ * @param {object} [opt] any cross-spawn options
+ * @return {String} spawn.sync result
  */
 spawnCommand.spawnCommandSync = (command, args, opt) => {
   opt = opt || {};
-  return spawn.sync(command, args, _.defaults(opt, {stdio: 'inherit'}));
+  return spawn.sync(command, args, _.defaults(opt, { stdio: 'inherit' }));
 };

package/lib/actions/user.js

@@ -27,7 +27,7 @@ user.git.name = () => {
   }
 
   if (shell.which('git')) {
-    name = shell.exec('git config --get user.name', {silent: true}).stdout.trim();
+    name = shell.exec('git config --get user.name', { silent: true }).stdout.trim();
     nameCache.set(process.cwd(), name);
   }
 
@@ -47,7 +47,7 @@ user.git.email = () => {
   }
 
   if (shell.which('git')) {
-    email = shell.exec('git config --get user.email', {silent: true}).stdout.trim();
+    email = shell.exec('git config --get user.email', { silent: true }).stdout.trim();
     emailCache.set(process.cwd(), email);
   }
 

package/lib/index.js

@@ -75,7 +75,7 @@ class Generator extends EventEmitter {
     this.option('help', {
       type: Boolean,
       alias: 'h',
-      description: 'Print the generator\'s options and usage'
+      description: "Print the generator's options and usage"
     });
 
     this.option('skip-cache', {
@@ -90,9 +90,21 @@ class Generator extends EventEmitter {
       default: false
     });
 
+    this.option('force-install', {
+      type: Boolean,
+      description: 'Fail on install dependencies error',
+      default: false
+    });
+
     // Checks required parameters
-    assert(this.options.env, 'You must provide the environment object. Use env#create() to create a new generator.');
-    assert(this.options.resolved, 'You must provide the resolved path value. Use env#create() to create a new generator.');
+    assert(
+      this.options.env,
+      'You must provide the environment object. Use env#create() to create a new generator.'
+    );
+    assert(
+      this.options.resolved,
+      'You must provide the resolved path value. Use env#create() to create a new generator.'
+    );
     this.env = this.options.env;
     this.resolved = this.options.resolved;
 
@@ -122,11 +134,13 @@ class Generator extends EventEmitter {
     rootPath = rootPath ? path.dirname(rootPath) : this.env.cwd;
 
     if (rootPath !== this.env.cwd) {
-      this.log([
-        '',
-        'Just found a `.yo-rc.json` in a parent directory.',
-        'Setting the project root at: ' + rootPath
-      ].join('\n'));
+      this.log(
+        [
+          '',
+          'Just found a `.yo-rc.json` in a parent directory.',
+          'Setting the project root at: ' + rootPath
+        ].join('\n')
+      );
       this.destinationRoot(rootPath);
     }
 
@@ -153,7 +167,7 @@ class Generator extends EventEmitter {
     questions = promptSuggestion.prefillQuestions(this.config, questions);
 
     return this.env.adapter.prompt(questions).then(answers => {
-      if (!this.options['skip-cache']) {
+      if (!this.options['skip-cache'] && !this.options.skipCache) {
         promptSuggestion.storeAnswers(this._globalConfig, questions, answers, false);
         promptSuggestion.storeAnswers(this.config, questions, answers, true);
       }
@@ -198,12 +212,17 @@ class Generator extends EventEmitter {
     const boolOptionRegex = /^no-/;
     if (config.type === Boolean && name.match(boolOptionRegex)) {
       const simpleName = name.replace(boolOptionRegex, '');
-      return this.emit('error', new Error([
-        `Option name ${chalk.yellow(name)} cannot start with ${chalk.red('no-')}\n`,
-        `Option name prefixed by ${chalk.yellow('--no')} are parsed as implicit`,
-        ` boolean. To use ${chalk.yellow('--' + name)} as an option, use\n`,
-        chalk.cyan(`  this.option('${simpleName}', {type: Boolean})`)
-      ].join('')));
+      return this.emit(
+        'error',
+        new Error(
+          [
+            `Option name ${chalk.yellow(name)} cannot start with ${chalk.red('no-')}\n`,
+            `Option name prefixed by ${chalk.yellow('--no')} are parsed as implicit`,
+            ` boolean. To use ${chalk.yellow('--' + name)} as an option, use\n`,
+            chalk.cyan(`  this.option('${simpleName}', {type: Boolean})`)
+          ].join('')
+        )
+      );
     }
 
     if (this._options[name] === null || this._options[name] === undefined) {
@@ -348,7 +367,10 @@ class Generator extends EventEmitter {
       // If the help option was not provided, check whether the argument was
       // required, and whether a value was provided.
       if (config.required && position >= this.args.length) {
-        return this.emit('error', new Error(`Did not provide required argument ${chalk.bold(config.name)}!`));
+        return this.emit(
+          'error',
+          new Error(`Did not provide required argument ${chalk.bold(config.name)}!`)
+        );
       }
     });
   }
@@ -364,154 +386,205 @@ class Generator extends EventEmitter {
    * provided, the same values used to initialize the invoker are used to
    * initialize the invoked.
    *
-   * @param {Function} [cb]
+   * @param {Function} [cb] Deprecated: prefer to use the promise interface
+   * @return {Promise} Resolved once the process finish
    */
   run(cb) {
-    cb = cb || (() => {});
-
-    const self = this;
-    this._running = true;
-    this.emit('run');
-
-    const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(this));
-    const validMethods = methods.filter(methodIsValid);
-    assert(validMethods.length, 'This Generator is empty. Add at least one method for it to run.');
-
-    this.env.runLoop.once('end', () => {
-      this.emit('end');
-      cb();
-    });
-
-    // Ensure a prototype method is a candidate run by default
-    function methodIsValid(name) {
-      return name.charAt(0) !== '_' && name !== 'constructor';
-    }
-
-    function addMethod(method, methodName, queueName) {
-      queueName = queueName || 'default';
-      debug(`Queueing ${methodName} in ${queueName}`);
-      self.env.runLoop.add(queueName, completed => {
-        debug(`Running ${methodName}`);
-        self.emit(`method:${methodName}`);
-
-        runAsync(function () {
-          self.async = () => this.async();
-          return method.apply(self, self.args);
-        })().then(completed).catch(err => {
-          debug(`An error occured while running ${methodName}`, err);
-
-          // Ensure we emit the error event outside the promise context so it won't be
-          // swallowed when there's no listeners.
-          setImmediate(() => {
-            self.emit('error', err);
-            cb(err);
-          });
-        });
+    const promise = new Promise((resolve, reject) => {
+      const self = this;
+      this._running = true;
+      this.emit('run');
+
+      const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(this));
+      const validMethods = methods.filter(methodIsValid);
+      assert(
+        validMethods.length,
+        'This Generator is empty. Add at least one method for it to run.'
+      );
+
+      this.env.runLoop.once('end', () => {
+        this.emit('end');
+        resolve();
       });
-    }
 
-    function addInQueue(name) {
-      const item = Object.getPrototypeOf(self)[name];
-      const queueName = self.env.runLoop.queueNames.indexOf(name) === -1 ? null : name;
-
-      // Name points to a function; run it!
-      if (typeof item === 'function') {
-        return addMethod(item, name, queueName);
+      // Ensure a prototype method is a candidate run by default
+      function methodIsValid(name) {
+        return name.charAt(0) !== '_' && name !== 'constructor';
       }
 
-      // Not a queue hash; stop
-      if (!queueName) {
-        return;
+      function addMethod(method, methodName, queueName) {
+        queueName = queueName || 'default';
+        debug(`Queueing ${methodName} in ${queueName}`);
+        self.env.runLoop.add(queueName, completed => {
+          debug(`Running ${methodName}`);
+          self.emit(`method:${methodName}`);
+
+          runAsync(function() {
+            self.async = () => this.async();
+            return method.apply(self, self.args);
+          })()
+            .then(completed)
+            .catch(err => {
+              debug(`An error occured while running ${methodName}`, err);
+
+              // Ensure we emit the error event outside the promise context so it won't be
+              // swallowed when there's no listeners.
+              setImmediate(() => {
+                self.emit('error', err);
+                reject(err);
+              });
+            });
+        });
       }
 
-      // Run each queue items
-      _.each(item, (method, methodName) => {
-        if (!_.isFunction(method) || !methodIsValid(methodName)) {
+      function addInQueue(name) {
+        const item = Object.getPrototypeOf(self)[name];
+        const queueName = self.env.runLoop.queueNames.indexOf(name) === -1 ? null : name;
+
+        // Name points to a function; run it!
+        if (typeof item === 'function') {
+          return addMethod(item, name, queueName);
+        }
+
+        // Not a queue hash; stop
+        if (!queueName) {
           return;
         }
 
-        addMethod(method, methodName, queueName);
-      });
-    }
+        // Run each queue items
+        _.each(item, (method, methodName) => {
+          if (!_.isFunction(method) || !methodIsValid(methodName)) {
+            return;
+          }
 
-    validMethods.forEach(addInQueue);
+          addMethod(method, methodName, queueName);
+        });
+      }
 
-    const writeFiles = () => {
-      this.env.runLoop.add('conflicts', this._writeFiles.bind(this), {
-        once: 'write memory fs to disk'
-      });
-    };
+      validMethods.forEach(addInQueue);
 
-    this.env.sharedFs.on('change', writeFiles);
-    writeFiles();
+      const writeFiles = () => {
+        this.env.runLoop.add('conflicts', this._writeFiles.bind(this), {
+          once: 'write memory fs to disk'
+        });
+      };
 
-    // Add the default conflicts handling
-    this.env.runLoop.add('conflicts', done => {
-      this.conflicter.resolve(err => {
-        if (err) {
-          this.emit('error', err);
-        }
+      this.env.sharedFs.on('change', writeFiles);
+      writeFiles();
 
-        done();
+      // Add the default conflicts handling
+      this.env.runLoop.add('conflicts', done => {
+        this.conflicter.resolve(err => {
+          if (err) {
+            this.emit('error', err);
+          }
+
+          done();
+        });
       });
+
+      _.invokeMap(this._composedWith, 'run');
     });
 
-    _.invokeMap(this._composedWith, 'run');
-    return this;
+    // Maintain backward compatibility with the callback function
+    if (_.isFunction(cb)) {
+      promise.then(cb, cb);
+    }
+
+    return promise;
   }
 
   /**
    * Compose this generator with another one.
-   * @param  {String} namespace  The generator namespace to compose with
+   * @param  {String|Object} generator  The path to the generator module or an object (see examples)
    * @param  {Object} options    The options passed to the Generator
-   * @param  {Object} [settings] Settings hash on the composition relation
-   * @param  {string} [settings.local]        Path to a locally stored generator
-   * @param  {String} [settings.link="weak"]  If "strong", the composition will occured
-   *                                          even when the composition is initialized by
-   *                                          the end user
-   * @return {this}
+   * @return {this}    This generator
    *
    * @example <caption>Using a peerDependency generator</caption>
    * this.composeWith('bootstrap', { sass: true });
    *
    * @example <caption>Using a direct dependency generator</caption>
    * this.composeWith(require.resolve('generator-bootstrap/app/main.js'), { sass: true });
+   *
+   * @example <caption>Passing a Generator class</caption>
+   * this.composeWith({ Generator: MyGenerator, path: '../generator-bootstrap/app/main.js' }, { sass: true });
    */
-  composeWith(modulePath, options) {
-    let generator;
-    options = options || {};
+  composeWith(generator, options) {
+    let instantiatedGenerator;
 
-    // Pass down the default options so they're correctly mirrored down the chain.
-    options = _.extend({
-      skipInstall: this.options.skipInstall,
-      'skip-install': this.options.skipInstall,
-      skipCache: this.options.skipCache,
-      'skip-cache': this.options.skipCache
-    }, options);
-
-    try {
-      const Generator = require(modulePath); // eslint-disable-line import/no-dynamic-require
-      Generator.resolved = require.resolve(modulePath);
-      Generator.namespace = this.env.namespace(modulePath);
-      generator = this.env.instantiate(Generator, {
+    const instantiate = (Generator, path) => {
+      Generator.resolved = require.resolve(path);
+      Generator.namespace = this.env.namespace(path);
+
+      return this.env.instantiate(Generator, {
         options,
         arguments: options.arguments
       });
-    } catch (err) {
-      if (err.code === 'MODULE_NOT_FOUND') {
-        generator = this.env.create(modulePath, {
-          options,
-          arguments: options.arguments
-        });
-      } else {
-        throw err;
+    };
+
+    options = options || {};
+
+    // Pass down the default options so they're correctly mirrored down the chain.
+    options = _.extend(
+      {
+        skipInstall: this.options.skipInstall || this.options['skip-install'],
+        'skip-install': this.options.skipInstall || this.options['skip-install'],
+        skipCache: this.options.skipCache || this.options['skip-cache'],
+        'skip-cache': this.options.skipCache || this.options['skip-cache'],
+        forceInstall: this.options.forceInstall || this.options['force-install'],
+        'force-install': this.options.forceInstall || this.options['force-install']
+      },
+      options
+    );
+
+    if (typeof generator === 'string') {
+      try {
+        const Generator = require(generator); // eslint-disable-line import/no-dynamic-require
+        instantiatedGenerator = instantiate(Generator, generator);
+      } catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND') {
+          instantiatedGenerator = this.env.create(generator, {
+            options,
+            arguments: options.arguments
+          });
+        } else {
+          throw err;
+        }
       }
+    } else {
+      assert(
+        generator.Generator,
+        `${chalk.red('Missing Generator property')}\n` +
+          `When passing an object to Generator${chalk.cyan(
+            '#composeWith'
+          )} include the generator class to run in the ${chalk.cyan(
+            'Generator'
+          )} property\n\n` +
+          `this.composeWith({\n` +
+          `  ${chalk.yellow('Generator')}: MyGenerator,\n` +
+          `  ...\n` +
+          `});`
+      );
+      assert(
+        typeof generator.path === 'string',
+        `${chalk.red('path property is not a string')}\n` +
+          `When passing an object to Generator${chalk.cyan(
+            '#composeWith'
+          )} include the path to the generators files in the ${chalk.cyan(
+            'path'
+          )} property\n\n` +
+          `this.composeWith({\n` +
+          `  ${chalk.yellow('path')}: '../my-generator',\n` +
+          `  ...\n` +
+          `});`
+      );
+      instantiatedGenerator = instantiate(generator.Generator, generator.path);
     }
 
     if (this._running) {
-      generator.run();
+      instantiatedGenerator.run();
     } else {
-      this._composedWith.push(generator);
+      this._composedWith.push(instantiatedGenerator);
     }
 
     return this;
@@ -522,7 +595,7 @@ class Generator extends EventEmitter {
    * @return {String} The name of the root generator
    */
   rootGeneratorName() {
-    const pkg = readPkgUp.sync({cwd: this.resolved}).pkg;
+    const pkg = readPkgUp.sync({ cwd: this.resolved }).pkg;
     return pkg ? pkg.name : '*';
   }
 
@@ -531,7 +604,7 @@ class Generator extends EventEmitter {
    * @return {String} The version of the root generator
    */
   rootGeneratorVersion() {
-    const pkg = readPkgUp.sync({cwd: this.resolved}).pkg;
+    const pkg = readPkgUp.sync({ cwd: this.resolved }).pkg;
     return pkg ? pkg.version : '0.0.0';
   }
 
@@ -673,7 +746,7 @@ class Generator extends EventEmitter {
   _writeFiles(done) {
     const self = this;
 
-    const conflictChecker = through.obj(function (file, enc, cb) {
+    const conflictChecker = through.obj(function(file, enc, cb) {
       const stream = this;
 
       // If the file has no state requiring action, move on

package/lib/util/binary-diff.js

@@ -8,8 +8,10 @@ const Table = require('cli-table');
 
 exports.isBinary = (existingFilePath, newFileContents) => {
   const existingHeader = readChunk.sync(existingFilePath, 0, 512);
-  return istextorbinary.isBinarySync(undefined, existingHeader) ||
-    (newFileContents && istextorbinary.isBinarySync(undefined, newFileContents));
+  return (
+    istextorbinary.isBinarySync(undefined, existingHeader) ||
+    (newFileContents && istextorbinary.isBinarySync(undefined, newFileContents))
+  );
 };
 
 exports.diff = (existingFilePath, newFileContents) => {
@@ -32,17 +34,15 @@ exports.diff = (existingFilePath, newFileContents) => {
 
   sizeDiff += prettyBytes(Math.abs(existingStat.size - newFileContents.length));
 
-  table.push([
-    'Size',
-    prettyBytes(existingStat.size),
-    prettyBytes(newFileContents.length),
-    sizeDiff
-  ], [
-    'Last modified',
-    dateFormat(existingStat.mtime),
-    '',
-    ''
-  ]);
+  table.push(
+    [
+      'Size',
+      prettyBytes(existingStat.size),
+      prettyBytes(newFileContents.length),
+      sizeDiff
+    ],
+    ['Last modified', dateFormat(existingStat.mtime), '', '']
+  );
 
   return table.toString();
 };

package/lib/util/conflicter.js

@@ -103,7 +103,6 @@ class Conflicter {
    * @param  {Object}   file File object respecting this interface: { path, contents }
    * @param  {Function} cb Callback receiving a status string ('identical', 'create',
    *                       'skip', 'force')
-   * @return {null} nothing
    */
   collision(file, cb) {
     const rfilepath = path.relative(process.cwd(), file.path);
@@ -132,8 +131,8 @@ class Conflicter {
   /**
    * Actual prompting logic
    * @private
-   * @param {Object} file
-   * @param {Function} cb
+   * @param {Object} file vinyl file object
+   * @param {Function} cb callback receiving the next action
    */
   _ask(file, cb) {
     const rfilepath = path.relative(process.cwd(), file.path);
@@ -141,23 +140,28 @@ class Conflicter {
       name: 'action',
       type: 'expand',
       message: `Overwrite ${rfilepath}?`,
-      choices: [{
-        key: 'y',
-        name: 'overwrite',
-        value: 'write'
-      }, {
-        key: 'n',
-        name: 'do not overwrite',
-        value: 'skip'
-      }, {
-        key: 'a',
-        name: 'overwrite this and all others',
-        value: 'force'
-      }, {
-        key: 'x',
-        name: 'abort',
-        value: 'abort'
-      }]
+      choices: [
+        {
+          key: 'y',
+          name: 'overwrite',
+          value: 'write'
+        },
+        {
+          key: 'n',
+          name: 'do not overwrite',
+          value: 'skip'
+        },
+        {
+          key: 'a',
+          name: 'overwrite this and all others',
+          value: 'force'
+        },
+        {
+          key: 'x',
+          name: 'abort',
+          value: 'abort'
+        }
+      ]
     };
 
     // Only offer diff option for files
@@ -194,7 +198,7 @@ class Conflicter {
         result.action = 'force';
       }
 
-      this.adapter.log[result.action](rfilepath);
+      this.adapter.log[result.action || 'force'](rfilepath);
       return cb(result.action);
     });
   }

package/lib/util/deprecate.js

@@ -3,7 +3,7 @@ const _ = require('lodash');
 const chalk = require('chalk');
 
 const deprecate = (message, fn) => {
-  return function () {
+  return function() {
     deprecate.log(message);
     return fn.apply(this, arguments);
   };
@@ -25,7 +25,7 @@ deprecate.object = (message, object) => {
       continue;
     }
 
-    mirror[name] = deprecate(msgTpl({name}), func);
+    mirror[name] = deprecate(msgTpl({ name }), func);
   }
 
   return mirror;

package/lib/util/prompt-suggestion.js

@@ -36,7 +36,9 @@ const getCheckboxDefault = (question, defaultValue) => {
  * @private
  */
 const getListDefault = (question, defaultValue) => {
-  const choiceValues = question.choices.map(choice => typeof choice === 'object' ? choice.value : choice);
+  const choiceValues = question.choices.map(choice =>
+    typeof choice === 'object' ? choice.value : choice
+  );
   return choiceValues.indexOf(defaultValue);
 };
 
@@ -115,7 +117,7 @@ promptSuggestion.prefillQuestions = (store, questions) => {
 
     const storedValue = promptValues[question.name];
 
-    if ((storedValue === undefined) || _.isFunction(question.choices)) {
+    if (storedValue === undefined || _.isFunction(question.choices)) {
       // Do not override prompt default when question.choices is a function,
       // since can't guarantee that the `storedValue` will even be in the returned choices
       return question;

package/lib/util/storage.js

@@ -52,7 +52,6 @@ class Storage {
 
   /**
    * Save a new object of values
-   * @return {null}
    */
   save() {
     this._persist(this._store);
@@ -82,7 +81,7 @@ class Storage {
    * @return {*} val  Whatever was passed in as val.
    */
   set(key, val) {
-    assert(!_.isFunction(val), 'Storage value can\'t be a function');
+    assert(!_.isFunction(val), "Storage value can't be a function");
 
     const store = this._store;
 
@@ -99,7 +98,6 @@ class Storage {
   /**
    * Delete a key from the store and schedule a save.
    * @param  {String} key  The key under which the value is stored.
-   * @return {null}
    */
   delete(key) {
     const store = this._store;

package/package.json

@@ -1,24 +1,13 @@
 {
   "name": "yeoman-generator",
-  "version": "2.0.5",
+  "version": "3.2.0",
   "description": "Rails-inspired generator system that provides scaffolding for your apps",
-  "license": "BSD-2-Clause",
-  "repository": "yeoman/generator",
   "homepage": "http://yeoman.io",
   "author": "Yeoman",
-  "main": "lib",
-  "engines": {
-    "node": ">=4"
-  },
-  "scripts": {
-    "pretest": "xo",
-    "test": "nyc mocha",
-    "doc": "jsdoc -c jsdoc.json",
-    "coverage": "nyc report --reporter=text-lcov | coveralls"
-  },
   "files": [
     "lib"
   ],
+  "main": "lib",
   "keywords": [
     "development",
     "dev",
@@ -32,62 +21,96 @@
     "yeoman",
     "app"
   ],
+  "devDependencies": {
+    "coveralls": "^3.0.2",
+    "eslint": "^5.10.0",
+    "eslint-config-prettier": "^3.3.0",
+    "eslint-config-xo": "^0.25.1",
+    "eslint-plugin-prettier": "^3.0.0",
+    "husky": "^1.2.1",
+    "inquirer": "^6.0.0",
+    "jsdoc": "^3.5.5",
+    "lint-staged": "^8.1.0",
+    "mocha": "^5.1.1",
+    "mockery": "^2.1.0",
+    "nock": "^10.0.4",
+    "nyc": "^13.1.0",
+    "prettier": "^1.15.3",
+    "proxyquire": "^2.0.1",
+    "sinon": "^7.2.2",
+    "tui-jsdoc-template": "^1.2.2",
+    "yeoman-assert": "^3.1.1",
+    "yeoman-test": "^1.8.0"
+  },
+  "license": "BSD-2-Clause",
+  "repository": "yeoman/generator",
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "pretest": "eslint .",
+    "test": "nyc mocha",
+    "doc": "jsdoc -c jsdoc.json",
+    "coverage": "nyc report --reporter=text-lcov | coveralls",
+    "precommit": "lint-staged"
+  },
   "dependencies": {
     "async": "^2.6.0",
     "chalk": "^2.3.0",
     "cli-table": "^0.3.1",
     "cross-spawn": "^6.0.5",
-    "dargs": "^5.1.0",
+    "dargs": "^6.0.0",
     "dateformat": "^3.0.3",
-    "debug": "^3.1.0",
+    "debug": "^4.1.0",
     "detect-conflict": "^1.0.0",
     "error": "^7.0.2",
-    "find-up": "^2.1.0",
+    "find-up": "^3.0.0",
     "github-username": "^4.0.0",
     "istextorbinary": "^2.2.1",
     "lodash": "^4.17.10",
     "make-dir": "^1.1.0",
-    "mem-fs-editor": "^4.0.0",
+    "mem-fs-editor": "^5.0.0",
     "minimist": "^1.2.0",
-    "pretty-bytes": "^4.0.2",
-    "read-chunk": "^2.1.0",
-    "read-pkg-up": "^3.0.0",
+    "pretty-bytes": "^5.1.0",
+    "read-chunk": "^3.0.0",
+    "read-pkg-up": "^4.0.0",
     "rimraf": "^2.6.2",
     "run-async": "^2.0.0",
     "shelljs": "^0.8.0",
     "text-table": "^0.2.0",
-    "through2": "^2.0.0",
+    "through2": "^3.0.0",
     "yeoman-environment": "^2.0.5"
   },
-  "devDependencies": {
-    "coveralls": "^3.0.0",
-    "inquirer": "^5.2.0",
-    "jsdoc": "^3.5.5",
-    "mocha": "^5.1.1",
-    "mockery": "^2.1.0",
-    "nock": "^9.1.6",
-    "nsp": "^3.2.1",
-    "nyc": "^11.4.1",
-    "proxyquire": "^2.0.1",
-    "sinon": "^4.5.0",
-    "tui-jsdoc-template": "^1.2.2",
-    "xo": "^0.20.3",
-    "yeoman-assert": "^3.1.1",
-    "yeoman-test": "^1.7.0"
+  "lint-staged": {
+    "*.js": [
+      "eslint --fix",
+      "git add"
+    ],
+    "*.json": [
+      "prettier --write",
+      "git add"
+    ]
   },
-  "xo": {
-    "space": true,
+  "eslintConfig": {
+    "extends": [
+      "xo",
+      "prettier"
+    ],
+    "env": {
+      "mocha": true,
+      "node": true
+    },
     "rules": {
-      "promise/no-callback-in-promise": "off"
+      "prettier/prettier": [
+        "error",
+        {
+          "singleQuote": true,
+          "printWidth": 90
+        }
+      ]
     },
-    "overrides": [
-      {
-        "files": "test/**",
-        "envs": [
-          "node",
-          "mocha"
-        ]
-      }
+    "plugins": [
+      "prettier"
     ]
   }
 }