2 Copyright (c) 2010, Yahoo! Inc. All rights reserved.
3 Code licensed under the BSD License:
4 http://developer.yahoo.com/yui/license.html
8 YUI.add('pluginhost-base', function(Y) {
11 * Provides the augmentable PluginHost interface, which can be added to any class.
16 * Provides the augmentable PluginHost interface, which can be added to any class.
17 * @module pluginhost-base
22 * An augmentable class, which provides the augmented class with the ability to host plugins.
23 * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can
24 * be used to add or remove plugins from instances of the class.
27 * <p>Plugins can also be added through the constructor configuration object passed to the host class' constructor using
28 * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method.
30 * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
32 * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
36 * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a>
37 * methods should be invoked by the host class at the appropriate point in the host's lifecyle.
45 function PluginHost() {
49 PluginHost.prototype = {
52 * Adds a plugin to the host object. This will instantiate the
53 * plugin and attach it to the configured namespace on the host object.
57 * @param P {Function | Object |Array} Accepts the plugin class, or an
58 * object with a "fn" property specifying the plugin class and
59 * a "cfg" property specifying the configuration for the Plugin.
61 * Additionally an Array can also be passed in, with the above function or
62 * object values, allowing the user to add multiple plugins in a single call.
64 * @param config (Optional) If the first argument is the plugin class, the second argument
65 * can be the configuration for the plugin.
66 * @return {Base} A reference to the host object
68 plug: function(Plugin, config) {
71 if (L.isArray(Plugin)) {
72 for (i = 0, ln = Plugin.length; i < ln; i++) {
76 if (Plugin && !L.isFunction(Plugin)) {
81 // Plugin should be fn by now
82 if (Plugin && Plugin.NS) {
85 config = config || {};
88 if (this.hasPlugin(ns)) {
90 this[ns].setAttrs(config);
92 // Create new instance
93 this[ns] = new Plugin(config);
94 this._plugins[ns] = Plugin;
102 * Removes a plugin from the host object. This will destroy the
103 * plugin instance and delete the namepsace from the host object.
106 * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
107 * all registered plugins are unplugged.
108 * @return {Base} A reference to the host object
111 unplug: function(plugin) {
113 plugins = this._plugins;
116 if (L.isFunction(plugin)) {
118 if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
133 for (ns in this._plugins) {
134 if (this._plugins.hasOwnProperty(ns)) {
143 * Determines if a plugin has plugged into this host.
146 * @param {String} ns The plugin's namespace
147 * @return {boolean} returns true, if the plugin has been plugged into this host, false otherwise.
149 hasPlugin : function(ns) {
150 return (this._plugins[ns] && this[ns]);
154 * Initializes static plugins registered on the host (using the
155 * Base.plug static method) and any plugins passed to the
156 * instance through the "plugins" configuration property.
158 * @method _initPlugins
159 * @param {Config} config The configuration object with property name/value pairs.
163 _initPlugins: function(config) {
164 this._plugins = this._plugins || {};
166 if (this._initConfigPlugins) {
167 this._initConfigPlugins(config);
172 * Unplugs and destroys all plugins on the host
173 * @method _destroyPlugins
176 _destroyPlugins: function() {
181 Y.namespace("Plugin").Host = PluginHost;
184 }, '3.3.0' ,{requires:['yui-base']});
185 YUI.add('pluginhost-config', function(Y) {
188 * Adds pluginhost constructor configuration and static configuration support
189 * @submodule pluginhost-config
193 * Constructor and static configuration support for plugins
197 var PluginHost = Y.Plugin.Host,
200 PluginHost.prototype._initConfigPlugins = function(config) {
202 // Class Configuration
203 var classes = (this._getClasses) ? this._getClasses() : [this.constructor],
206 constructor, i, classPlug, classUnplug, pluginClassName;
208 // TODO: Room for optimization. Can we apply statically/unplug in same pass?
209 for (i = classes.length - 1; i >= 0; i--) {
210 constructor = classes[i];
212 classUnplug = constructor._UNPLUG;
214 // subclasses over-write
215 Y.mix(unplug, classUnplug, true);
218 classPlug = constructor._PLUG;
220 // subclasses over-write
221 Y.mix(plug, classPlug, true);
225 for (pluginClassName in plug) {
226 if (plug.hasOwnProperty(pluginClassName)) {
227 if (!unplug[pluginClassName]) {
228 this.plug(plug[pluginClassName]);
233 // User Configuration
234 if (config && config.plugins) {
235 this.plug(config.plugins);
240 * Registers plugins to be instantiated at the class level (plugins
241 * which should be plugged into every instance of the class by default).
243 * @method Plugin.Host.plug
246 * @param {Function} hostClass The host class on which to register the plugins
247 * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
248 * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
250 PluginHost.plug = function(hostClass, plugin, config) {
251 // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ]
254 if (hostClass !== Y.Base) {
255 hostClass._PLUG = hostClass._PLUG || {};
257 if (!L.isArray(plugin)) {
259 plugin = {fn:plugin, cfg:config};
264 for (i = 0, l = plugin.length; i < l;i++) {
266 name = p.NAME || p.fn.NAME;
267 hostClass._PLUG[name] = p;
273 * Unregisters any class level plugins which have been registered by the host class, or any
274 * other class in the hierarchy.
276 * @method Plugin.Host.unplug
279 * @param {Function} hostClass The host class from which to unregister the plugins
280 * @param {Function | Array} plugin The plugin class, or an array of plugin classes
282 PluginHost.unplug = function(hostClass, plugin) {
285 if (hostClass !== Y.Base) {
286 hostClass._UNPLUG = hostClass._UNPLUG || {};
288 if (!L.isArray(plugin)) {
292 for (i = 0, l = plugin.length; i < l; i++) {
295 if (!hostClass._PLUG[name]) {
296 hostClass._UNPLUG[name] = p;
298 delete hostClass._PLUG[name];
305 }, '3.3.0' ,{requires:['pluginhost-base']});
308 YUI.add('pluginhost', function(Y){}, '3.3.0' ,{use:['pluginhost-base', 'pluginhost-config']});