support named plugins

jonschlinkert · jonschlinkert · commit 06084e39874f · 2017-04-01T15:38:11.000-04:00
(this code was co-written with @doowb in early March)
diff --git a/index.js b/index.js
@@ -1,19 +1,25 @@
 /*!
- * base-plugins <https://github.com/jonschlinkert/base-plugins>
+ * base-plugins <https://github.com/node-base/base-plugins>
  *
- * Copyright (c) 2015, Jon Schlinkert.
- * Licensed under the MIT License.
+ * Copyright (c) 2015, 2017, Jon Schlinkert.
+ * Released under the MIT License.
  */
 
 'use strict';
 
 var isRegistered = require('is-registered');
+var isValid = require('is-valid-instance');
 var define = require('define-property');
 var isObject = require('isobject');
 
 module.exports = function plugin() {
-  return function(app) {
+  return function fn(app) {
     if (isRegistered(app, 'base-plugins')) return;
+
+    /**
+     * Cache plugins
+     */
+
     if (!app.fns) {
       define(app, 'fns', []);
     }
@@ -62,7 +68,15 @@ module.exports = function plugin() {
 
     define(app, 'run', function(val) {
       if (!isObject(val)) return;
-      decorate(val);
+
+      if (!val.use) {
+        define(val, 'fns', val.fns || []);
+        define(val, 'use', use);
+      }
+
+      if (!val.fns || val.fns.indexOf(fn) === -1) {
+        val.use(fn);
+      }
 
       var len = this.fns.length;
       var idx = -1;
@@ -71,34 +85,47 @@ module.exports = function plugin() {
       }
       return this;
     });
-  };
-
-  /**
-   * Prime the `.use` method and `fns`
-   * array on `val`
-   */
 
-  function decorate(val) {
-    if (!val.use) {
-      define(val, 'fns', val.fns || []);
-      define(val, 'use', use);
-      val.use(plugin());
-    }
-  }
+    return fn;
+  };
 
   /**
    * Call plugin `fn`. If a function is returned push it into the
    * `fns` array to be called by the `run` method.
    */
 
-  function use(fn, options) {
-    var val = fn.call(this, this, this.base || {}, this.env || {}, options || {});
+  function use(type, fn, options) {
+    if (typeof type === 'string' || Array.isArray(type)) {
+      fn = wrap(type, fn);
+    } else {
+      options = fn;
+      fn = type;
+    }
+
+    var val = fn.call(this, this, this.base || {}, options || {}, this.env || {});
     if (typeof val === 'function') {
       this.fns.push(val);
     }
-    if (this.emit) {
+
+    if (typeof this.emit === 'function') {
       this.emit('use', val, this);
     }
     return this;
   }
+
+  /**
+   * Wrap a named plugin function so that it's only called on objects of the
+   * given `type`
+   *
+   * @param {String} `type`
+   * @param {Function} `fn` Plugin function
+   * @return {Function}
+   */
+
+  function wrap(type, fn) {
+    return function plugin() {
+      if (!isValid(this, type)) return plugin;
+      return fn.apply(this, arguments);
+    };
+  }
 };
diff --git a/test.js b/test.js
@@ -84,6 +84,46 @@ describe('plugins', function() {
     });
   });
 
+  describe('named plugins', function() {
+    it('should register named plugins', function() {
+      var app = new Base();
+      app.use(plugins());
+      app.type = 'app';
+      app.use(plugins());
+      var names = [];
+
+      app.use('foo', function() {
+        names.push(this.type);
+      });
+
+      app.use('bar', function() {
+        names.push(this.type);
+      });
+
+      app.use('baz', function() {
+        names.push(this.type);
+      });
+
+      var foo = new Base();
+      foo.type = 'foo';
+      foo.parent = app;
+      app.run(foo);
+
+      var bar = new Base();
+      bar.type = 'bar';
+      bar.parent = foo;
+      foo.run(bar);
+
+      var baz = new Base();
+      baz.type = 'baz';
+      baz.parent = bar;
+      bar.run(baz);
+
+      assert.deepEqual(names, ['foo', 'bar', 'baz']);
+    });
+
+  });
+
   describe('run', function() {
     beforeEach(function() {
       base = new Base();
