• Classes
• Modules
• Everything

 /**
 * The attribute module provides an augmentable Attribute implementation, which
 * adds configurable attributes and attribute change events to the class being
 * augmented. It also provides a State class, which is used internally by Attribute,
 * but can also be used independently to provide a name/property/value data structure to
 * store state.
 *
 * @module attribute
 */
 /**
 * The attribute-extras submodule provides less commonly used attribute methods, and can
 * be augmented/mixed into an implemention which used attribute-core.
 *
 * @module attribute
 * @submodule attribute-extras
 */
 var BROADCAST = "broadcast",
 PUBLISHED = "published",
 INIT_VALUE = "initValue",
 MODIFIABLE = {
 readOnly:1,
 writeOnce:1,
 getter:1,
 broadcast:1
 };
 /**
 * A augmentable implementation for AttributeCore, providing less frequently used
 * methods for Attribute management such as modifyAttrs(), removeAttr and reset()
 *
 * @class AttributeExtras
 * @extensionfor AttributeCore
 */
 function AttributeExtras() {}
 AttributeExtras.prototype = {
 /**
 * Updates the configuration of an attribute which has already been added.
 * <p>
 * The properties which can be modified through this interface are limited
 * to the following subset of attributes, which can be safely modified
 * after a value has already been set on the attribute:
 * </p>
 * <dl>
 * <dt>readOnly;</dt>
 * <dt>writeOnce;</dt>
 * <dt>broadcast; and</dt>
 * <dt>getter.</dt>
 * </dl>
 * <p>
 * Note: New attributes cannot be added using this interface. New attributes must be
 * added using {{#crossLink "AttributeCore/addAttr:method"}}addAttr{{/crossLink}}, or an
 * appropriate manner for a class which utilises Attributes (e.g. the
 * {{#crossLink "Base/ATTRS:property"}}ATTRS{{/crossLink}} property in
 * {{#crossLink "Base"}}Base{{/crossLink}}).
 * </p>
 * @method modifyAttr
 * @param {String} name The name of the attribute whose configuration is to be updated.
 * @param {Object} config An object with configuration property/value pairs, specifying the configuration properties to modify.
 */
 modifyAttr: function(name, config) {
 var host = this, // help compression
 prop, state;
 if (host.attrAdded(name)) {
 if (host._isLazyAttr(name)) {
 host._addLazyAttr(name);
 }
 state = host._state;
 for (prop in config) {
 if (MODIFIABLE[prop] && config.hasOwnProperty(prop)) {
 state.add(name, prop, config[prop]);
 // If we reconfigured broadcast, need to republish
 if (prop === BROADCAST) {
 state.remove(name, PUBLISHED);
 }
 }
 }
 } else {
 Y.log('Attribute modifyAttr:' + name + ' has not been added. Use addAttr to add the attribute', 'warn', 'attribute');
 }
 },
 /**
 * Removes an attribute from the host object
 *
 * @method removeAttr
 * @param {String} name The name of the attribute to be removed.
 */
 removeAttr: function(name) {
 this._state.removeAll(name);
 },
 /**
 * Resets the attribute (or all attributes) to its initial value, as long as
 * the attribute is not readOnly, or writeOnce.
 *
 * @method reset
 * @param {String} name Optional. The name of the attribute to reset. If omitted, all attributes are reset.
 * @return {Object} A reference to the host object.
 * @chainable
 */
 reset : function(name) {
 var host = this; // help compression
 if (name) {
 if (host._isLazyAttr(name)) {
 host._addLazyAttr(name);
 }
 host.set(name, host._state.get(name, INIT_VALUE));
 } else {
 Y.Object.each(host._state.data, function(v, n) {
 host.reset(n);
 });
 }
 return host;
 },
 /**
 * Returns an object with the configuration properties (and value)
 * for the given attribute. If attrName is not provided, returns the
 * configuration properties for all attributes.
 *
 * @method _getAttrCfg
 * @protected
 * @param {String} name Optional. The attribute name. If not provided, the method will return the configuration for all attributes.
 * @return {Object} The configuration properties for the given attribute, or all attributes.
 */
 _getAttrCfg : function(name) {
 var o,
 state = this._state;
 if (name) {
 o = state.getAll(name) || {};
 } else {
 o = {};
 Y.each(state.data, function(v, n) {
 o[n] = state.getAll(n);
 });
 }
 return o;
 }
 };
 Y.AttributeExtras = AttributeExtras;