lib/yuilib/3.13.0/base-core/base-core-debug.js

   1 /*
   2 YUI 3.13.0 (build 508226d)
   3 Copyright 2013 Yahoo! Inc. All rights reserved.
   4 Licensed under the BSD License.
   5 http://yuilibrary.com/license/
   6 */
   7
   8 YUI.add('base-core', function (Y, NAME) {
   9
  10     /**
  11      * The base module provides the Base class, which objects requiring attribute and custom event support can extend.
  12      * The module also provides two ways to reuse code - It augments Base with the Plugin.Host interface which provides
  13      * plugin support and also provides the BaseCore.build method which provides a way to build custom classes using extensions.
  14      *
  15      * @module base
  16      */
  17
  18     /**
  19      * <p>The base-core module provides the BaseCore class, the lightest version of Base,
  20      * which provides Base's basic lifecycle management and ATTRS construction support,
  21      * but doesn't fire init/destroy or attribute change events.</p>
  22      *
  23      * <p>It mixes in AttributeCore, which is the lightest version of Attribute</p>
  24      *
  25      * @module base
  26      * @submodule base-core
  27      */
  28     var O = Y.Object,
  29         L = Y.Lang,
  30         DOT = ".",
  31         INITIALIZED = "initialized",
  32         DESTROYED = "destroyed",
  33         INITIALIZER = "initializer",
  34         VALUE = "value",
  35         OBJECT_CONSTRUCTOR = Object.prototype.constructor,
  36         DEEP = "deep",
  37         SHALLOW = "shallow",
  38         DESTRUCTOR = "destructor",
  39
  40         AttributeCore = Y.AttributeCore,
  41
  42         _wlmix = function(r, s, wlhash) {
  43             var p;
  44             for (p in s) {
  45                 if(wlhash[p]) {
  46                     r[p] = s[p];
  47                 }
  48             }
  49             return r;
  50         };
  51
  52     /**
  53      * The BaseCore class, is the lightest version of Base, and provides Base's
  54      * basic lifecycle management and ATTRS construction support, but doesn't
  55      * fire init/destroy or attribute change events.
  56      *
  57      * BaseCore also handles the chaining of initializer and destructor methods across
  58      * the hierarchy as part of object construction and destruction. Additionally, attributes
  59      * configured through the static <a href="#property_BaseCore.ATTRS">ATTRS</a>
  60      * property for each class in the hierarchy will be initialized by BaseCore.
  61      *
  62      * Classes which require attribute support, but don't intend to use/expose attribute
  63      * change events can extend BaseCore instead of Base for optimal kweight and
  64      * runtime performance.
  65      *
  66      * **3.11.0 BACK COMPAT NOTE FOR COMPONENT DEVELOPERS**
  67      *
  68      * Prior to version 3.11.0, ATTRS would get added a class at a time. That is:
  69      *
  70      * <pre>
  71      *    for each (class in the hierarchy) {
  72      *       Call the class Extension constructors.
  73      *
  74      *       Add the class ATTRS.
  75      *
  76      *       Call the class initializer
  77      *       Call the class Extension initializers.
  78      *    }
  79      * </pre>
  80      *
  81      * As of 3.11.0, ATTRS from all classes in the hierarchy are added in one `addAttrs` call
  82      * before **any** initializers are called. That is, the flow becomes:
  83      *
  84      * <pre>
  85      *    for each (class in the hierarchy) {
  86      *       Call the class Extension constructors.
  87      *    }
  88      *
  89      *    Add ATTRS for all classes
  90      *
  91      *    for each (class in the hierarchy) {
  92      *       Call the class initializer.
  93      *       Call the class Extension initializers.
  94      *    }
  95      * </pre>
  96      *
  97      * Adding all ATTRS at once fixes subtle edge-case issues with subclass ATTRS overriding
  98      * superclass `setter`, `getter` or `valueFn` definitions and being unable to get/set attributes
  99      * defined by the subclass. It also leaves us with a cleaner order of operation flow moving
 100      * forward.
 101      *
 102      * However, it may require component developers to upgrade their components, for the following
 103      * scenarios:
 104      *
 105      * 1. It impacts components which may have `setter`, `getter` or `valueFn` code which
 106      * expects a superclass' initializer to have run.
 107      *
 108      * This is expected to be rare, but to support it, Base now supports a `_preAddAttrs()`, method
 109      * hook (same signature as `addAttrs`). Components can implement this method on their prototype
 110      * for edge cases which do require finer control over the order in which attributes are added
 111      * (see widget-htmlparser for example).
 112      *
 113      * 2. Extension developers may need to move code from Extension constructors to `initializer`s
 114      *
 115      * Older extensions, which were written before `initializer` support was added, had a lot of
 116      * initialization code in their constructors. For example, code which acccessed superclass
 117      * attributes. With the new flow this code would not be able to see attributes. The recommendation
 118      * is to move this initialization code to an `initializer` on the Extension, which was the
 119      * recommendation for anything created after `initializer` support for Extensions was added.
 120      *
 121      * @class BaseCore
 122      * @constructor
 123      * @uses AttributeCore
 124      * @param {Object} cfg Object with configuration property name/value pairs.
 125      * The object can be used to provide initial values for the objects published
 126      * attributes.
 127      */
 128     function BaseCore(cfg) {
 129         if (!this._BaseInvoked) {
 130             this._BaseInvoked = true;
 131
 132             Y.log('constructor called', 'life', 'base');
 133             this._initBase(cfg);
 134         }
 135         else { Y.log('Based constructor called more than once. Ignoring duplicate calls', 'life', 'base'); }
 136     }
 137
 138     /**
 139      * The list of properties which can be configured for each attribute
 140      * (e.g. setter, getter, writeOnce, readOnly etc.)
 141      *
 142      * @property _ATTR_CFG
 143      * @type Array
 144      * @static
 145      * @private
 146      */
 147     BaseCore._ATTR_CFG = AttributeCore._ATTR_CFG.concat("cloneDefaultValue");
 148
 149     /**
 150      * The array of non-attribute configuration properties supported by this class.
 151      *
 152      * For example `BaseCore` defines a "plugins" configuration property which
 153      * should not be set up as an attribute. This property is primarily required so
 154      * that when <a href="#property__allowAdHocAttrs">`_allowAdHocAttrs`</a> is enabled by a class,
 155      * non-attribute configuration properties don't get added as ad-hoc attributes.
 156      *
 157      * @property _NON_ATTRS_CFG
 158      * @type Array
 159      * @static
 160      * @private
 161      */
 162     BaseCore._NON_ATTRS_CFG = ["plugins"];
 163
 164     /**
 165      * This property controls whether or not instances of this class should
 166      * allow users to add ad-hoc attributes through the constructor configuration
 167      * hash.
 168      *
 169      * AdHoc attributes are attributes which are not defined by the class, and are
 170      * not handled by the MyClass._NON_ATTRS_CFG
 171      *
 172      * @property _allowAdHocAttrs
 173      * @type boolean
 174      * @default undefined (false)
 175      * @protected
 176      */
 177
 178     /**
 179      * The string to be used to identify instances of this class.
 180      *
 181      * Classes extending BaseCore, should define their own
 182      * static NAME property, which should be camelCase by
 183      * convention (e.g. MyClass.NAME = "myClass";).
 184      *
 185      * @property NAME
 186      * @type String
 187      * @static
 188      */
 189     BaseCore.NAME = "baseCore";
 190
 191     /**
 192      * The default set of attributes which will be available for instances of this class, and
 193      * their configuration. In addition to the configuration properties listed by
 194      * AttributeCore's <a href="AttributeCore.html#method_addAttr">addAttr</a> method,
 195      * the attribute can also be configured with a "cloneDefaultValue" property, which
 196      * defines how the statically defined value field should be protected
 197      * ("shallow", "deep" and false are supported values).
 198      *
 199      * By default if the value is an object literal or an array it will be "shallow"
 200      * cloned, to protect the default value.
 201      *
 202      * @property ATTRS
 203      * @type Object
 204      * @static
 205      */
 206     BaseCore.ATTRS = {
 207         /**
 208          * Flag indicating whether or not this object
 209          * has been through the init lifecycle phase.
 210          *
 211          * @attribute initialized
 212          * @readonly
 213          * @default false
 214          * @type boolean
 215          */
 216         initialized: {
 217             readOnly:true,
 218             value:false
 219         },
 220
 221         /**
 222          * Flag indicating whether or not this object
 223          * has been through the destroy lifecycle phase.
 224          *
 225          * @attribute destroyed
 226          * @readonly
 227          * @default false
 228          * @type boolean
 229          */
 230         destroyed: {
 231             readOnly:true,
 232             value:false
 233         }
 234     };
 235
 236     /**
 237     Provides a way to safely modify a `Y.BaseCore` subclass' static `ATTRS`
 238     after the class has been defined or created.
 239
 240     BaseCore-based classes cache information about the class hierarchy in order
 241     to efficiently create instances. This cache includes includes the aggregated
 242     `ATTRS` configs. If the static `ATTRS` configs need to be modified after the
 243     class has been defined or create, then use this method which will make sure
 244     to clear any cached data before making any modifications.
 245
 246     @method modifyAttrs
 247     @param {Function} [ctor] The constructor function whose `ATTRS` should be
 248         modified. If a `ctor` function is not specified, then `this` is assumed
 249         to be the constructor which hosts the `ATTRS`.
 250     @param {Object} configs The collection of `ATTRS` configs to mix with the
 251         existing attribute configurations.
 252     @static
 253     @since 3.10.0
 254     **/
 255     BaseCore.modifyAttrs = function (ctor, configs) {
 256         // When called without a constructor, assume `this` is the constructor.
 257         if (typeof ctor !== 'function') {
 258             configs = ctor;
 259             ctor    = this;
 260         }
 261
 262         var attrs, attr, name;
 263
 264         // Eagerly create the `ATTRS` object if it doesn't already exist.
 265         attrs = ctor.ATTRS || (ctor.ATTRS = {});
 266
 267         if (configs) {
 268             // Clear cache because it has ATTRS aggregation data which is about
 269             // to be modified.
 270             ctor._CACHED_CLASS_DATA = null;
 271
 272             for (name in configs) {
 273                 if (configs.hasOwnProperty(name)) {
 274                     attr = attrs[name] || (attrs[name] = {});
 275                     Y.mix(attr, configs[name], true);
 276                 }
 277             }
 278         }
 279     };
 280
 281     BaseCore.prototype = {
 282
 283         /**
 284          * Internal construction logic for BaseCore.
 285          *
 286          * @method _initBase
 287          * @param {Object} config The constructor configuration object
 288          * @private
 289          */
 290         _initBase : function(config) {
 291             Y.log('init called', 'life', 'base');
 292
 293             Y.stamp(this);
 294
 295             this._initAttribute(config);
 296
 297             // If Plugin.Host has been augmented [ through base-pluginhost ], setup it's
 298             // initial state, but don't initialize Plugins yet. That's done after initialization.
 299             var PluginHost = Y.Plugin && Y.Plugin.Host;
 300             if (this._initPlugins && PluginHost) {
 301                 PluginHost.call(this);
 302             }
 303
 304             if (this._lazyAddAttrs !== false) { this._lazyAddAttrs = true; }
 305
 306             /**
 307              * The string used to identify the class of this object.
 308              *
 309              * @deprecated Use this.constructor.NAME
 310              * @property name
 311              * @type String
 312              */
 313             this.name = this.constructor.NAME;
 314
 315             this.init.apply(this, arguments);
 316         },
 317
 318         /**
 319          * Initializes AttributeCore
 320          *
 321          * @method _initAttribute
 322          * @private
 323          */
 324         _initAttribute: function() {
 325             AttributeCore.call(this);
 326         },
 327
 328         /**
 329          * Init lifecycle method, invoked during construction. Sets up attributes
 330          * and invokes initializers for the class hierarchy.
 331          *
 332          * @method init
 333          * @chainable
 334          * @param {Object} cfg Object with configuration property name/value pairs
 335          * @return {BaseCore} A reference to this object
 336          */
 337         init: function(cfg) {
 338             Y.log('init called', 'life', 'base');
 339
 340             this._baseInit(cfg);
 341
 342             return this;
 343         },
 344
 345         /**
 346          * Internal initialization implementation for BaseCore
 347          *
 348          * @method _baseInit
 349          * @private
 350          */
 351         _baseInit: function(cfg) {
 352             this._initHierarchy(cfg);
 353
 354             if (this._initPlugins) {
 355                 // Need to initPlugins manually, to handle constructor parsing, static Plug parsing
 356                 this._initPlugins(cfg);
 357             }
 358             this._set(INITIALIZED, true);
 359         },
 360
 361         /**
 362          * Destroy lifecycle method. Invokes destructors for the class hierarchy.
 363          *
 364          * @method destroy
 365          * @return {BaseCore} A reference to this object
 366          * @chainable
 367          */
 368         destroy: function() {
 369             this._baseDestroy();
 370             return this;
 371         },
 372
 373         /**
 374          * Internal destroy implementation for BaseCore
 375          *
 376          * @method _baseDestroy
 377          * @private
 378          */
 379         _baseDestroy : function() {
 380             if (this._destroyPlugins) {
 381                 this._destroyPlugins();
 382             }
 383             this._destroyHierarchy();
 384             this._set(DESTROYED, true);
 385         },
 386
 387         /**
 388          * Returns the class hierarchy for this object, with BaseCore being the last class in the array.
 389          *
 390          * @method _getClasses
 391          * @protected
 392          * @return {Function[]} An array of classes (constructor functions), making up the class hierarchy for this object.
 393          * This value is cached the first time the method, or _getAttrCfgs, is invoked. Subsequent invocations return the
 394          * cached value.
 395          */
 396         _getClasses : function() {
 397             if (!this._classes) {
 398                 this._initHierarchyData();
 399             }
 400             return this._classes;
 401         },
 402
 403         /**
 404          * Returns an aggregated set of attribute configurations, by traversing
 405          * the class hierarchy.
 406          *
 407          * @method _getAttrCfgs
 408          * @protected
 409          * @return {Object} The hash of attribute configurations, aggregated across classes in the hierarchy
 410          * This value is cached the first time the method, or _getClasses, is invoked. Subsequent invocations return
 411          * the cached value.
 412          */
 413         _getAttrCfgs : function() {
 414             if (!this._attrs) {
 415                 this._initHierarchyData();
 416             }
 417             return this._attrs;
 418         },
 419
 420         /**
 421          * A helper method used to isolate the attrs config for this instance to pass to `addAttrs`,
 422          * from the static cached ATTRS for the class.
 423          *
 424          * @method _getInstanceAttrCfgs
 425          * @private
 426          *
 427          * @param {Object} allCfgs The set of all attribute configurations for this instance.
 428          * Attributes will be removed from this set, if they belong to the filtered class, so
 429          * that by the time all classes are processed, allCfgs will be empty.
 430          *
 431          * @return {Object} The set of attributes to be added for this instance, suitable
 432          * for passing through to `addAttrs`.
 433          */
 434         _getInstanceAttrCfgs : function(allCfgs) {
 435
 436             var cfgs = {},
 437                 cfg,
 438                 val,
 439                 subAttr,
 440                 subAttrs,
 441                 subAttrPath,
 442                 attr,
 443                 attrCfg,
 444                 allSubAttrs = allCfgs._subAttrs,
 445                 attrCfgProperties = this._attrCfgHash();
 446
 447             for (attr in allCfgs) {
 448
 449                 if (allCfgs.hasOwnProperty(attr) && attr !== "_subAttrs") {
 450
 451                     attrCfg = allCfgs[attr];
 452
 453                     // Need to isolate from allCfgs, because we're going to set values etc.
 454                     cfg = cfgs[attr] = _wlmix({}, attrCfg, attrCfgProperties);
 455
 456                     val = cfg.value;
 457
 458                     if (val && (typeof val === "object")) {
 459                         this._cloneDefaultValue(attr, cfg);
 460                     }
 461
 462                     if (allSubAttrs && allSubAttrs.hasOwnProperty(attr)) {
 463                         subAttrs = allCfgs._subAttrs[attr];
 464
 465                         for (subAttrPath in subAttrs) {
 466                             subAttr = subAttrs[subAttrPath];
 467
 468                             if (subAttr.path) {
 469                                 O.setValue(cfg.value, subAttr.path, subAttr.value);
 470                             }
 471                         }
 472                     }
 473                 }
 474             }
 475
 476             return cfgs;
 477         },
 478
 479         /**
 480          * @method _filterAdHocAttrs
 481          * @private
 482          *
 483          * @param {Object} allAttrs The set of all attribute configurations for this instance.
 484          * Attributes will be removed from this set, if they belong to the filtered class, so
 485          * that by the time all classes are processed, allCfgs will be empty.
 486          * @param {Object} userVals The config object passed in by the user, from which adhoc attrs are to be filtered.
 487          * @return {Object} The set of adhoc attributes passed in, in the form
 488          * of an object with attribute name/configuration pairs.
 489          */
 490         _filterAdHocAttrs : function(allAttrs, userVals) {
 491             var adHocs,
 492                 nonAttrs = this._nonAttrs,
 493                 attr;
 494
 495             if (userVals) {
 496                 adHocs = {};
 497                 for (attr in userVals) {
 498                     if (!allAttrs[attr] && !nonAttrs[attr] && userVals.hasOwnProperty(attr)) {
 499                         adHocs[attr] = {
 500                             value:userVals[attr]
 501                         };
 502                     }
 503                 }
 504             }
 505
 506             return adHocs;
 507         },
 508
 509         /**
 510          * A helper method used by _getClasses and _getAttrCfgs, which determines both
 511          * the array of classes and aggregate set of attribute configurations
 512          * across the class hierarchy for the instance.
 513          *
 514          * @method _initHierarchyData
 515          * @private
 516          */
 517         _initHierarchyData : function() {
 518
 519             var ctor = this.constructor,
 520                 cachedClassData = ctor._CACHED_CLASS_DATA,
 521                 c,
 522                 i,
 523                 l,
 524                 attrCfg,
 525                 attrCfgHash,
 526                 needsAttrCfgHash = !ctor._ATTR_CFG_HASH,
 527                 nonAttrsCfg,
 528                 nonAttrs = {},
 529                 classes = [],
 530                 attrs = [];
 531
 532             // Start with `this` instance's constructor.
 533             c = ctor;
 534
 535             if (!cachedClassData) {
 536
 537                 while (c) {
 538                     // Add to classes
 539                     classes[classes.length] = c;
 540
 541                     // Add to attributes
 542                     if (c.ATTRS) {
 543                         attrs[attrs.length] = c.ATTRS;
 544                     }
 545
 546                     // Aggregate ATTR cfg whitelist.
 547                     if (needsAttrCfgHash) {
 548                         attrCfg     = c._ATTR_CFG;
 549                         attrCfgHash = attrCfgHash || {};
 550
 551                         if (attrCfg) {
 552                             for (i = 0, l = attrCfg.length; i < l; i += 1) {
 553                                 attrCfgHash[attrCfg[i]] = true;
 554                             }
 555                         }
 556                     }
 557
 558                     // Commenting out the if. We always aggregate, since we don't
 559                     // know if we'll be needing this on the instance or not.
 560                     // if (this._allowAdHocAttrs) {
 561                         nonAttrsCfg = c._NON_ATTRS_CFG;
 562                         if (nonAttrsCfg) {
 563                             for (i = 0, l = nonAttrsCfg.length; i < l; i++) {
 564                                 nonAttrs[nonAttrsCfg[i]] = true;
 565                             }
 566                         }
 567                     //}
 568
 569                     c = c.superclass ? c.superclass.constructor : null;
 570                 }
 571
 572                 // Cache computed `_ATTR_CFG_HASH` on the constructor.
 573                 if (needsAttrCfgHash) {
 574                     ctor._ATTR_CFG_HASH = attrCfgHash;
 575                 }
 576
 577                 cachedClassData = ctor._CACHED_CLASS_DATA = {
 578                     classes : classes,
 579                     nonAttrs : nonAttrs,
 580                     attrs : this._aggregateAttrs(attrs)
 581                 };
 582
 583             }
 584
 585             this._classes = cachedClassData.classes;
 586             this._attrs = cachedClassData.attrs;
 587             this._nonAttrs = cachedClassData.nonAttrs;
 588         },
 589
 590         /**
 591          * Utility method to define the attribute hash used to filter/whitelist property mixes for
 592          * this class for iteration performance reasons.
 593          *
 594          * @method _attrCfgHash
 595          * @private
 596          */
 597         _attrCfgHash: function() {
 598             return this.constructor._ATTR_CFG_HASH;
 599         },
 600
 601         /**
 602          * This method assumes that the value has already been checked to be an object.
 603          * Since it's on a critical path, we don't want to re-do the check.
 604          *
 605          * @method _cloneDefaultValue
 606          * @param {Object} cfg
 607          * @private
 608          */
 609         _cloneDefaultValue : function(attr, cfg) {
 610
 611             var val = cfg.value,
 612                 clone = cfg.cloneDefaultValue;
 613
 614             if (clone === DEEP || clone === true) {
 615                 Y.log('Cloning default value for attribute:' + attr, 'info', 'base');
 616                 cfg.value = Y.clone(val);
 617             } else if (clone === SHALLOW) {
 618                 Y.log('Merging default value for attribute:' + attr, 'info', 'base');
 619                 cfg.value = Y.merge(val);
 620             } else if ((clone === undefined && (OBJECT_CONSTRUCTOR === val.constructor || L.isArray(val)))) {
 621                 cfg.value = Y.clone(val);
 622             }
 623             // else if (clone === false), don't clone the static default value.
 624             // It's intended to be used by reference.
 625         },
 626
 627         /**
 628          * A helper method, used by _initHierarchyData to aggregate
 629          * attribute configuration across the instances class hierarchy.
 630          *
 631          * The method will protect the attribute configuration value to protect the statically defined
 632          * default value in ATTRS if required (if the value is an object literal, array or the
 633          * attribute configuration has cloneDefaultValue set to shallow or deep).
 634          *
 635          * @method _aggregateAttrs
 636          * @private
 637          * @param {Array} allAttrs An array of ATTRS definitions across classes in the hierarchy
 638          * (subclass first, Base last)
 639          * @return {Object} The aggregate set of ATTRS definitions for the instance
 640          */
 641         _aggregateAttrs : function(allAttrs) {
 642
 643             var attr,
 644                 attrs,
 645                 subAttrsHash,
 646                 cfg,
 647                 path,
 648                 i,
 649                 cfgPropsHash = this._attrCfgHash(),
 650                 aggAttr,
 651                 aggAttrs = {};
 652
 653             if (allAttrs) {
 654                 for (i = allAttrs.length-1; i >= 0; --i) {
 655
 656                     attrs = allAttrs[i];
 657
 658                     for (attr in attrs) {
 659                         if (attrs.hasOwnProperty(attr)) {
 660
 661                             // PERF TODO: Do we need to merge here, since we're merging later in getInstanceAttrCfgs
 662                             // Should we move this down to only merge if we hit the path or valueFn ifs below?
 663                             cfg = _wlmix({}, attrs[attr], cfgPropsHash);
 664
 665                             path = null;
 666                             if (attr.indexOf(DOT) !== -1) {
 667                                 path = attr.split(DOT);
 668                                 attr = path.shift();
 669                             }
 670
 671                             aggAttr = aggAttrs[attr];
 672
 673                             if (path && aggAttr && aggAttr.value) {
 674
 675                                 subAttrsHash = aggAttrs._subAttrs;
 676
 677                                 if (!subAttrsHash) {
 678                                     subAttrsHash = aggAttrs._subAttrs = {};
 679                                 }
 680
 681                                 if (!subAttrsHash[attr]) {
 682                                     subAttrsHash[attr] = {};
 683                                 }
 684
 685                                 subAttrsHash[attr][path.join(DOT)] = {
 686                                     value: cfg.value,
 687                                     path : path
 688                                 };
 689
 690                             } else if (!path) {
 691
 692                                 if (!aggAttr) {
 693                                     aggAttrs[attr] = cfg;
 694                                 } else {
 695                                     if (aggAttr.valueFn && VALUE in cfg) {
 696                                         aggAttr.valueFn = null;
 697                                     }
 698
 699                                     // Mix into existing config.
 700                                     _wlmix(aggAttr, cfg, cfgPropsHash);
 701                                 }
 702                             }
 703                         }
 704                     }
 705                 }
 706             }
 707
 708             return aggAttrs;
 709         },
 710
 711         /**
 712          * Initializes the class hierarchy for the instance, which includes
 713          * initializing attributes for each class defined in the class's
 714          * static <a href="#property_BaseCore.ATTRS">ATTRS</a> property and
 715          * invoking the initializer method on the prototype of each class in the hierarchy.
 716          *
 717          * @method _initHierarchy
 718          * @param {Object} userVals Object with configuration property name/value pairs
 719          * @private
 720          */
 721         _initHierarchy : function(userVals) {
 722
 723             var lazy = this._lazyAddAttrs,
 724                 constr,
 725                 constrProto,
 726                 i,
 727                 l,
 728                 ci,
 729                 ei,
 730                 el,
 731                 ext,
 732                 extProto,
 733                 exts,
 734                 instanceAttrs,
 735                 initializers = [],
 736                 classes = this._getClasses(),
 737                 attrCfgs = this._getAttrCfgs(),
 738                 cl = classes.length - 1;
 739
 740             // Constructors
 741             for (ci = cl; ci >= 0; ci--) {
 742
 743                 constr = classes[ci];
 744                 constrProto = constr.prototype;
 745                 exts = constr._yuibuild && constr._yuibuild.exts;
 746
 747                 // Using INITIALIZER in hasOwnProperty check, for performance reasons (helps IE6 avoid GC thresholds when
 748                 // referencing string literals). Not using it in apply, again, for performance "." is faster.
 749
 750                 if (constrProto.hasOwnProperty(INITIALIZER)) {
 751                     // Store initializer while we're here and looping
 752                     initializers[initializers.length] = constrProto.initializer;
 753                 }
 754
 755                 if (exts) {
 756                     for (ei = 0, el = exts.length; ei < el; ei++) {
 757
 758                         ext = exts[ei];
 759
 760                         // Ext Constructor
 761                         ext.apply(this, arguments);
 762
 763                         extProto = ext.prototype;
 764                         if (extProto.hasOwnProperty(INITIALIZER)) {
 765                             // Store initializer while we're here and looping
 766                             initializers[initializers.length] = extProto.initializer;
 767                         }
 768                     }
 769                 }
 770             }
 771
 772             // ATTRS
 773             instanceAttrs = this._getInstanceAttrCfgs(attrCfgs);
 774
 775             if (this._preAddAttrs) {
 776                 this._preAddAttrs(instanceAttrs, userVals, lazy);
 777             }
 778
 779             if (this._allowAdHocAttrs) {
 780                 this.addAttrs(this._filterAdHocAttrs(attrCfgs, userVals), userVals, lazy);
 781             }
 782
 783             this.addAttrs(instanceAttrs, userVals, lazy);
 784
 785             // Initializers
 786             for (i = 0, l = initializers.length; i < l; i++) {
 787                 initializers[i].apply(this, arguments);
 788             }
 789         },
 790
 791         /**
 792          * Destroys the class hierarchy for this instance by invoking
 793          * the destructor method on the prototype of each class in the hierarchy.
 794          *
 795          * @method _destroyHierarchy
 796          * @private
 797          */
 798         _destroyHierarchy : function() {
 799             var constr,
 800                 constrProto,
 801                 ci, cl, ei, el, exts, extProto,
 802                 classes = this._getClasses();
 803
 804             for (ci = 0, cl = classes.length; ci < cl; ci++) {
 805                 constr = classes[ci];
 806                 constrProto = constr.prototype;
 807                 exts = constr._yuibuild && constr._yuibuild.exts;
 808
 809                 if (exts) {
 810                     for (ei = 0, el = exts.length; ei < el; ei++) {
 811                         extProto = exts[ei].prototype;
 812                         if (extProto.hasOwnProperty(DESTRUCTOR)) {
 813                             extProto.destructor.apply(this, arguments);
 814                         }
 815                     }
 816                 }
 817
 818                 if (constrProto.hasOwnProperty(DESTRUCTOR)) {
 819                     constrProto.destructor.apply(this, arguments);
 820                 }
 821             }
 822         },
 823
 824         /**
 825          * Default toString implementation. Provides the constructor NAME
 826          * and the instance guid, if set.
 827          *
 828          * @method toString
 829          * @return {String} String representation for this object
 830          */
 831         toString: function() {
 832             return this.name + "[" + Y.stamp(this, true) + "]";
 833         }
 834     };
 835
 836     // Straightup augment, no wrapper functions
 837     Y.mix(BaseCore, AttributeCore, false, null, 1);
 838
 839     // Fix constructor
 840     BaseCore.prototype.constructor = BaseCore;
 841
 842     Y.BaseCore = BaseCore;
 843
 844
 845 }, '3.13.0', {"requires": ["attribute-core"]});