yeoman-generator 4.8.3 → 4.11.0

package/lib/actions/fs.js

@@ -0,0 +1,230 @@
+/* eslint max-params: [1, 5] */
+const assert = require('assert');
+
+/**
+ * @mixin
+ * @alias actions/fs
+ */
+const fs = module.exports;
+
+/**
+ * Read file from templates folder.
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.read(this.templatePath(filepath))
+ *
+ * @param {String} filepath - absolute file path or relative to templates folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.readTemplate = function(filepath, ...args) {
+  return this.fs.read(this.templatePath(filepath), ...args);
+};
+
+/**
+ * Copy file from templates folder to destination folder.
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.copy(this.templatePath(from), this.destinationPath(to))
+ *
+ * @param {String} from - absolute file path or relative to templates folder.
+ * @param {String} to - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.copyTemplate = function(from, to, ...args) {
+  return this.fs.copy(this.templatePath(from), this.destinationPath(to), ...args);
+};
+
+/**
+ * Read file from destination folder
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.read(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.readDestination = function(filepath, ...args) {
+  return this.fs.read(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Read JSON file from destination folder
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.readJSON(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.readDestinationJSON = function(filepath, ...args) {
+  return this.fs.readJSON(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Write file to destination folder
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.write(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.writeDestination = function(filepath, ...args) {
+  return this.fs.write(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Write json file to destination folder
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.writeJSON(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.writeDestinationJSON = function(filepath, ...args) {
+  return this.fs.writeJSON(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Delete file from destination folder
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.delete(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.deleteDestination = function(filepath, ...args) {
+  return this.fs.delete(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Copy file from destination folder to another destination folder.
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.copy(this.destinationPath(from), this.destinationPath(to)).
+ *
+ * @param {String} from - absolute file path or relative to destination folder.
+ * @param {String} to - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.copyDestination = function(from, to, ...args) {
+  return this.fs.copy(this.destinationPath(from), this.destinationPath(to), ...args);
+};
+
+/**
+ * Move file from destination folder to another destination folder.
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.move(this.destinationPath(from), this.destinationPath(to)).
+ *
+ * @param {String} from - absolute file path or relative to destination folder.
+ * @param {String} to - absolute file path or relative to destination folder.
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.moveDestination = function(from, to, ...args) {
+  return this.fs.move(this.destinationPath(from), this.destinationPath(to), ...args);
+};
+
+/**
+ * Exists file on destination folder.
+ * mem-fs-editor method's shortcut, for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}.
+ * Shortcut for this.fs.exists(this.destinationPath(filepath)).
+ *
+ * @param {String} filepath - absolute file path or relative to destination folder.
+ * @param {...*} args - for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ * @returns {*} for more information see [mem-fs-editor]{@link https://github.com/SBoudrias/mem-fs-editor}
+ */
+fs.existsDestination = function(filepath, ...args) {
+  return this.fs.exists(this.destinationPath(filepath), ...args);
+};
+
+/**
+ * Copy a template from templates folder to the destination.
+ *
+ * @param  {String|Array} source - template file, absolute or relative to templatePath().
+ * @param  {String|Array} [destination] - destination, absolute or relative to destinationPath().
+ * @param {Object} [templateData] - ejs data
+ * @param {Object} [templateOptions] - ejs options
+ * @param {Object} [copyOptions] - mem-fs-editor copy options
+ */
+fs.renderTemplate = function(
+  source = '',
+  destination = source,
+  templateData = this._templateData(),
+  templateOptions,
+  copyOptions
+) {
+  if (typeof templateData === 'string') {
+    templateData = this._templateData(templateData);
+  }
+
+  templateOptions = { context: this, ...templateOptions };
+
+  source = Array.isArray(source) ? source : [source];
+  const templatePath = this.templatePath(...source);
+  destination = Array.isArray(destination) ? destination : [destination];
+  const destinationPath = this.destinationPath(...destination);
+
+  this.fs.copyTpl(
+    templatePath,
+    destinationPath,
+    templateData,
+    templateOptions,
+    copyOptions
+  );
+};
+
+/**
+ * Copy templates from templates folder to the destination.
+ *
+ * @param  {Array} templates - template file, absolute or relative to templatePath().
+ * @param  {function} [templates.when] - conditional if the template should be written.
+ *                                       First argument is the templateData, second is the generator.
+ * @param  {String|Array} templates.source - template file, absolute or relative to templatePath().
+ * @param  {String|Array} [templates.destination] - destination, absolute or relative to destinationPath().
+ * @param {Object} [templates.templateOptions] - ejs options
+ * @param {Object} [templates.copyOptions] - mem-fs-editor copy options
+ * @param {Object} [templateData] - ejs data
+ */
+fs.renderTemplates = function(templates, templateData = this._templateData()) {
+  assert(Array.isArray(templates), 'Templates must an array');
+  if (typeof templateData === 'string') {
+    templateData = this._templateData(templateData);
+  }
+
+  const self = this;
+  const renderEachTemplate = template => {
+    if (template.when && !template.when(templateData, this)) {
+      return;
+    }
+
+    const { source, destination, templateOptions, copyOptions } = template;
+    self.renderTemplate(source, destination, templateData, templateOptions, copyOptions);
+  };
+
+  templates.forEach(template => renderEachTemplate(template));
+};
+
+/**
+ * Utility method to get a formatted data for templates.
+ *
+ * @param {String} path - path to the storage key.
+ * @return {Object} data to be passed to the templates.
+ */
+fs._templateData = function(path) {
+  if (path) {
+    return this.config.getPath(path);
+  }
+
+  const allConfig = this.config.getAll();
+  if (this.generatorConfig) {
+    Object.assign(allConfig, this.generatorConfig.getAll());
+  }
+
+  if (this.instanceConfig) {
+    Object.assign(allConfig, this.instanceConfig.getAll());
+  }
+
+  return allConfig;
+};

