File: pluginhost/js/PluginHostConfig.js

                /**
                 * 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 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
                 * @for Plugin.Host
                 */
                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 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
                 * @for Plugin.Host
                 */
                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];
                            }
                        }
                    }
                };