pluginhost/js/PluginHostConfig.js

PluginHostConfig.js revision 1e467ec3dfebabf9895552c6e7e85d4660a18969
   /**
    * Adds pluginhost constructor configuration and static configuration support
    * @submodule pluginhost-config
    */

   var PluginHost = Y.Plugin.Host,
       L = Y.Lang;

   /**
    * A protected initialization method, used by the host class to initialize
    * plugin configurations passed the constructor, through the config object.
    *
    * Host objects should invoke this method at the appropriate time in their
    * construction lifecycle.
    *
    * @method _initConfigPlugins
    * @param {Object} config The configuration object passed to the constructor
    * @protected
    * @for Plugin.Host
    */
   PluginHost.prototype._initConfigPlugins = function(config) {

       // Class Configuration
       var classes = (this._getClasses) ? this._getClasses() : [this.constructor],
           plug = [],
           unplug = {},
           constructor, i, classPlug, classUnplug, pluginClassName;

       // TODO: Room for optimization. Can we apply statically/unplug in same pass?
       for (i = classes.length - 1; i >= 0; i--) {
           constructor = classes[i];

           classUnplug = constructor._UNPLUG;
           if (classUnplug) {
               // subclasses over-write
               Y.mix(unplug, classUnplug, true);
           }

           classPlug = constructor._PLUG;
           if (classPlug) {
               // subclasses over-write
               Y.mix(plug, classPlug, true);
           }
       }

       for (pluginClassName in plug) {
           if (plug.hasOwnProperty(pluginClassName)) {
               if (!unplug[pluginClassName]) {
                   this.plug(plug[pluginClassName]);
               }
           }
       }

       // User Configuration
       if (config && config.plugins) {
           this.plug(config.plugins);
       }
   };

   /**
    * Registers plugins to be instantiated at the class level (plugins
    * which should be plugged into every instance of the class by default).
    *
    * @method Plugin.Host.plug
    * @static
    *
    * @param {Function} hostClass The host class on which to register the plugins
    * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
    * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
    */
   PluginHost.plug = function(hostClass, plugin, config) {
       // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ]
       var p, i, l, name;

       if (hostClass !== Y.Base) {
           hostClass._PLUG = hostClass._PLUG || {};

           if (!L.isArray(plugin)) {
               if (config) {
                   plugin = {fn:plugin, cfg:config};
               }
               plugin = [plugin];
           }

           for (i = 0, l = plugin.length; i < l;i++) {
               p = plugin[i];
               name = p.NAME || p.fn.NAME;
               hostClass._PLUG[name] = p;
           }
       }
   };

   /**
    * Unregisters any class level plugins which have been registered by the host class, or any
    * other class in the hierarchy.
    *
    * @method Plugin.Host.unplug
    * @static
    *
    * @param {Function} hostClass The host class from which to unregister the plugins
    * @param {Function | Array} plugin The plugin class, or an array of plugin classes
    */
   PluginHost.unplug = function(hostClass, plugin) {
       var p, i, l, name;

       if (hostClass !== Y.Base) {
           hostClass._UNPLUG = hostClass._UNPLUG || {};

           if (!L.isArray(plugin)) {
               plugin = [plugin];
           }

           for (i = 0, l = plugin.length; i < l; i++) {
               p = plugin[i];
               name = p.NAME;
               if (!hostClass._PLUG[name]) {
                   hostClass._UNPLUG[name] = p;
               } else {
                   delete hostClass._PLUG[name];
               }
           }
       }
   };