From af55d7998026b4960450c0cbb9e5a1ac47cb1a22 Mon Sep 17 00:00:00 2001
From: Kyle Anderson <andersonkyle@users.noreply.github.com>
Date: Thu, 19 Oct 2017 15:53:38 -0700
Subject: [PATCH] Save Generator Version in Environment

---
 lib/environment.js |  4 ++--
 lib/resolver.js    | 26 ++++++++++++++++----------
 lib/store.js       | 22 +++++++++++++++-------
 3 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/lib/environment.js b/lib/environment.js
index 58eec896..058396f4 100644
--- a/lib/environment.js
+++ b/lib/environment.js
@@ -219,7 +219,7 @@ class Environment extends EventEmitter {
    * @param  {String} namespace - Namespace under which register the generator (optional)
    * @return {String} namespace - Namespace assigned to the registered generator
    */
-  register(name, namespace) {
+  register(name, namespace, packageJson) {
     if (typeof name !== 'string') {
       return this.error(new Error('You must provide a generator name to register.'));
     }
@@ -231,7 +231,7 @@ class Environment extends EventEmitter {
       return this.error(new Error('Unable to determine namespace.'));
     }
 
-    this.store.add(namespace, modulePath);
+    this.store.add(namespace, modulePath, packageJson);
 
     debug('Registered %s (%s)', namespace, modulePath);
     return this;
diff --git a/lib/resolver.js b/lib/resolver.js
index d1858a4c..18b027fa 100644
--- a/lib/resolver.js
+++ b/lib/resolver.js
@@ -36,14 +36,14 @@ resolver.lookup = function (cb) {
   const patterns = [];
 
   for (const lookup of this.lookups) {
-    for (const modulePath of generatorsModules) {
-      patterns.push(path.join(modulePath, lookup));
+    for (const module of generatorsModules) {
+      patterns.push(Object.assign({}, module, {path: path.join(module.path, lookup)}));
     }
   }
 
   for (const pattern of patterns) {
-    for (const filename of globby.sync('*/index.js', {cwd: pattern})) {
-      this._tryRegistering(path.join(pattern, filename));
+    for (const filename of globby.sync('*/index.js', {cwd: pattern.path})) {
+      this._tryRegistering(Object.assign({}, pattern, {path: path.join(pattern.path, filename)}));
     }
   }
 
@@ -72,7 +72,11 @@ resolver.findGeneratorsIn = function (searchPaths) {
       'generator-*',
       '@*/generator-*'
     ], {cwd: root})
-      .map(match => path.join(root, match))
+      .map(match => {
+        const generatorPath = path.join(root, match);
+        const packageJson = path.join(generatorPath, 'package.json');
+        return {path: generatorPath, packageJson};
+      })
       .concat(modules);
   }
 
@@ -86,16 +90,18 @@ resolver.findGeneratorsIn = function (searchPaths) {
  */
 resolver._tryRegistering = function (generatorReference) {
   let namespace;
-  const realPath = fs.realpathSync(generatorReference);
+  const generatorPath = generatorReference.path;
+  const packageJson = generatorReference.packageJson;
+  const realPath = fs.realpathSync(generatorPath);
 
   try {
-    debug('found %s, trying to register', generatorReference);
+    debug('found %s, trying to register', generatorPath);
 
-    if (realPath !== generatorReference) {
-      namespace = this.namespace(generatorReference);
+    if (realPath !== generatorPath) {
+      namespace = this.namespace(generatorPath);
     }
 
-    this.register(realPath, namespace);
+    this.register(realPath, namespace, packageJson);
   } catch (err) {
     console.error('Unable to register %s (Error: %s)', generatorReference, err.message);
   }
diff --git a/lib/store.js b/lib/store.js
index 83afa8ae..0662210e 100644
--- a/lib/store.js
+++ b/lib/store.js
@@ -18,19 +18,23 @@ class Store {
    * @param {String}          namespace - The key under which the generator can be retrieved
    * @param {String|Function} generator - A generator module or a module path
    */
-  add(namespace, generator) {
+  add(namespace, generator, packageJson) {
     if (typeof generator === 'string') {
-      this._storeAsPath(namespace, generator);
+      this._storeAsPath(namespace, generator, packageJson);
       return;
     }
 
-    this._storeAsModule(namespace, generator);
+    this._storeAsModule(namespace, generator, packageJson);
   }
 
-  _storeAsPath(namespace, path) {
+  _storeAsPath(namespace, path, packageJson) {
     this._meta[namespace] = {
       resolved: path,
-      namespace
+      namespace,
+      packageJson,
+      get version() {
+        return require(packageJson).version;
+      }
     };
 
     Object.defineProperty(this._generators, namespace, {
@@ -43,10 +47,14 @@ class Store {
     });
   }
 
-  _storeAsModule(namespace, Generator) {
+  _storeAsModule(namespace, Generator, packageJson) {
     this._meta[namespace] = {
       resolved: 'unknown',
-      namespace
+      namespace,
+      packageJson,
+      get version() {
+        return require(packageJson).version;
+      }
     };
 
     this._generators[namespace] = Generator;