package/lib/actions/install.js

@@ -110,7 +110,7 @@ install.scheduleInstallTask = function(installer, paths, options, spawnOptions)
  *   npm: false
  * });
  *
- * @param {Object} [options]
+ * @param {Object} [options] - 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

package/lib/index.js

@@ -21,11 +21,11 @@ const promptSuggestion = require('./util/prompt-suggestion');
 
 const EMPTY = '@@_YEOMAN_EMPTY_MARKER_@@';
 const debug = createDebug('yeoman:generator');
-const ENV_VER_WITH_VER_API = '3.0.0';
+const ENV_VER_WITH_VER_API = '2.9.0';
 
 // Ensure a prototype method is a candidate run by default
 const methodIsValid = function(name) {
-  return name.charAt(0) !== '_' && name !== 'constructor';
+  return !['_', '#'].includes(name.charAt(0)) && name !== 'constructor';
 };
 
 // New runWithOptions should take precedence if exists.
@@ -98,6 +98,7 @@ class Generator extends EventEmitter {
     ];
   }
 
+  /* eslint-disable complexity */
   /**
    * @classdesc The `Generator` class provides the common API shared by all generators.
    * It define options, arguments, file, prompt, log, API, etc.
@@ -111,6 +112,7 @@ class Generator extends EventEmitter {
    * @mixes actions/install
    * @mixes actions/spawn-command
    * @mixes actions/user
+   * @mixes actions/fs
    * @mixes nodejs/EventEmitter
    *
    * @param {string[]} args           - Provide arguments at initialization
@@ -147,8 +149,11 @@ class Generator extends EventEmitter {
     this._args = args || [];
     this._options = {};
     this._arguments = [];
+    this._prompts = [];
     this._composedWith = [];
     this._transformStreams = [];
+    this._namespace = this.options.namespace;
+    this._namespaceId = this.options.namespaceId;
 
     this.option('help', {
       type: Boolean,
@@ -174,6 +179,12 @@ class Generator extends EventEmitter {
       default: false
     });
 
+    this.option('ask-answered', {
+      type: Boolean,
+      description: 'Show prompts for already configured options',
+      default: false
+    });
+
     this.resolved = this.options.resolved || __dirname;
     this.env = this.options.env;
 
@@ -210,13 +221,7 @@ class Generator extends EventEmitter {
       }
     }
 
-    try {
-      this.fs = this.env.fs || require('mem-fs-editor').create(this.env.sharedFs);
-    } catch (_) {
-      throw new Error(
-        "Current environment don't provides some necessary feature this generator needs"
-      );
-    }
+    this.fs = require('mem-fs-editor').create(this.env.sharedFs);
 
     this.description = this.description || '';
 
@@ -266,6 +271,15 @@ class Generator extends EventEmitter {
 
     this.appname = this.determineAppname();
     this.config = this._getStorage();
+    if (this._namespaceId && this._namespaceId.generator) {
+      this.generatorConfig = this.config.createStorage(`:${this._namespaceId.generator}`);
+      if (this._namespaceId.instanceId) {
+        this.instanceConfig = this.generatorConfig.createStorage(
+          `#${this._namespaceId.instanceId}`
+        );
+      }
+    }
+
     this._globalConfig = this._getGlobalStorage();
 
     // Ensure source/destination path, can be configured from subclasses
@@ -368,6 +382,11 @@ class Generator extends EventEmitter {
         this.env.runLoop.addSubQueue(customQueue.queueName, beforeQueue);
       });
     }
+
+    this.compose = this.options.compose;
+
+    // Expose utilities for dependency-less generators.
+    this._ = _;
   }
 
   checkEnvironmentVersion(packageDependency, version) {
@@ -423,6 +442,48 @@ class Generator extends EventEmitter {
     this._debug(...args);
   }
 
+  /**
+   * Register stored config prompts and optional option alternative.
+   *
+   * @param {Inquirer|Inquirer[]} questions - Inquirer question or questions.
+   * @param {Object|Boolean} [questions.exportOption] - Additional data to export this question as an option.
+   * @param {Storage|String} [question.storage=this.config] - Storage to store the answers.
+   */
+  registerConfigPrompts(questions) {
+    questions = Array.isArray(questions) ? questions : [questions];
+    const getOptionTypeFromInquirerType = type => {
+      if (type === 'number') {
+        return Number;
+      }
+
+      if (type === 'confirm') {
+        return Boolean;
+      }
+
+      if (type === 'checkbox') {
+        return Array;
+      }
+
+      return String;
+    };
+
+    questions.forEach(q => {
+      const question = { ...q };
+      if (q.exportOption) {
+        let option = typeof q.exportOption === 'boolean' ? {} : q.exportOption;
+        this.option({
+          name: q.name,
+          type: getOptionTypeFromInquirerType(q.type),
+          description: q.message,
+          ...option,
+          storage: q.storage || this.config
+        });
+      }
+
+      this._prompts.push(question);
+    });
+  }
+
   /**
    * Prompt user to answer questions. The signature of this method is the same as {@link https://github.com/SBoudrias/Inquirer.js Inquirer.js}
    *
@@ -430,17 +491,79 @@ class Generator extends EventEmitter {
    * every question descriptor. When set to true, Yeoman will store/fetch the
    * user's answers as defaults.
    *
-   * @param  {array} questions  Array of question descriptor objects. See {@link https://github.com/SBoudrias/Inquirer.js/blob/master/README.md Documentation}
+   * @param  {object|object[]} questions  Array of question descriptor objects. See {@link https://github.com/SBoudrias/Inquirer.js/blob/master/README.md Documentation}
+   * @param  {Storage} [questions.storage] Store/fetch the question on the storage.
+   * @param  {Storage} [storage] Storage object
    * @return {Promise} prompt promise
    */
