init

jssource/src_files/include/javascript/yui3/build/pluginhost/pluginhost-min.js

@@ -0,0 +1,8 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0
+build: 1549
+*/
+YUI.add("pluginhost",function(C){var A=C.Lang;function B(){this._plugins={};}B.prototype={plug:function(G,D){if(G){if(A.isFunction(G)){this._plug(G,D);}else{if(A.isArray(G)){for(var E=0,F=G.length;E<F;E++){this.plug(G[E]);}}else{this._plug(G.fn,G.cfg);}}}return this;},unplug:function(E){if(E){this._unplug(E);}else{var D;for(D in this._plugins){if(this._plugins.hasOwnProperty(D)){this._unplug(D);}}}return this;},hasPlugin:function(D){return(this._plugins[D]&&this[D]);},_initPlugins:function(E){this._plugins=this._plugins||{};var G=(this._getClasses)?this._getClasses():[this.constructor],D=[],H={},F,I,K,L,J;for(I=G.length-1;I>=0;I--){F=G[I];L=F._UNPLUG;if(L){C.mix(H,L,true);}K=F._PLUG;if(K){C.mix(D,K,true);}}for(J in D){if(D.hasOwnProperty(J)){if(!H[J]){this.plug(D[J]);}}}if(E&&E.plugins){this.plug(E.plugins);}},_destroyPlugins:function(){this._unplug();},_plug:function(F,D){if(F&&F.NS){var E=F.NS;D=D||{};D.host=this;if(this.hasPlugin(E)){this[E].setAttrs(D);}else{this[E]=new F(D);this._plugins[E]=F;}}},_unplug:function(F){var E=F,D=this._plugins;if(A.isFunction(F)){E=F.NS;if(E&&(!D[E]||D[E]!==F)){E=null;}}if(E){if(this[E]){this[E].destroy();delete this[E];}if(D[E]){delete D[E];}}}};B.plug=function(E,I,G){var J,H,D,F;if(E!==C.Base){E._PLUG=E._PLUG||{};if(!A.isArray(I)){if(G){I={fn:I,cfg:G};}I=[I];}for(H=0,D=I.length;H<D;H++){J=I[H];F=J.NAME||J.fn.NAME;E._PLUG[F]=J;}}};B.unplug=function(E,H){var I,G,D,F;if(E!==C.Base){E._UNPLUG=E._UNPLUG||{};if(!A.isArray(H)){H=[H];}for(G=0,D=H.length;G<D;G++){I=H[G];F=I.NAME;if(!E._PLUG[F]){E._UNPLUG[F]=I;}else{delete E._PLUG[F];}}}};C.namespace("Plugin").Host=B;},"3.0.0",{requires:["yui-base"]});

jssource/src_files/include/javascript/yui3/build/pluginhost/pluginhost.js

@@ -0,0 +1,296 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0
+build: 1549
+*/
+YUI.add('pluginhost', function(Y) {
+
+    /**
+     * Provides the augmentable PluginHost interface, which can be added to any class.
+     * @module pluginhost
+     */
+
+    /**
+     * <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(p, config) {
+            if (p) {
+                if (L.isFunction(p)) {
+                    this._plug(p, config);
+                } else if (L.isArray(p)) {
+                    for (var i = 0, ln = p.length; i < ln; i++) {
+                        this.plug(p[i]);
+                    }
+                } else {
+                    this._plug(p.fn, p.cfg);
+                }
+            }
+            return this;
+        },
+
+        /**
+         * Removes a plugin from the host object. This will destroy the 
+         * plugin instance and delete the namepsace 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) {
+            if (plugin) {
+                this._unplug(plugin);
+            } else {
+                var ns;
+                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 {boolean} returns true, if the plugin has been plugged into this host, false otherwise.
+         */
+        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 || {};
+
+            // 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);
+            }
+        },
+
+        /**
+         * Unplugs and destroys all plugins on the host
+         * @method _destroyPlugins
+         * @private
+         */
+        _destroyPlugins: function() {
+            this._unplug();
+        },
+
+        /**
+         * Private method used to instantiate and attach plugins to the host
+         *
+         * @method _plug
+         * @param {Function} PluginClass The plugin class to instantiate
+         * @param {Object} config The configuration object for the plugin
+         * @private
+         */
+        _plug: function(PluginClass, config) {
+            if (PluginClass && PluginClass.NS) {
+                var ns = PluginClass.NS;
+    
+                config = config || {};
+                config.host = this;
+    
+                if (this.hasPlugin(ns)) {
+                    // Update config
+                    this[ns].setAttrs(config);
+                } else {
+                    // Create new instance
+                    this[ns] = new PluginClass(config);
+                    this._plugins[ns] = PluginClass;
+                }
+            }
+        },
+
+        /**
+         * Unplugs and destroys a plugin already instantiated with the host.
+         *
+         * @method _unplug
+         * @private
+         * @param {String | Function} plugin The namespace for the plugin, or a plugin class with the static NS property defined.
+         */
+        _unplug : function(plugin) {
+            var ns = plugin, 
+                plugins = this._plugins;
+    
+            if (L.isFunction(plugin)) {
+                ns = plugin.NS;
+                if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
+                    ns = null;
+                }
+            }
+    
+            if (ns) {
+                if (this[ns]) {
+                    this[ns].destroy();
+                    delete this[ns];
+                }
+                if (plugins[ns]) {
+                    delete plugins[ns];
+                }
+            }
+        }
+    };
+    
+    /**
+     * 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];
+                }
+            }
+        }
+    };
+
+    Y.namespace("Plugin").Host = PluginHost;
+
+
+}, '3.0.0' ,{requires:['yui-base']});