← Back to branch summary

~ubuntu-branches/ubuntu/precise/maas/precise-security

« back to all changes in this revision

Viewing changes to src/maasserver/static/jslibs/yui/3.4.1/build/base-base/base-base-debug.js

Tags: 1.2+bzr1373+dfsg-0ubuntu1~12.04.4
https://launchpad.net/bugs/1039513
https://launchpad.net/bugs/1158425
* SECURITY UPDATE: failure to authenticate downloaded content (LP: #1039513)
  - debian/patches/CVE-2013-1058.patch: Authenticate downloaded files with
    GnuPG and MD5SUM files. Thanks to Julian Edwards.
  - CVE-2013-1058
* SECURITY UPDATE: configuration options may be loaded from current working
  directory (LP: #1158425)
  - debian/patches/CVE-2013-1057-1-2.patch: Do not load configuration
    options from the current working directory. Thanks to Julian Edwards.
  - CVE-2013-1057

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/jslibs/yui/3.4.1/build/base-base/base-base-debug.js
1
 
/*
2
 
YUI 3.4.1 (build 4118)
3
 
Copyright 2011 Yahoo! Inc. All rights reserved.
4
 
Licensed under the BSD License.
5
 
http://yuilibrary.com/license/
6
 
*/
7
 
YUI.add('base-base', function(Y) {
8
 
 
9
 
    /**
10
 
     * The base module provides the Base class, which objects requiring attribute and custom event support can extend. 
11
 
     * The module also provides two ways to reuse code - It augments Base with the Plugin.Host interface which provides 
12
 
     * plugin support and also provides the Base.build method which provides a way to build custom classes using extensions.
13
 
     *
14
 
     * @module base
15
 
     */
16
 
 
17
 
    /**
18
 
     * The base-base submodule provides the Base class without the Plugin support, provided by Plugin.Host, 
19
 
     * and without the extension support provided by Base.build.
20
 
     *
21
 
     * @module base
22
 
     * @submodule base-base
23
 
     */
24
 
    var O = Y.Object,
25
 
        L = Y.Lang,
26
 
        DOT = ".",
27
 
        DESTROY = "destroy",
28
 
        INIT = "init",
29
 
        INITIALIZED = "initialized",
30
 
        DESTROYED = "destroyed",
31
 
        INITIALIZER = "initializer",
32
 
        BUBBLETARGETS = "bubbleTargets",
33
 
        _BUBBLETARGETS = "_bubbleTargets",
34
 
        OBJECT_CONSTRUCTOR = Object.prototype.constructor,
35
 
        DEEP = "deep",
36
 
        SHALLOW = "shallow",
37
 
        DESTRUCTOR = "destructor",
38
 
 
39
 
        Attribute = Y.Attribute,
40
 
 
41
 
        _wlmix = function(r, s, wlhash) {
42
 
            var p;
43
 
            for (p in s) {
44
 
                if(wlhash[p]) { 
45
 
                    r[p] = s[p];
46
 
                }
47
 
            }
48
 
            return r;
49
 
        };
50
 
 
51
 
    /**
52
 
     * <p>
53
 
     * A base class which objects requiring attributes and custom event support can 
54
 
     * extend. Base also handles the chaining of initializer and destructor methods across 
55
 
     * the hierarchy as part of object construction and destruction. Additionally, attributes configured 
56
 
     * through the static <a href="#property_Base.ATTRS">ATTRS</a> property for each class 
57
 
     * in the hierarchy will be initialized by Base.
58
 
     * </p>
59
 
     *
60
 
     * <p>
61
 
     * The static <a href="#property_Base.NAME">NAME</a> property of each class extending 
62
 
     * from Base will be used as the identifier for the class, and is used by Base to prefix 
63
 
     * all events fired by instances of that class.
64
 
     * </p>
65
 
     *
66
 
     * @class Base
67
 
     * @constructor
68
 
     * @uses Attribute
69
 
     * @uses Plugin.Host
70
 
     *
71
 
     * @param {Object} config Object with configuration property name/value pairs. The object can be 
72
 
     * used to provide default values for the objects published attributes.
73
 
     *
74
 
     * <p>
75
 
     * The config object can also contain the following non-attribute properties, providing a convenient 
76
 
     * way to configure events listeners and plugins for the instance, as part of the constructor call:
77
 
     * </p>
78
 
     *
79
 
     * <dl>
80
 
     *     <dt>on</dt>
81
 
     *     <dd>An event name to listener function map, to register event listeners for the "on" moment of the event. A constructor convenience property for the <a href="Base.html#method_on">on</a> method.</dd>
82
 
     *     <dt>after</dt>
83
 
     *     <dd>An event name to listener function map, to register event listeners for the "after" moment of the event. A constructor convenience property for the <a href="Base.html#method_after">after</a> method.</dd>
84
 
     *     <dt>bubbleTargets</dt>
85
 
     *     <dd>An object, or array of objects, to register as bubble targets for bubbled events fired by this instance. A constructor convenience property for the <a href="EventTarget.html#method_addTarget">addTarget</a> method.</dd>
86
 
     *     <dt>plugins</dt>
87
 
     *     <dd>A plugin, or array of plugins to be plugged into the instance (see PluginHost's plug method for signature details). A constructor convenience property for the <a href="Plugin.Host.html#method_plug">plug</a> method.</dd>
88
 
     * </dl>
89
 
     */
90
 
    function Base() {
91
 
        Y.log('constructor called', 'life', 'base');
92
 
 
93
 
        // So the object can be used as a hash key (as DD does)
94
 
        Y.stamp(this);
95
 
 
96
 
        Attribute.call(this);
97
 
 
98
 
        // If Plugin.Host has been augmented [ through base-pluginhost ], setup it's
99
 
        // initial state, but don't initialize Plugins yet. That's done after initialization.
100
 
        var PluginHost = Y.Plugin && Y.Plugin.Host;  
101
 
        if (this._initPlugins && PluginHost) {
102
 
            PluginHost.call(this);
103
 
        }
104
 
 
105
 
        if (this._lazyAddAttrs !== false) { this._lazyAddAttrs = true; }
106
 
 
107
 
        /**
108
 
         * The string used to identify the class of this object.
109
 
         *
110
 
         * @deprecated Use this.constructor.NAME
111
 
         * @property name
112
 
         * @type String
113
 
         */
114
 
        this.name = this.constructor.NAME;
115
 
        this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;
116
 
 
117
 
        this.init.apply(this, arguments);
118
 
    }
119
 
 
120
 
    /**
121
 
     * The list of properties which can be configured for 
122
 
     * each attribute (e.g. setter, getter, writeOnce, readOnly etc.)
123
 
     *
124
 
     * @property _ATTR_CFG
125
 
     * @type Array
126
 
     * @static
127
 
     * @private
128
 
     */
129
 
    Base._ATTR_CFG = Attribute._ATTR_CFG.concat("cloneDefaultValue");
130
 
    Base._ATTR_CFG_HASH = Y.Array.hash(Base._ATTR_CFG);
131
 
 
132
 
    /**
133
 
     * <p>
134
 
     * The string to be used to identify instances of 
135
 
     * this class, for example in prefixing events.
136
 
     * </p>
137
 
     * <p>
138
 
     * Classes extending Base, should define their own
139
 
     * static NAME property, which should be camelCase by
140
 
     * convention (e.g. MyClass.NAME = "myClass";).
141
 
     * </p>
142
 
     * @property NAME
143
 
     * @type String
144
 
     * @static
145
 
     */
146
 
    Base.NAME = "base";
147
 
 
148
 
    /**
149
 
     * The default set of attributes which will be available for instances of this class, and 
150
 
     * their configuration. In addition to the configuration properties listed by 
151
 
     * Attribute's <a href="Attribute.html#method_addAttr">addAttr</a> method, the attribute 
152
 
     * can also be configured with a "cloneDefaultValue" property, which defines how the statically
153
 
     * defined value field should be protected ("shallow", "deep" and false are supported values). 
154
 
     *
155
 
     * By default if the value is an object literal or an array it will be "shallow" cloned, to 
156
 
     * protect the default value.
157
 
     *
158
 
     * @property ATTRS
159
 
     * @type Object
160
 
     * @static
161
 
     */
162
 
    Base.ATTRS = {
163
 
        /**
164
 
         * Flag indicating whether or not this object
165
 
         * has been through the init lifecycle phase.
166
 
         *
167
 
         * @attribute initialized
168
 
         * @readonly
169
 
         * @default false
170
 
         * @type boolean
171
 
         */
172
 
        initialized: {
173
 
            readOnly:true,
174
 
            value:false
175
 
        },
176
 
 
177
 
        /**
178
 
         * Flag indicating whether or not this object
179
 
         * has been through the destroy lifecycle phase.
180
 
         *
181
 
         * @attribute destroyed
182
 
         * @readonly
183
 
         * @default false
184
 
         * @type boolean
185
 
         */
186
 
        destroyed: {
187
 
            readOnly:true,
188
 
            value:false
189
 
        }
190
 
    };
191
 
 
192
 
    Base.prototype = {
193
 
 
194
 
        /**
195
 
         * Init lifecycle method, invoked during construction.
196
 
         * Fires the init event prior to setting up attributes and 
197
 
         * invoking initializers for the class hierarchy.
198
 
         *
199
 
         * @method init
200
 
         * @chainable
201
 
         * @param {Object} config Object with configuration property name/value pairs
202
 
         * @return {Base} A reference to this object
203
 
         */
204
 
        init: function(config) {
205
 
            Y.log('init called', 'life', 'base');
206
 
 
207
 
            this._yuievt.config.prefix = this._eventPrefix;
208
 
 
209
 
            /**
210
 
             * <p>
211
 
             * Lifecycle event for the init phase, fired prior to initialization. 
212
 
             * Invoking the preventDefault() method on the event object provided 
213
 
             * to subscribers will prevent initialization from occuring.
214
 
             * </p>
215
 
             * <p>
216
 
             * Subscribers to the "after" momemt of this event, will be notified
217
 
             * after initialization of the object is complete (and therefore
218
 
             * cannot prevent initialization).
219
 
             * </p>
220
 
             *
221
 
             * @event init
222
 
             * @preventable _defInitFn
223
 
             * @param {EventFacade} e Event object, with a cfg property which 
224
 
             * refers to the configuration object passed to the constructor.
225
 
             */
226
 
            this.publish(INIT, {
227
 
                queuable:false,
228
 
                fireOnce:true,
229
 
                defaultTargetOnly:true,
230
 
                defaultFn:this._defInitFn
231
 
            });
232
 
 
233
 
            this._preInitEventCfg(config);
234
 
 
235
 
            this.fire(INIT, {cfg: config});
236
 
 
237
 
            return this;
238
 
        },
239
 
 
240
 
        /**
241
 
         * Handles the special on, after and target properties which allow the user to
242
 
         * easily configure on and after listeners as well as bubble targets during 
243
 
         * construction, prior to init.
244
 
         *
245
 
         * @private
246
 
         * @method _preInitEventCfg
247
 
         * @param {Object} config The user configuration object
248
 
         */
249
 
        _preInitEventCfg : function(config) {
250
 
            if (config) {
251
 
                if (config.on) {
252
 
                    this.on(config.on);
253
 
                }
254
 
                if (config.after) {
255
 
                    this.after(config.after);
256
 
                }
257
 
            }
258
 
 
259
 
            var i, l, target,
260
 
                userTargets = (config && BUBBLETARGETS in config);
261
 
 
262
 
            if (userTargets || _BUBBLETARGETS in this) {
263
 
                target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;
264
 
                if (L.isArray(target)) {
265
 
                    for (i = 0, l = target.length; i < l; i++) { 
266
 
                        this.addTarget(target[i]);
267
 
                    }
268
 
                } else if (target) {
269
 
                    this.addTarget(target);
270
 
                }
271
 
            }
272
 
        },
273
 
 
274
 
        /**
275
 
         * <p>
276
 
         * Destroy lifecycle method. Fires the destroy
277
 
         * event, prior to invoking destructors for the
278
 
         * class hierarchy.
279
 
         * </p>
280
 
         * <p>
281
 
         * Subscribers to the destroy
282
 
         * event can invoke preventDefault on the event object, to prevent destruction
283
 
         * from proceeding.
284
 
         * </p>
285
 
         * @method destroy
286
 
         * @return {Base} A reference to this object
287
 
         * @chainable
288
 
         */
289
 
        destroy: function() {
290
 
            Y.log('destroy called', 'life', 'base');
291
 
 
292
 
            /**
293
 
             * <p>
294
 
             * Lifecycle event for the destroy phase, 
295
 
             * fired prior to destruction. Invoking the preventDefault 
296
 
             * method on the event object provided to subscribers will 
297
 
             * prevent destruction from proceeding.
298
 
             * </p>
299
 
             * <p>
300
 
             * Subscribers to the "after" moment of this event, will be notified
301
 
             * after destruction is complete (and as a result cannot prevent
302
 
             * destruction).
303
 
             * </p>
304
 
             * @event destroy
305
 
             * @preventable _defDestroyFn
306
 
             * @param {EventFacade} e Event object
307
 
             */
308
 
            this.publish(DESTROY, {
309
 
                queuable:false,
310
 
                fireOnce:true,
311
 
                defaultTargetOnly:true,
312
 
                defaultFn: this._defDestroyFn
313
 
            });
314
 
            this.fire(DESTROY);
315
 
 
316
 
            this.detachAll();
317
 
            return this;
318
 
        },
319
 
 
320
 
        /**
321
 
         * Default init event handler
322
 
         *
323
 
         * @method _defInitFn
324
 
         * @param {EventFacade} e Event object, with a cfg property which 
325
 
         * refers to the configuration object passed to the constructor.
326
 
         * @protected
327
 
         */
328
 
        _defInitFn : function(e) {
329
 
            this._initHierarchy(e.cfg);
330
 
            if (this._initPlugins) {
331
 
                // Need to initPlugins manually, to handle constructor parsing, static Plug parsing
332
 
                this._initPlugins(e.cfg);
333
 
            }
334
 
            this._set(INITIALIZED, true);
335
 
        },
336
 
 
337
 
        /**
338
 
         * Default destroy event handler
339
 
         *
340
 
         * @method _defDestroyFn
341
 
         * @param {EventFacade} e Event object
342
 
         * @protected
343
 
         */
344
 
        _defDestroyFn : function(e) {
345
 
            if (this._destroyPlugins) {
346
 
                this._destroyPlugins();
347
 
            }
348
 
            this._destroyHierarchy();
349
 
            this._set(DESTROYED, true);
350
 
        },
351
 
 
352
 
        /**
353
 
         * Returns the class hierarchy for this object, with Base being the last class in the array.
354
 
         *
355
 
         * @method _getClasses
356
 
         * @protected
357
 
         * @return {Function[]} An array of classes (constructor functions), making up the class hierarchy for this object.
358
 
         * This value is cached the first time the method, or _getAttrCfgs, is invoked. Subsequent invocations return the 
359
 
         * cached value.
360
 
         */
361
 
        _getClasses : function() {
362
 
            if (!this._classes) {
363
 
                this._initHierarchyData();
364
 
            }
365
 
            return this._classes;
366
 
        },
367
 
 
368
 
        /**
369
 
         * Returns an aggregated set of attribute configurations, by traversing the class hierarchy.
370
 
         *
371
 
         * @method _getAttrCfgs
372
 
         * @protected
373
 
         * @return {Object} The hash of attribute configurations, aggregated across classes in the hierarchy
374
 
         * This value is cached the first time the method, or _getClasses, is invoked. Subsequent invocations return
375
 
         * the cached value.
376
 
         */
377
 
        _getAttrCfgs : function() {
378
 
            if (!this._attrs) {
379
 
                this._initHierarchyData();
380
 
            }
381
 
            return this._attrs;
382
 
        },
383
 
 
384
 
        /**
385
 
         * A helper method used when processing ATTRS across the class hierarchy during 
386
 
         * initialization. Returns a disposable object with the attributes defined for 
387
 
         * the provided class, extracted from the set of all attributes passed in .
388
 
         *
389
 
         * @method _filterAttrCfs
390
 
         * @private
391
 
         *
392
 
         * @param {Function} clazz The class for which the desired attributes are required.
393
 
         * @param {Object} allCfgs The set of all attribute configurations for this instance. 
394
 
         * Attributes will be removed from this set, if they belong to the filtered class, so
395
 
         * that by the time all classes are processed, allCfgs will be empty.
396
 
         * 
397
 
         * @return {Object} The set of attributes belonging to the class passed in, in the form
398
 
         * of an object with attribute name/configuration pairs.
399
 
         */
400
 
        _filterAttrCfgs : function(clazz, allCfgs) {
401
 
            var cfgs = null, attr, attrs = clazz.ATTRS;
402
 
 
403
 
            if (attrs) {
404
 
                for (attr in attrs) {
405
 
                    if (allCfgs[attr]) {
406
 
                        cfgs = cfgs || {};
407
 
                        cfgs[attr] = allCfgs[attr];
408
 
                        allCfgs[attr] = null;
409
 
                    }
410
 
                }
411
 
            }
412
 
 
413
 
            return cfgs;
414
 
        },
415
 
 
416
 
        /**
417
 
         * A helper method used by _getClasses and _getAttrCfgs, which determines both
418
 
         * the array of classes and aggregate set of attribute configurations
419
 
         * across the class hierarchy for the instance.
420
 
         *
421
 
         * @method _initHierarchyData
422
 
         * @private
423
 
         */
424
 
        _initHierarchyData : function() {
425
 
            var c = this.constructor,
426
 
                classes = [],
427
 
                attrs = [];
428
 
 
429
 
            while (c) {
430
 
                // Add to classes
431
 
                classes[classes.length] = c;
432
 
 
433
 
                // Add to attributes
434
 
                if (c.ATTRS) {
435
 
                    attrs[attrs.length] = c.ATTRS;
436
 
                }
437
 
                c = c.superclass ? c.superclass.constructor : null;
438
 
            }
439
 
 
440
 
            this._classes = classes;
441
 
            this._attrs = this._aggregateAttrs(attrs);
442
 
        },
443
 
 
444
 
        /**
445
 
         * A helper method, used by _initHierarchyData to aggregate 
446
 
         * attribute configuration across the instances class hierarchy.
447
 
         *
448
 
         * The method will protect the attribute configuration value to protect the statically defined 
449
 
         * default value in ATTRS if required (if the value is an object literal, array or the 
450
 
         * attribute configuration has cloneDefaultValue set to shallow or deep).
451
 
         *
452
 
         * @method _aggregateAttrs
453
 
         * @private
454
 
         * @param {Array} allAttrs An array of ATTRS definitions across classes in the hierarchy 
455
 
         * (subclass first, Base last)
456
 
         * @return {Object} The aggregate set of ATTRS definitions for the instance
457
 
         */
458
 
        _aggregateAttrs : function(allAttrs) {
459
 
            var attr,
460
 
                attrs,
461
 
                cfg,
462
 
                val,
463
 
                path,
464
 
                i,
465
 
                clone, 
466
 
                cfgPropsHash = Base._ATTR_CFG_HASH,
467
 
                aggAttrs = {};
468
 
 
469
 
            if (allAttrs) {
470
 
                for (i = allAttrs.length-1; i >= 0; --i) {
471
 
                    attrs = allAttrs[i];
472
 
 
473
 
                    for (attr in attrs) {
474
 
                        if (attrs.hasOwnProperty(attr)) {
475
 
 
476
 
                            // Protect config passed in
477
 
                            //cfg = Y.mix({}, attrs[attr], true, cfgProps);
478
 
                            //cfg = Y.Object(attrs[attr]);
479
 
                            cfg = _wlmix({}, attrs[attr], cfgPropsHash);
480
 
 
481
 
                            val = cfg.value;
482
 
                            clone = cfg.cloneDefaultValue;
483
 
 
484
 
                            if (val) {
485
 
                                if ( (clone === undefined && (OBJECT_CONSTRUCTOR === val.constructor || L.isArray(val))) || clone === DEEP || clone === true) {
486
 
                                    Y.log('Cloning default value for attribute:' + attr, 'info', 'base');
487
 
                                    cfg.value = Y.clone(val);
488
 
                                } else if (clone === SHALLOW) {
489
 
                                    Y.log('Merging default value for attribute:' + attr, 'info', 'base');
490
 
                                    cfg.value = Y.merge(val);
491
 
                                }
492
 
                                // else if (clone === false), don't clone the static default value. 
493
 
                                // It's intended to be used by reference.
494
 
                            }
495
 
 
496
 
                            path = null;
497
 
                            if (attr.indexOf(DOT) !== -1) {
498
 
                                path = attr.split(DOT);
499
 
                                attr = path.shift();
500
 
                            }
501
 
 
502
 
                            if (path && aggAttrs[attr] && aggAttrs[attr].value) {
503
 
                                O.setValue(aggAttrs[attr].value, path, val);
504
 
                            } else if (!path) {
505
 
                                if (!aggAttrs[attr]) {
506
 
                                    aggAttrs[attr] = cfg;
507
 
                                } else {
508
 
                                    _wlmix(aggAttrs[attr], cfg, cfgPropsHash);
509
 
                                }
510
 
                            }
511
 
                        }
512
 
                    }
513
 
                }
514
 
            }
515
 
 
516
 
            return aggAttrs;
517
 
        },
518
 
 
519
 
        /**
520
 
         * Initializes the class hierarchy for the instance, which includes 
521
 
         * initializing attributes for each class defined in the class's 
522
 
         * static <a href="#property_Base.ATTRS">ATTRS</a> property and 
523
 
         * invoking the initializer method on the prototype of each class in the hierarchy.
524
 
         *
525
 
         * @method _initHierarchy
526
 
         * @param {Object} userVals Object with configuration property name/value pairs
527
 
         * @private
528
 
         */
529
 
        _initHierarchy : function(userVals) {
530
 
            var lazy = this._lazyAddAttrs,
531
 
                constr,
532
 
                constrProto,
533
 
                ci,
534
 
                ei,
535
 
                el,
536
 
                extProto,
537
 
                exts,
538
 
                classes = this._getClasses(),
539
 
                attrCfgs = this._getAttrCfgs();
540
 
 
541
 
            for (ci = classes.length-1; ci >= 0; ci--) {
542
 
 
543
 
                constr = classes[ci];
544
 
                constrProto = constr.prototype;
545
 
                exts = constr._yuibuild && constr._yuibuild.exts; 
546
 
 
547
 
                if (exts) {
548
 
                    for (ei = 0, el = exts.length; ei < el; ei++) {
549
 
                        exts[ei].apply(this, arguments);
550
 
                    }
551
 
                }
552
 
 
553
 
                this.addAttrs(this._filterAttrCfgs(constr, attrCfgs), userVals, lazy);
554
 
 
555
 
                // Using INITIALIZER in hasOwnProperty check, for performance reasons (helps IE6 avoid GC thresholds when
556
 
                // referencing string literals). Not using it in apply, again, for performance "." is faster. 
557
 
                if (constrProto.hasOwnProperty(INITIALIZER)) {
558
 
                    constrProto.initializer.apply(this, arguments);
559
 
                }
560
 
 
561
 
                if (exts) {
562
 
                    for (ei = 0; ei < el; ei++) {
563
 
                        extProto = exts[ei].prototype;
564
 
                        if (extProto.hasOwnProperty(INITIALIZER)) {
565
 
                            extProto.initializer.apply(this, arguments);
566
 
                        }
567
 
                    }
568
 
                }
569
 
            }
570
 
        },
571
 
 
572
 
        /**
573
 
         * Destroys the class hierarchy for this instance by invoking
574
 
         * the destructor method on the prototype of each class in the hierarchy.
575
 
         *
576
 
         * @method _destroyHierarchy
577
 
         * @private
578
 
         */
579
 
        _destroyHierarchy : function() {
580
 
            var constr,
581
 
                constrProto,
582
 
                ci, cl, ei, el, exts, extProto,
583
 
                classes = this._getClasses();
584
 
 
585
 
            for (ci = 0, cl = classes.length; ci < cl; ci++) {
586
 
                constr = classes[ci];
587
 
                constrProto = constr.prototype;
588
 
                exts = constr._yuibuild && constr._yuibuild.exts; 
589
 
 
590
 
                if (exts) {
591
 
                    for (ei = 0, el = exts.length; ei < el; ei++) {
592
 
                        extProto = exts[ei].prototype;
593
 
                        if (extProto.hasOwnProperty(DESTRUCTOR)) {
594
 
                            extProto.destructor.apply(this, arguments);
595
 
                        }
596
 
                    }
597
 
                }
598
 
 
599
 
                if (constrProto.hasOwnProperty(DESTRUCTOR)) {
600
 
                    constrProto.destructor.apply(this, arguments);
601
 
                }
602
 
            }
603
 
        },
604
 
 
605
 
        /**
606
 
         * Default toString implementation. Provides the constructor NAME
607
 
         * and the instance guid, if set.
608
 
         *
609
 
         * @method toString
610
 
         * @return {String} String representation for this object
611
 
         */
612
 
        toString: function() {
613
 
            return this.name + "[" + Y.stamp(this, true) + "]";
614
 
        }
615
 
 
616
 
    };
617
 
 
618
 
    // Straightup augment, no wrapper functions
619
 
    Y.mix(Base, Attribute, false, null, 1);
620
 
 
621
 
    // Fix constructor
622
 
    Base.prototype.constructor = Base;
623
 
 
624
 
    Y.Base = Base;
625
 
 
626
 
 
627
 
}, '3.4.1' ,{requires:['attribute-base']});