-  prompt(questions) {
+  prompt(questions, storage) {
+    const checkInquirer = () => {
+      if (this.inquireSupportsPrefilled === undefined) {
+        this.checkEnvironmentVersion();
+        this.inquireSupportsPrefilled = this.checkEnvironmentVersion('inquirer', '7.1.0');
+      }
+    };
+
+    if (storage !== undefined) {
+      checkInquirer();
+    }
+
+    const storageForQuestion = {};
+
+    const getAnswerFromStorage = function(question) {
+      let questionStorage = question.storage || storage;
+      questionStorage =
+        typeof questionStorage === 'string' ? this[questionStorage] : questionStorage;
+      if (questionStorage) {
+        checkInquirer();
+
+        const name = question.name;
+        storageForQuestion[name] = questionStorage;
+        const value = questionStorage.getPath(name);
+        if (value !== undefined) {
+          question.default = value;
+        }
+
+        return [name, value];
+      }
+
+      return undefined;
+    };
+
+    if (!Array.isArray(questions)) {
+      questions = [questions];
+    }
+
+    // Shows the prompt even if the answer already exists.
+    questions.forEach(question => {
+      if (question.askAnswered === undefined) {
+        question.askAnswered = this.options.askAnswered === true;
+      }
+    });
+
+    // Pre-fill answers with storage values.
+    const answers = {};
+    questions
+      .map(getAnswerFromStorage)
+      .filter(a => a)
+      .forEach(([key, value]) => {
+        answers[key] = value;
+      });
+
     questions = promptSuggestion.prefillQuestions(this._globalConfig, questions);
     questions = promptSuggestion.prefillQuestions(this.config, questions);
 
-    return this.env.adapter.prompt(questions).then(answers => {
+    return this.env.adapter.prompt(questions, answers).then(answers => {
+      Object.entries(storageForQuestion).forEach(([name, questionStorage]) => {
+        const answer = answers[name] === undefined ? null : answers[name];
+        questionStorage.setPath(name, answer);
+      });
+
       if (!this.options['skip-cache'] && !this.options.skipCache) {
         promptSuggestion.storeAnswers(this._globalConfig, questions, answers, false);
-        promptSuggestion.storeAnswers(this.config, questions, answers, true);
+        if (!this.options.skipLocalCache) {
+          promptSuggestion.storeAnswers(this.config, questions, answers, true);
+        }
       }
 
       return answers;
@@ -452,16 +575,29 @@ class Generator extends EventEmitter {
    * generate generator usage. By default, generators get all the cli options
    * parsed by nopt as a `this.options` hash object.
    *
-   * @param {String} name - Option name
+   * @param {String} [name] - Option name
    * @param {Object} config - Option options
    * @param {any} config.type - Either Boolean, String or Number
    * @param {string} [config.description] - Description for the option
    * @param {any} [config.default] - Default value
    * @param {any} [config.alias] - Option name alias (example `-h` and --help`)
    * @param {any} [config.hide] - Boolean whether to hide from help
+   * @param {Storage} [config.storage] - Storage to persist the option
    * @return {this} This generator
    */
   option(name, config) {
+    if (Array.isArray(name)) {
+      name.forEach(option => {
+        this.option(option);
+      });
+      return;
+    }
+
+    if (typeof name === 'object') {
+      config = name;
+      name = config.name;
+    }
+
     config = config || {};
 
     // Alias default to defaults for backward compatibility.
@@ -500,6 +636,12 @@ class Generator extends EventEmitter {
     }
 
     this.parseOptions();
+    if (config.storage && this.options[name] !== undefined) {
+      const storage =
+        typeof config.storage === 'string' ? this[config.storage] : config.storage;
+      storage.set(name, this.options[name]);
+    }
+
     return this;
   }
 
@@ -703,6 +845,84 @@ class Generator extends EventEmitter {
     });
   }
 
+  /**
+   * @private
+   * Schedule a generator's method on a run queue.
+   *
+   * @param {String}  name: The method name to schedule.
+   * @param {TaskOptions} [taskOptions]: options.
+   */
+  queueOwnTask(name, taskOptions = {}) {
+    const property = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), name);
+    const item = property.value ? property.value : property.get.call(this);
+
+    const priority = this._queues[name];
+    taskOptions = {
+      ...priority,
+      cancellable: true,
+      run: false,
+      ...taskOptions
+    };
+
+    // Name points to a function; run it!
+    if (typeof item === 'function') {
+      taskOptions.taskName = name;
+      taskOptions.method = item;
+      this.queueTask(taskOptions);
+      return;
+    }
+
+    // Not a queue hash; stop
+    if (!priority) {
+      return;
+    }
+
+    this.queueTaskGroup(item, taskOptions);
+  }
+
+  /**
+   * @private
+   * Schedule every generator's methods on a run queue.
+   *
+   * @param {TaskOptions} [taskOptions]: options.
+   */
+  queueOwnTasks(taskOptions) {
+    this._running = true;
+    this._taskStatus = { cancelled: false, timestamp: new Date() };
+
+    const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(this));
+    const validMethods = methods.filter(methodIsValid);
+    if (validMethods.length === 0 && this._prompts.length === 0) {
+      const error = new Error(
+        'This Generator is empty. Add at least one method for it to run.'
+      );
+      this.emit('error', error);
+      throw error;
+    }
+
+    if (this._prompts.length > 0) {
+      this.queueTask({
+        method: () => this.prompt(this._prompts, this.config),
+        taskName: 'Prompt registered questions',
+        queueName: 'prompting',
+        cancellable: true
+      });
+
+      if (validMethods.length === 0) {
+        this.queueTask({
+          method: () => {
+            this.renderTemplate();
+          },
+          taskName: 'Empty generator: copy templates',
+          queueName: 'writing',
+          cancellable: true
+        });
+      }
+    }
+
+    validMethods.forEach(methodName => this.queueOwnTask(methodName, taskOptions));
+  }
+
   /**
    * Schedule tasks on a run queue.
    *
@@ -730,6 +950,10 @@ class Generator extends EventEmitter {
       namespace = self.options.namespace;
     }
 
+    // Task status allows to ignore (cancel) current queued tasks.
+    // Each queueOwnTasks (complete run) create a new taskStatus.
+    const taskStatus = this._taskStatus || {};
+
     debug(
       `Queueing ${namespace}#${methodName} with options %o`,
       _.omit(task, ['method'])
@@ -740,23 +964,18 @@ class Generator extends EventEmitter {
       continueQueue => {
         debug(`Running ${namespace}#${methodName}`);
         self.emit(`method:${methodName}`);
-        const taskCancelled = task.cancellable && !self._running;
+        const taskCancelled = task.cancellable && taskStatus.cancelled;
+        if (taskCancelled) {
+          continueQueue();
+          return;
+        }
 
         runAsync(function() {
-          if (taskCancelled) {
-            return Promise.resolve();
-          }
-
           self.async = () => this.async();
           self.runningState = { namespace, queueName, methodName };
           return method.apply(self, self.args);
         })()
           .then(function() {
-            if (taskCancelled) {
-              continueQueue();
-              return;
-            }
-
             delete self.runningState;
             const eventName = `done$${namespace || 'unknownnamespace'}#${methodName}`;
             debug(`Emiting event ${eventName}`);
@@ -798,6 +1017,21 @@ class Generator extends EventEmitter {
    */
   cancelCancellableTasks() {
     this._running = false;
+    // Task status references is registered at each running task
+    this._taskStatus.cancelled = true;
+    // Create a new task status.
+    delete this._taskStatus;
+  }
+
+  /**
+   * Start the generator again.
+   *
+   * @param {Object} [options]: options.
+   */
+  startOver(options = {}) {
+    this.cancelCancellableTasks();
+    Object.assign(this.options, options);
+    this.queueOwnTasks();
   }
 
   /**
@@ -853,8 +1087,6 @@ class Generator extends EventEmitter {
     }
 
     const promise = new Promise((resolve, reject) => {
-      const self = this;
-      this._running = true;
       this.debug('Generator is starting');
       this.emit('run');
 
@@ -868,74 +1100,20 @@ class Generator extends EventEmitter {
         this.on('error', reject);
       }
 
-      const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(this));
-      const validMethods = methods.filter(methodIsValid);
-      if (!validMethods.length) {
-        return this.emit(
-          'error',
-          new Error('This Generator is empty. Add at least one method for it to run.')
-        );
-      }
-
       this.env.runLoop.once('end', () => {
         this.debug('Generator has ended');
         this.emit('end');
         resolve();
       });
 
-      function addInQueue(name) {
-        const property = Object.getOwnPropertyDescriptor(
-          Object.getPrototypeOf(self),
-          name
-        );
-        const item = property.value ? property.value : property.get.call(self);
-
-        const priority = self._queues[name];
-        let taskOptions = {
-          ...priority,
-          cancellable: true,
-          run: false,
-          generatorReject: usePromise ? undefined : reject
-        };
-
-        // Name points to a function; run it!
-        if (typeof item === 'function') {
-          taskOptions.taskName = name;
-          taskOptions.method = item;
-          return self.queueTask(taskOptions);
-        }
-
-        // Not a queue hash; stop
-        if (!priority) {
-          return;
-        }
-
-        self.queueTaskGroup(item, taskOptions);
-      }
-
-      validMethods.forEach(addInQueue);
-
-      const writeFiles = () => {
-        this.env.runLoop.add('conflicts', this._writeFiles.bind(this), {
-          once: 'write memory fs to disk'
-        });
-      };
-
-      this.env.sharedFs.on('change', writeFiles);
-      writeFiles();
-
-      // Add the default conflicts handling
-      this.env.runLoop.add('conflicts', done => {
-        this.conflicter.resolve(err => {
-          if (err) {
-            return this.emit('error', err);
-          }
-
-          done();
-        });
+      this.queueOwnTasks({
+        generatorReject: usePromise ? undefined : reject
       });
 
+      this.queueBasicTasks();
+
       this._composedWith.forEach(runGenerator);
+      this._composedWith = [];
     });
 
     // For composed generators, otherwise error will not be catched.
@@ -948,6 +1126,31 @@ class Generator extends EventEmitter {
     return promise;
   }
 
+  /**
+   * Queue generator's basic tasks, only once execution is required for each environment.
+   */
+  queueBasicTasks() {
+    const writeFiles = () => {
+      this.env.runLoop.add('conflicts', this._writeFiles.bind(this), {
+        once: 'write memory fs to disk'
+      });
+    };
+
+    this.env.sharedFs.on('change', writeFiles);
+    writeFiles();
+
+    // Add the default conflicts handling
+    this.env.runLoop.add('conflicts', done => {
+      this.conflicter.resolve(err => {
+        if (err) {
+          return this.emit('error', err);
+        }
+
+        done();
+      });
+    });
+  }
+
   /**
    * Compose this generator with another one.
    * @param  {String|Object|Array} generator  The path to the generator module or an object (see examples)
@@ -975,7 +1178,9 @@ class Generator extends EventEmitter {
     let instantiatedGenerator;
 
     if (Array.isArray(generator)) {
-      const generators = generator.map(gen => this.composeWith(gen, options));
+      const generators = generator.map(gen =>
+        this.composeWith(gen, options, returnNewGenerator)
+      );
       return returnCompose(generators);
     }
 
@@ -1005,6 +1210,7 @@ class Generator extends EventEmitter {
         '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'],
+        skipLocalCache: this.options.skipLocalCache,
         destinationRoot: this._destinationRoot
       },
       options
@@ -1292,6 +1498,7 @@ class Generator extends EventEmitter {
 _.extend(Generator.prototype, require('./actions/install'));
 _.extend(Generator.prototype, require('./actions/help'));
 _.extend(Generator.prototype, require('./actions/spawn-command'));
+_.extend(Generator.prototype, require('./actions/fs'));
 Generator.prototype.user = require('./actions/user');
 
 module.exports = Generator;

package/lib/util/storage.js

@@ -2,6 +2,32 @@
 const assert = require('assert');
 const _ = require('lodash');
 
+/**
+ * Proxy handler for Storage
+ */
+const proxyHandler = {
+  get(storage, property) {
+    return storage.get(property);
+  },
+  set(storage, property, value) {
+    storage.set(property, value);
+    return true;
+  },
+  ownKeys(storage) {
+    return Reflect.ownKeys(storage._store);
+  },
+  has(target, prop) {
+    return target.get(prop) !== undefined;
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return {
+      get: () => this.get(target, key),
+      enumerable: true,
+      configurable: true
+    };
+  }
+};
+
 /**
  * Storage instances handle a json file where Generator authors can store data.
  *
@@ -11,7 +37,10 @@ const _ = require('lodash');
  * @param {String} [name]     The name of the new storage (this is a namespace)
  * @param {mem-fs-editor} fs  A mem-fs editor instance
  * @param {String} configPath The filepath used as a storage.
- * @param {Boolean} lodashPath Set true to treat name as a lodash path.
+ * @param {Object} [options] Storage options.
+ * @param {Boolean} [options.lodashPath=false] Set true to treat name as a lodash path.
+ * @param {Boolean} [options.disableCache=false] Set true to disable json object cache.
+ * @param {Boolean} [options.disableCacheByFile=false] Set true to cleanup cache for every fs change.
  *
  * @example
  * class extend Generator {
@@ -21,21 +50,43 @@ const _ = require('lodash');
  * }
  */
 class Storage {
-  constructor(name, fs, configPath, lodashPath = false) {
+  constructor(name, fs, configPath, options = {}) {
     if (name !== undefined && typeof name !== 'string') {
       configPath = fs;
       fs = name;
       name = undefined;
     }
 
+    if (typeof options === 'boolean') {
+      options = { lodashPath: options };
+    }
+
+    _.defaults(options, {
+      lodash: false,
+      disableCache: false,
+      disableCacheByFile: false
+    });
+
     assert(configPath, 'A config filepath is required to create a storage');
 
     this.path = configPath;
     this.name = name;
     this.fs = fs;
-    this.existed = Object.keys(this._store).length > 0;
     this.indent = 2;
-    this.lodashPath = lodashPath;
+    this.lodashPath = options.lodashPath;
+    this.disableCache = options.disableCache;
+    this.disableCacheByFile = options.disableCacheByFile;
+
+    this.existed = Object.keys(this._store).length > 0;
+
+    this.fs.store.on('change', filename => {
+      // At mem-fs 1.1.3 filename is not passed to the event.
+      if (this.disableCacheByFile || (filename && filename !== this.path)) {
+        return;
+      }
+
+      delete this._cachedStore;
+    });
   }
 
   /**
@@ -44,7 +95,11 @@ class Storage {
    * @private
    */
   get _store() {
-    const store = this.fs.readJSON(this.path, {});
+    const store = this._cachedStore || this.fs.readJSON(this.path, {});
+    if (!this.disableCache) {
+      this._cachedStore = store;
+    }
+
     if (!this.name) {
       return store || {};
     }
@@ -164,6 +219,24 @@ class Storage {
     this.set(val);
     return val;
   }
+
+  /**
+   * Create a child storage.
+   * @param  {String} path - relative path of the key to create a new storage.
+   * @return {Storage} Returns a new Storage.
+   */
+  createStorage(path) {
+    const childName = this.name ? `${this.name}.${path}` : path;
+    return new Storage(childName, this.fs, this.path, true);
+  }
+
+  /**
+   * Creates a proxy object.
+   * @return {Object} proxy.
+   */
+  createProxy() {
+    return new Proxy(this, proxyHandler);
+  }
 }
 
 module.exports = Storage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-generator",
-  "version": "4.8.3",
+  "version": "4.11.0",
   "description": "Rails-inspired generator system that provides scaffolding for your apps",
   "homepage": "http://yeoman.io",
   "author": "Yeoman",
@@ -31,6 +31,7 @@
     "inquirer": "^6.3.1",
     "jsdoc": "^3.6.3",
     "lint-staged": "^8.1.7",
+    "mem-fs": "^1.2.0",
     "mocha": "^7.1.1",
     "mockery": "^2.1.0",
     "nock": "^12.0.3",
@@ -40,7 +41,7 @@
     "sinon": "^7.3.2",
     "tui-jsdoc-template": "^1.2.2",
     "yeoman-assert": "^3.1.1",
-    "yeoman-test": "^2.3.0"
+    "yeoman-test": "^2.6.0"
   },
   "license": "BSD-2-Clause",
   "repository": "yeoman/generator",
@@ -68,6 +69,7 @@
     "istextorbinary": "^2.5.1",
     "lodash": "^4.17.11",
     "make-dir": "^3.0.0",
+    "mem-fs-editor": "^7.0.1",
     "minimist": "^1.2.5",
     "pretty-bytes": "^5.2.0",
     "read-chunk": "^3.2.0",
@@ -81,8 +83,7 @@
   },
   "optionalDependencies": {
     "grouped-queue": "^1.1.0",
-    "mem-fs-editor": "^6.0.0",
-    "yeoman-environment": "^2.3.4"
+    "yeoman-environment": "^2.9.5"
   },
   "lint-staged": {
     "*.js": [