base-generators - npm Package Compare versions

Comparing version 0.1.5 to 0.1.6

index.js

@@ -43,5 +43,8 @@ /*!
       if (!this.task) {
-        this.use(utils.task());
+        this.use(utils.task(this.options));
       }
-      this.use(utils.cwd());
+      if (!this.fns) {
+        this.use(utils.plugin(this.options));
+      }
+      this.use(utils.cwd(this.options));
       this.use(tasks(this.options));
@@ -106,4 +109,6 @@ this.use(cache(this.options));
       debug('registering configfile "%s", at cwd: "%s"', name, opts.cwd);
+      this.createEnv('default', configfile, opts);
+
       var fn = util.configfile(configfile, opts);
-      return this.register(name, fn);
+      return this.base.invoke(fn);
     });
@@ -382,5 +387,7 @@
       if (typeof cb === 'function' && cb.name === 'finishRun') {
-        var gen = this.getGenerator(name);
-        tasks = Array.isArray(tasks) ? tasks : ['default'];
-        return gen.build(tasks, cb);
+        if (typeof name === 'string' && !/\W/.test(name)) {
+          var gen = this.getGenerator(name);
+          tasks = Array.isArray(tasks) ? tasks : ['default'];
+          return gen.build(tasks, cb);
+        }
       }
@@ -400,9 +407,16 @@
 
-      res.generator.build(res.tasks, function(err) {
-        if (err) {
-          generatorError(err, this, name, cb);
-          return;
-        }
-        cb();
-      }.bind(this));
+      var gen = res.generator;
+      var app = this;
+
+      gen.config.process(this.base.cache.config, function(err) {
+        if (err) return cb(err);
+
+        gen.build(res.tasks, function(err) {
+          if (err) {
+            generatorError(err, app, name, cb);
+            return;
+          }
+          cb();
+        });
+      });
     });
@@ -434,2 +448,3 @@
       }
+
       async.eachSeries(util.arrayify(tasks), function(task, next) {
@@ -561,3 +576,3 @@ var args = task.split(':').concat(next);
     msg += 'task: "' + taskName + '" in generator';
-  } else if (app.hasGenerator(name)) {
+  } else if (app.hasGenerator(name) || app.hasConfigfile) {
     msg += 'task';
@@ -564,0 +579,0 @@ } else {

lib/cache.js

@@ -8,5 +8,5 @@ 'use strict';
 var env = require('./env');
+var pristine;
 
-module.exports = function(options) {
-
+module.exports = function(config) {
   return function(app) {
@@ -17,2 +17,3 @@ if (this.isRegistered('generator-cache')) return;
     this.generators = new Cache();
+
     var base = this.base;
@@ -59,2 +60,3 @@ var envCache = {};
       parent = parent || base;
+      utils.define(this, 'parent', parent);
       var generator;
@@ -68,16 +70,28 @@
 
+      generator.isGenerator = true;
+
+      // merge options
+      var opts = utils.extend({}, config, app.base.options, parent.options, generator.options);
+      if (opts.pristine === true) {
+        pristine = true;
+      }
+
       // ensure the `env` plugin is registered on the generator
-      generator.use(env());
+      generator.use(env(opts));
 
+      // set `parent` on the generator instance
       generator.define('parent', parent);
-      generator.isGenerator = true;
+
+      // create `generator.env` object
       if (envCache[name]) {
         generator.env = envCache[name];
       } else {
-        generator.createEnv(name, app.options, fn);
+        generator.createEnv(name, opts, fn);
       }
 
+      // create alias
       var alias = generator.env.alias;
       generator.namespace = toNamespace(parent, alias);
 
+      // create getter for invoking the generator instance
       Object.defineProperty(this, alias, {
@@ -95,2 +109,17 @@ configurable: true,
 
+      // if `pristine` is defined on base.options, parent options will
+      // not be merged onto "child" generators, and parent plugins will
+      // not be run on "child" generators
+      if (pristine !== true) {
+        generator.options = opts;
+        parent.run(generator);
+      }
+
+      parent.emit('generator.set', generator);
+      parent.emit('generator', 'set', generator);
+
+      generator.on('error', function(err) {
+        this.parent.emit('error', this.error(err, generator));
+      }.bind(this));
+
       envCache[name] = generator.env;
@@ -101,52 +130,113 @@ return generator;
     /**
-     * Lookup generator:
-     * - [x] look for registered generator using custom fn
-     * - [x] look for registered generator by alias
-     * - [x] look for registered generator by full name
-     * - [ ] look for globally installed generator
+     * Find a registered generator by searching the following:
+     *   1. look for registered generator by given `name`
+     *   2. look for registered generator by alias
+     *   3. look for registered generator by full name
+     *   4. look for registered generator by basename
+     *   5. look for registered generator by alias dot-notation path
+     *   6. look for registered generator by full name dot-notation path
      */
 
     Cache.prototype.get = function(name, fn) {
-      debug('getting: "%s"', name);
+      debug('generators.get getting "%s"', name);
       fn = fn || utils.identity;
 
-      var generator = this[name];
-      if (generator) {
-        return generator;
+      var alias = fn(name);
+      var fullname = util.toFullname(name, {prefix: app.prefix});
+      var basename = path.basename(name);
+      var aliasPath = util.toGeneratorPath(alias, false);
+      var namePath = util.toGeneratorPath(name, false);
+
+      var names = [name, alias, fullname, basename, aliasPath, namePath];
+      names = utils.unique(names.filter(Boolean));
+
+      var seen = {};
+      var len = names.length;
+      var idx = -1;
+
+      while (++idx < len) {
+        var n = names[idx];
+        debug('generators.get "%s"', n);
+
+        if (getCache[n]) {
+          return getCache[n];
+        }
+
+        if (seen[n]) {
+          continue;
+        }
+        seen[n] = true;
+
+        var generator = this[n] || utils.get(this, n);
+        if (generator) {
+          this.parent.emit('generator.get', generator);
+          this.parent.emit('generator', 'get', generator);
+          return set(n, generator);
+        }
       }
+    };
 
-      var alias = fn(name);
-      generator = this[alias];
-      if (generator) {
-        set(alias, generator);
-        return set(name, generator);
+    Cache.prototype.error = function(error, generator) {
+      if (error.name === 'Error') {
+        return new GeneratorError(error);
       }
 
-      var fullname = util.toFullname(name, {prefix: app.prefix});
-      generator = this[fullname];
-      if (generator) {
-        set(fullname, generator);
-        return set(name, generator);
+      if (error.name === 'ReferenceError') {
+        var stack = error.stack;
+        // console.log(generator.cwd)
       }
 
-      if (typeof generator === 'undefined' && util.exists(name)) {
-        var basename = path.basename(name);
-        app.register(basename, name);
-        generator = utils.get(this, basename);
-        if (generator) {
-          set(basename, generator);
-          return set(name, generator);
+      if (error.name.indexOf('GeneratorError') === 0) {
+        return error;
+      }
+
+      function GeneratorError(err) {
+        this.message = err.message;
+        this.name = 'GeneratorError';
+        this.name += ': generator [' + generator.namespace + '] reason';
+
+        var inst = this;
+
+        try {
+          throw new Error(err.message);
+        } catch (e) {
+          Object.defineProperty(e, 'name', {
+            configurable: true,
+            get: function() {
+              return inst.name;
+            }
+          });
+          this.stack = e.stack;
         }
       }
 
-      generator = utils.get(this, util.toGeneratorPath(name, false));
-      if (generator) {
-        return set(name, generator);
+      GeneratorError.prototype = new Error();
+      GeneratorError.prototype.constructor = GeneratorError;
+      define(GeneratorError.prototype, 'name', function() {
+        return 'GeneratorError';
+      });
+
+      GeneratorError.prototype.inspect = function () {
+        if (this.message) {
+          return '[' + this.constructor.name + ': ' + this.message + ']'
+        }
+        return '[' + this.constructor.name + ']';
+      };
+
+      function define(obj, prop, val) {
+        Object.defineProperty(obj, prop, {
+          configurable: true,
+          set: function(val) {
+            define(obj, prop, val);
+          },
+          get: function() {
+            if (typeof val === 'function') {
+              return val.call(this);
+            }
+            return val;
+          }
+        });
       }
 
-      generator = utils.get(this, util.toGeneratorPath(alias, false));
-      if (generator) {
-        set(alias, generator);
-        return set(name, generator);
-      }
+      return new GeneratorError(error);
     };
@@ -159,1 +249,2 @@ };
 }
+

lib/env.js

@@ -42,2 +42,3 @@ 'use strict';
       env.options = opts;
+      env.configfile = this.configfile;
       env.alias = utils.toAlias(name, opts);
@@ -44,0 +45,0 @@ env.name = utils.toFullname(env.alias, opts);

lib/tasks.js

@@ -24,16 +24,8 @@ 'use strict';
 
-      var res = { tasks: (segs[1] || segs[0]).split(',') };
+      var res = {};
+      res.generator = this;
+      res.tasks = (segs[1] || segs[0]).split(',');
+
       var len = segs.length;
-
-      if (!/\W/.test(prop) && this.hasTask(prop)) {
-        res.generator = this;
-        res.tasks = [prop];
-        return res;
-      }
-
       var gen = this;
-      var def = this.getGenerator('default');
-      if (def) {
-        gen = def;
-      }
 
@@ -48,2 +40,13 @@ var isDefault = res.tasks[0] === 'default';
 
+      if (!/\W/.test(prop) && gen.hasTask(prop)) {
+        res.generator = gen;
+        res.tasks = [prop]
+        return res;
+      }
+
+      var fallback = gen.getGenerator('default');
+      if (fallback) {
+        gen = fallback;
+      }
+
       if (len > 1) {
@@ -71,2 +74,5 @@ res.generator = gen.findGenerator(segs[0]);
       res.generator = gen;
+      if (prop === 'default') {
+        res.tasks = null;
+      }
       return res;
@@ -73,0 +79,0 @@ });

lib/utils.js

@@ -18,4 +18,7 @@ 'use strict';
 require('base-task', 'task');
+require('base-plugins', 'plugin');
+require('define-property', 'define');
 require('get-value', 'get');
 require('extend-shallow', 'extend');
+require('array-unique', 'unique');
 require = fn;
@@ -40,8 +43,8 @@
 
-  var base = app.base || context.base;
-  var env = app.env || context.env;
+  var base = context.base;
+  var env = context.env;
 
   debug('invoking "%s"', env.alias);
   fn.call(context, context, base, env);
-  return context;
+  return app;
 };
@@ -48,0 +51,0 @@

package.json

 {
   "name": "base-generators",
   "description": "Adds project-generator support to your `base` application.",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "homepage": "https://github.com/jonschlinkert/base-generators",
@@ -24,6 +24,9 @@ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "dependencies": {
+    "array-unique": "^0.2.1",
     "async": "^1.5.2",
     "base-cwd": "^0.1.1",
+    "base-plugins": "^0.4.1",
     "base-task": "^0.4.0",
     "debug": "^2.2.0",
+    "define-property": "^0.2.5",
     "extend-shallow": "^2.0.1",
@@ -30,0 +33,0 @@ "generator-util": "^0.2.2",

No alert changes

Improved metrics

Total package byte prevSize

47629

increased by7.79%

Lines of code

929

increased by11.12%

Worsened metrics

Dependency count

11

increased by37.5%

Dependency changes

• + Addedarray-unique@^0.2.1

• + Addedbase-plugins@^0.4.1

• + Addeddefine-property@^0.2.5

• + Addedbase-plugins@0.4.13(transitive)