[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('pluginhost-config', function (Y, NAME) {
   9  
  10      /**
  11       * Adds pluginhost constructor configuration and static configuration support
  12       * @submodule pluginhost-config
  13       */
  14  
  15      var PluginHost = Y.Plugin.Host,
  16          L = Y.Lang;
  17  
  18      /**
  19       * A protected initialization method, used by the host class to initialize
  20       * plugin configurations passed the constructor, through the config object.
  21       *
  22       * Host objects should invoke this method at the appropriate time in their
  23       * construction lifecycle.
  24       *
  25       * @method _initConfigPlugins
  26       * @param {Object} config The configuration object passed to the constructor
  27       * @protected
  28       * @for Plugin.Host
  29       */
  30      PluginHost.prototype._initConfigPlugins = function(config) {
  31  
  32          // Class Configuration
  33          var classes = (this._getClasses) ? this._getClasses() : [this.constructor],
  34              plug = [],
  35              unplug = {},
  36              constructor, i, classPlug, classUnplug, pluginClassName;
  37  
  38          // TODO: Room for optimization. Can we apply statically/unplug in same pass?
  39          for (i = classes.length - 1; i >= 0; i--) {
  40              constructor = classes[i];
  41  
  42              classUnplug = constructor._UNPLUG;
  43              if (classUnplug) {
  44                  // subclasses over-write
  45                  Y.mix(unplug, classUnplug, true);
  46              }
  47  
  48              classPlug = constructor._PLUG;
  49              if (classPlug) {
  50                  // subclasses over-write
  51                  Y.mix(plug, classPlug, true);
  52              }
  53          }
  54  
  55          for (pluginClassName in plug) {
  56              if (plug.hasOwnProperty(pluginClassName)) {
  57                  if (!unplug[pluginClassName]) {
  58                      this.plug(plug[pluginClassName]);
  59                  }
  60              }
  61          }
  62  
  63          // User Configuration
  64          if (config && config.plugins) {
  65              this.plug(config.plugins);
  66          }
  67      };
  68  
  69      /**
  70       * Registers plugins to be instantiated at the class level (plugins
  71       * which should be plugged into every instance of the class by default).
  72       *
  73       * @method plug
  74       * @static
  75       *
  76       * @param {Function} hostClass The host class on which to register the plugins
  77       * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
  78       * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
  79       * @for Plugin.Host
  80       */
  81      PluginHost.plug = function(hostClass, plugin, config) {
  82          // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ]
  83          var p, i, l, name;
  84  
  85          if (hostClass !== Y.Base) {
  86              hostClass._PLUG = hostClass._PLUG || {};
  87  
  88              if (!L.isArray(plugin)) {
  89                  if (config) {
  90                      plugin = {fn:plugin, cfg:config};
  91                  }
  92                  plugin = [plugin];
  93              }
  94  
  95              for (i = 0, l = plugin.length; i < l;i++) {
  96                  p = plugin[i];
  97                  name = p.NAME || p.fn.NAME;
  98                  hostClass._PLUG[name] = p;
  99              }
 100          }
 101      };
 102  
 103      /**
 104       * Unregisters any class level plugins which have been registered by the host class, or any
 105       * other class in the hierarchy.
 106       *
 107       * @method unplug
 108       * @static
 109       *
 110       * @param {Function} hostClass The host class from which to unregister the plugins
 111       * @param {Function | Array} plugin The plugin class, or an array of plugin classes
 112       * @for Plugin.Host
 113       */
 114      PluginHost.unplug = function(hostClass, plugin) {
 115          var p, i, l, name;
 116  
 117          if (hostClass !== Y.Base) {
 118              hostClass._UNPLUG = hostClass._UNPLUG || {};
 119  
 120              if (!L.isArray(plugin)) {
 121                  plugin = [plugin];
 122              }
 123  
 124              for (i = 0, l = plugin.length; i < l; i++) {
 125                  p = plugin[i];
 126                  name = p.NAME;
 127                  if (!hostClass._PLUG[name]) {
 128                      hostClass._UNPLUG[name] = p;
 129                  } else {
 130                      delete hostClass._PLUG[name];
 131                  }
 132              }
 133          }
 134      };
 135  
 136  
 137  }, '3.17.2', {"requires": ["pluginhost-base"]});