• Classes
• Modules
• Everything

 /**
 * 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];
 }
 }
 }
 };