#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# File: pluginhost/js/PluginHost.js

        /**
         * Provides the augmentable PluginHost interface, which can be added to any class.
         * @module pluginhost
         */

        /**
         * Provides the augmentable PluginHost interface, which can be added to any class.
         * @module pluginhost-base
         */

        /**
         * <p>
         * An augmentable class, which provides the augmented class with the ability to host plugins.
         * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can
         * be used to add or remove plugins from instances of the class.
         * </p>
         *
         * <p>Plugins can also be added through the constructor configuration object passed to the host class' constructor using
         * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method.
         *
         * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
         * <xmp>
         * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
         * </xmp>
         * </p>
         * <p>
         * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a>
         * methods should be invoked by the host class at the appropriate point in the host's lifecyle.
         * </p>
         *
         * @class Plugin.Host
         */

        var L = Y.Lang;

        function PluginHost() {
            this._plugins = {};
        }

        PluginHost.prototype = {

            /**
             * Adds a plugin to the host object. This will instantiate the
             * plugin and attach it to the configured namespace on the host object.
             *
             * @method plug
             * @chainable
             * @param P {Function | Object |Array} Accepts the plugin class, or an
             * object with a "fn" property specifying the plugin class and
             * a "cfg" property specifying the configuration for the Plugin.
             * <p>
             * Additionally an Array can also be passed in, with the above function or
             * object values, allowing the user to add multiple plugins in a single call.
             * </p>
             * @param config (Optional) If the first argument is the plugin class, the second argument
             * can be the configuration for the plugin.
             * @return {Base} A reference to the host object
             */
            plug: function(Plugin, config) {
                var i, ln, ns;

                if (L.isArray(Plugin)) {
                    for (i = 0, ln = Plugin.length; i < ln; i++) {
                        this.plug(Plugin[i]);
                    }
                } else {
                    if (Plugin && !L.isFunction(Plugin)) {
                        config = Plugin.cfg;
                        Plugin = Plugin.fn;
                    }

                    // Plugin should be fn by now
                    if (Plugin && Plugin.NS) {
                        ns = Plugin.NS;

                        config = config || {};
                        config.host = this;

                        if (this.hasPlugin(ns)) {
                            // Update config
                            if (this[ns].setAttrs) {
                                this[ns].setAttrs(config);
                            }
                            else { Y.log("Attempt to replug an already attached plugin, and we can't setAttrs, because it's not Attribute based: " + ns); }
                        } else {
                            // Create new instance
                            this[ns] = new Plugin(config);
                            this._plugins[ns] = Plugin;
                        }
                    }
                    else { Y.log("Attempt to plug in an invalid plugin. Host:" + this + ", Plugin:" + Plugin); }
                }
                return this;
            },

            /**
             * Removes a plugin from the host object. This will destroy the
             * plugin instance and delete the namespace from the host object.
             *
             * @method unplug
             * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
             * all registered plugins are unplugged.
             * @return {Base} A reference to the host object
             * @chainable
             */
            unplug: function(plugin) {
                var ns = plugin,
                    plugins = this._plugins;

                if (plugin) {
                    if (L.isFunction(plugin)) {
                        ns = plugin.NS;
                        if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                            ns = null;
                        }
                    }

                    if (ns) {
                        if (this[ns]) {
                            if (this[ns].destroy) {
                                this[ns].destroy();
                            }
                            delete this[ns];
                        }
                        if (plugins[ns]) {
                            delete plugins[ns];
                        }
                    }
                } else {
                    for (ns in this._plugins) {
                        if (this._plugins.hasOwnProperty(ns)) {
                            this.unplug(ns);
                        }
                    }
                }
                return this;
            },

            /**
             * Determines if a plugin has plugged into this host.
             *
             * @method hasPlugin
             * @param {String} ns The plugin's namespace
             * @return {Plugin} Returns a truthy value (the plugin instance) if present, or undefined if not.
             */
            hasPlugin : function(ns) {
                return (this._plugins[ns] && this[ns]);
            },

            /**
             * Initializes static plugins registered on the host (using the
             * Base.plug static method) and any plugins passed to the
             * instance through the "plugins" configuration property.
             *
             * @method _initPlugins
             * @param {Config} config The configuration object with property name/value pairs.
             * @private
             */

            _initPlugins: function(config) {
                this._plugins = this._plugins || {};

                if (this._initConfigPlugins) {
                    this._initConfigPlugins(config);
                }
            },

            /**
             * Unplugs and destroys all plugins on the host
             * @method _destroyPlugins
             * @private
             */
            _destroyPlugins: function() {
                this.unplug();
            }
        };

        Y.namespace("Plugin").Host = PluginHost;