yeoman-environment 2.5.0 → 2.6.0

package/lib/adapter.js

@@ -53,9 +53,14 @@ class TerminalAdapter {
    *
    * @param {string} actual
    * @param {string} expected
+   * @param {Array} changes returned by diff.
    */
-  diff(actual, expected) {
-    let msg = diff.diffLines(actual, expected).map(str => {
+  diff(actual, expected, changes) {
+    if (Array.isArray(actual)) {
+      changes = actual;
+    }
+    changes = changes || diff.diffLines(actual, expected);
+    let msg = changes.map(str => {
       if (str.added) {
         return this._colorLines('Added', str.value);
       }

package/lib/environment.js

@@ -159,14 +159,22 @@ class Environment extends EventEmitter {
    * Lookup for a specific generator.
    *
    * @param  {String} namespace
+   * @param  {Object} [options]
+   * @param {Boolean|Object} [options.localOnly=false] - Set true to skip lookups of
+   *                                                     globally-installed generators.
+   * @param {Boolean|Object} [options.packagePath=false] - Set true to return the package
+   *                                                       path instead of generators file.
    * @return {String} generator
    */
-  static lookupGenerator(namespace, localOnly = false) {
+  static lookupGenerator(namespace, options = {}) {
+    if (typeof options === 'boolean') {
+      options = {localOnly: options};
+    }
     const name = Environment.namespaceToName(namespace);
     const generatorHint = getGeneratorHint(name);
     const envProt = Environment.prototype;
 
-    const generatorsModules = envProt.findGeneratorsIn(envProt.getNpmPaths(localOnly).reverse(), generatorHint);
+    const generatorsModules = envProt.findGeneratorsIn(envProt.getNpmPaths(options.localOnly).reverse(), generatorHint);
     const patterns = [];
 
     for (const lookup of Environment.lookups) {
@@ -178,6 +186,9 @@ class Environment extends EventEmitter {
     for (const pattern of patterns) {
       for (const filename of globby.sync('*/index.js', {cwd: pattern, absolute: true, deep: 1})) {
         if (namespace === envProt.namespace(filename, Environment.lookups)) {
+          if (options.packagePath) {
+            return pattern;
+          }
           return filename;
         }
       }
@@ -283,9 +294,10 @@ class Environment extends EventEmitter {
    *
    * @param  {String} name      - Filepath to the a generator or a npm package name
    * @param  {String} namespace - Namespace under which register the generator (optional)
-   * @return {String} namespace - Namespace assigned to the registered generator
+   * @param  {String} packagePath - PackagePath to the generator npm package (optional)
+   * @return {Object} environment - This environment
    */
-  register(name, namespace) {
+  register(name, namespace, packagePath) {
     if (typeof name !== 'string') {
       return this.error(new Error('You must provide a generator name to register.'));
     }
@@ -297,9 +309,12 @@ class Environment extends EventEmitter {
       return this.error(new Error('Unable to determine namespace.'));
     }
 
-    this.store.add(namespace, modulePath);
+    this.store.add(namespace, modulePath, undefined, packagePath);
+    if (packagePath) {
+      this.store.addPackage(Environment.namespaceToName(namespace), packagePath);
+    }
 
-    debug('Registered %s (%s)', namespace, modulePath);
+    debug('Registered %s (%s) on package (%s)', namespace, modulePath, packagePath);
     return this;
   }
 
@@ -311,9 +326,10 @@ class Environment extends EventEmitter {
    * @param  {Function} Generator  - A Generator constructor or a simple function
    * @param  {String}   namespace  - Namespace under which register the generator
    * @param  {String}   [resolved] - The file path to the generator
+   * @param  {String} [packagePath] - The generator's package path
    * @return {this}
    */
-  registerStub(Generator, namespace, resolved) {
+  registerStub(Generator, namespace, resolved, packagePath) {
     if (typeof Generator !== 'function') {
       return this.error(new Error('You must provide a stub function to register.'));
     }
@@ -322,8 +338,12 @@ class Environment extends EventEmitter {
       return this.error(new Error('You must provide a namespace to register.'));
     }
 
-    this.store.add(namespace, Generator, resolved);
+    this.store.add(namespace, Generator, resolved, packagePath);
+    if (packagePath) {
+      this.store.addPackage(Environment.namespaceToName(namespace), packagePath);
+    }
 
+    debug('Registered %s (%s) on package (%s)', namespace, resolved, packagePath);
     return this;
   }
 
@@ -352,6 +372,32 @@ class Environment extends EventEmitter {
     return _.uniq(Object.keys(this.getGeneratorsMeta()).map(Environment.namespaceToName));
   }
 
+  /**
+   * Get last added path for a namespace
+   *
+   * @param  {String} - namespace
+   * @return {String} - path of the package
+   */
+  getPackagePath(namespace) {
+    if (namespace.includes(':')) {
+      const generator = this.get(namespace) || {};
+      return generator.packagePath;
+    }
+    const packagePaths = this.getPackagePaths(namespace) || [];
+    return packagePaths[0];
+  }
+
+  /**
+   * Get paths for a namespace
+   *
+   * @param  {String} - namespace
+   * @return  {Array} - array of paths.
+   */
+  getPackagePaths(namespace) {
+    return this.store.getPackagesPaths()[namespace] ||
+      this.store.getPackagesPaths()[Environment.namespaceToName(this.alias(namespace))];
+  }
+
   /**
    * Get a single generator from the registered list of generators. The lookup is
    * based on generator's namespace, "walking up" the namespaces until a matching

package/lib/resolver.js

@@ -41,17 +41,13 @@ resolver.lookup = function (localOnly = false, cb) {
   }
 
   const generatorsModules = this.findGeneratorsIn(this.getNpmPaths(localOnly).reverse());
-  const patterns = [];
 
   for (const lookup of this.lookups) {
     for (const modulePath of generatorsModules) {
-      patterns.push(path.join(modulePath, lookup));
-    }
-  }
-
-  for (const pattern of patterns) {
-    for (const filename of globby.sync('*/index.js', {cwd: pattern, absolute: true, deep: 1})) {
-      this._tryRegistering(filename);
+      const pattern = path.join(modulePath, lookup);
+      for (const filename of globby.sync('*/index.js', {cwd: pattern, absolute: true, deep: 1})) {
+        this._tryRegistering(filename, modulePath);
+      }
     }
   }
 
@@ -112,7 +108,7 @@ resolver.findGeneratorsIn = function (searchPaths, pattern = 'generator-*') {
  * @private
  * @param  {String} generatorReference A generator reference, usually a file path.
  */
-resolver._tryRegistering = function (generatorReference) {
+resolver._tryRegistering = function (generatorReference, packagePath) {
   let namespace;
   const realPath = fs.realpathSync(generatorReference);
 
@@ -123,7 +119,7 @@ resolver._tryRegistering = function (generatorReference) {
       namespace = this.namespace(generatorReference);
     }
 
-    this.register(realPath, namespace);
+    this.register(realPath, namespace, packagePath);
   } catch (err) {
     console.error('Unable to register %s (Error: %s)', generatorReference, err.message);
   }

package/lib/store.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const debug = require('debug')('yeoman:environment:store');
+
 /**
  * The Generator store
  * This is used to store generator (npm packages) reference and instantiate them when
@@ -11,27 +13,31 @@ class Store {
   constructor() {
     this._generators = {};
     this._meta = {};
+    // Store packages paths by ns
+    this._packagesPaths = {};
   }
 
   /**
    * Store a module under the namespace key
    * @param {String}          namespace  - The key under which the generator can be retrieved
    * @param {String|Function} generator  - A generator module or a module path
+   * @param {String}         packagePath - PackagePath to the generator npm package (optional)
    * @param {String}          [resolved] - The file path to the generator (used only if generator is a module)
    */
-  add(namespace, generator, resolved) {
+  add(namespace, generator, resolved, packagePath) {
     if (typeof generator === 'string') {
-      this._storeAsPath(namespace, generator);
+      this._storeAsPath(namespace, generator, packagePath);
       return;
     }
 
-    this._storeAsModule(namespace, generator, resolved);
+    this._storeAsModule(namespace, generator, resolved, packagePath);
   }
 
-  _storeAsPath(namespace, path) {
+  _storeAsPath(namespace, path, packagePath) {
     this._meta[namespace] = {
       resolved: path,
-      namespace
+      namespace,
+      packagePath
     };
 
     Object.defineProperty(this._generators, namespace, {
@@ -44,10 +50,11 @@ class Store {
     });
   }
 
-  _storeAsModule(namespace, Generator, resolved = 'unknown') {
+  _storeAsModule(namespace, Generator, resolved = 'unknown', packagePath) {
     this._meta[namespace] = {
       resolved,
-      namespace
+      namespace,
+      packagePath
     };
 
     this._generators[namespace] = Generator;
@@ -83,6 +90,39 @@ class Store {
   getGeneratorsMeta() {
     return this._meta;
   }
+
+  /**
+   * Store a package under the namespace key
+   * @param {String}     namespace - The key under which the generator can be retrieved
+   * @param {String}          path - The package path
+   * @param {String} [generatorNS] - Namespace of a generator to register.
+   */
+  addPackage(packageNS, packagePath) {
+    if (this._packagesPaths[packageNS]) {
+      // Yo environment allows overriding, so the last added has preference.
+      if (this._packagesPaths[packageNS][0] !== packagePath) {
+        const packagePaths = this._packagesPaths[packageNS];
+        debug('Overriding a package with namespace %s and path %s, with path %s',
+          packageNS, this._packagesPaths[packageNS][0], packagePath);
+        // Remove old packagePath
+        const index = packagePaths.indexOf(packagePath);
+        if (index > -1) {
+          packagePaths.splice(index, 1);
+        }
+        packagePaths.splice(0, 0, packagePath);
+      }
+    } else {
+      this._packagesPaths[packageNS] = [packagePath];
+    }
+  }
+
+  /**
+   * Get the stored packages namespaces with paths.
+   * @return {Object} Stored packages namespaces with paths.
+   */
+  getPackagesPaths() {
+    return this._packagesPaths;
+  }
 }
 
 module.exports = Store;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yeoman-environment",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Handles the lifecyle and bootstrapping of generators in a specific environment",
   "homepage": "http://yeoman.io",
   "author": "Yeoman",