← Back to branch summary

~ubuntu-branches/ubuntu/raring/maas/raring-updates

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2012-07-03 17:42:37 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20120703174237-p8l0keuuznfg721k
Tags: 0.1+bzr709+dfsg-0ubuntu1
* New Upstream release
* debian/control:
  - Depends on python-celery, python-tempita, libjs-yui3-{full,min},
    libjs-raphael
* debian/maas.install:
  - Install apiclient, celeryconfig.py, maas-import-pxe-files, preseeds_v2.
  - Update to install various files from chroot, rather tha manually copy
    them from the source.
* debian/maas.links: symlink celeryconfig.py
* debian/maas.maas-celery.upstart: Add job.
* debian/rules:
  - Install celery upstart job.
  - Do not install jslibs as packages are now used.
  - Drop copying of maas_local_settings_sample.py as source now ships
    a maas_local_settings.py
* debian/patches:
  - 04-maas-http-fix.patch: Drop. Merged upstream.
  - 01-fix-database-settings.patch: Refreshed.
  - 99_enums_js.patch: Added until creation of enum.js / build process
    is fixed.
* debian/maas.postinst: Update bzr version to correctly handle upgrades.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/static/jslibs/yui/3.4.1/build/profiler/profiler-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('profiler', function(Y) {
8
 
 
9
 
    /**
10
 
     * The YUI JavaScript profiler.
11
 
     * @module profiler
12
 
     */
13
 
     
14
 
    //-------------------------------------------------------------------------
15
 
    // Private Variables and Functions
16
 
    //-------------------------------------------------------------------------
17
 
    
18
 
    var container   = {},   //Container object on which to put the original unprofiled methods.
19
 
        report      = {},   //Profiling information for functions
20
 
        stopwatches = {},   //Additional stopwatch information
21
 
        
22
 
        WATCH_STARTED   = 0,
23
 
        WATCH_STOPPED   = 1,
24
 
        WATCH_PAUSED    = 2,    
25
 
        
26
 
        //shortcuts
27
 
        L   = Y.Lang;
28
 
 
29
 
    /* (intentionally not documented)
30
 
     * Creates a report object with the given name.
31
 
     * @param {String} name The name to store for the report object.
32
 
     * @return {Void}
33
 
     * @method createReport
34
 
     * @private
35
 
     */
36
 
    function createReport(name){
37
 
        report[name] = {
38
 
            calls: 0,
39
 
            max: 0,
40
 
            min: 0,
41
 
            avg: 0,
42
 
            points: []
43
 
        };
44
 
        return report[name];
45
 
    }
46
 
    
47
 
    /* (intentionally not documented)
48
 
     * Called when a method ends execution. Marks the start and end time of the 
49
 
     * method so it can calculate how long the function took to execute. Also 
50
 
     * updates min/max/avg calculations for the function.
51
 
     * @param {String} name The name of the function to mark as stopped.
52
 
     * @param {int} duration The number of milliseconds it took the function to
53
 
     *      execute.
54
 
     * @return {Void}
55
 
     * @method saveDataPoint
56
 
     * @private
57
 
     * @static
58
 
     */
59
 
    function saveDataPoint(name, duration){
60
 
 
61
 
        //get the function data
62
 
        var functionData /*:Object*/ = report[name];
63
 
        
64
 
        //just in case clear() was called
65
 
        if (!functionData){
66
 
            functionData = createReport(name);
67
 
        }
68
 
    
69
 
        //increment the calls
70
 
        functionData.calls++;
71
 
        functionData.points.push(duration);
72
 
 
73
 
        //if it's already been called at least once, do more complex calculations
74
 
        if (functionData.calls > 1) {
75
 
            functionData.avg = ((functionData.avg*(functionData.calls-1))+duration)/functionData.calls;
76
 
            functionData.min = Math.min(functionData.min, duration);
77
 
            functionData.max = Math.max(functionData.max, duration);
78
 
        } else {
79
 
            functionData.avg = duration;
80
 
            functionData.min = duration;
81
 
            functionData.max = duration;
82
 
        }                             
83
 
    
84
 
    }
85
 
    
86
 
    //-------------------------------------------------------------------------
87
 
    // Public Interface
88
 
    //-------------------------------------------------------------------------
89
 
    
90
 
    /**
91
 
     * Profiles functions in JavaScript.
92
 
     * @class Profiler
93
 
     * @static
94
 
     */
95
 
    Y.Profiler = {
96
 
    
97
 
        //-------------------------------------------------------------------------
98
 
        // Utility Methods
99
 
        //-------------------------------------------------------------------------        
100
 
        
101
 
        /**
102
 
         * Removes all report data from the profiler.
103
 
         * @param {String} name (Optional) The name of the report to clear. If
104
 
         *      omitted, then all report data is cleared.
105
 
         * @return {Void}
106
 
         * @method clear
107
 
         * @static
108
 
         */
109
 
        clear: function(name){
110
 
            if (L.isString(name)){
111
 
                delete report[name];
112
 
                delete stopwatches[name];
113
 
            } else {
114
 
                report = {};
115
 
                stopwatches = {};
116
 
            }
117
 
        },
118
 
 
119
 
        /**
120
 
         * Returns the uninstrumented version of a function/object.
121
 
         * @param {String} name The name of the function/object to retrieve.
122
 
         * @return {Function|Object} The uninstrumented version of a function/object.
123
 
         * @method getOriginal
124
 
         * @static
125
 
         */    
126
 
        getOriginal: function(name){
127
 
            return container[name];
128
 
        },
129
 
    
130
 
        /**
131
 
         * Instruments a method to have profiling calls.
132
 
         * @param {String} name The name of the report for the function.
133
 
         * @param {Function} method The function to instrument.
134
 
         * @return {Function} An instrumented version of the function.
135
 
         * @method instrument
136
 
         * @static
137
 
         */
138
 
        instrument: function(name, method){
139
 
        
140
 
            //create instrumented version of function
141
 
            var newMethod = function () {
142
 
    
143
 
                var start = new Date(),
144
 
                    retval = method.apply(this, arguments),
145
 
                    stop = new Date();
146
 
                
147
 
                saveDataPoint(name, stop-start);
148
 
                
149
 
                return retval;                
150
 
            
151
 
            };     
152
 
 
153
 
            //copy the function properties over
154
 
            Y.mix(newMethod, method);
155
 
            
156
 
            //assign prototype and flag as being profiled
157
 
            newMethod.__yuiProfiled = true;
158
 
            newMethod.prototype = method.prototype;
159
 
            
160
 
            //store original method
161
 
            container[name] = method;
162
 
            container[name].__yuiFuncName = name;
163
 
            
164
 
            //create the report
165
 
            createReport(name);
166
 
 
167
 
            //return the new method
168
 
            return newMethod;
169
 
        },    
170
 
        
171
 
        //-------------------------------------------------------------------------
172
 
        // Stopwatch Methods
173
 
        //-------------------------------------------------------------------------        
174
 
        
175
 
        /**
176
 
         * Pauses profiling information for a given name.
177
 
         * @param {String} name The name of the data point.
178
 
         * @return {Void}
179
 
         * @method pause
180
 
         * @static
181
 
         */        
182
 
        pause: function(name){
183
 
            var now = new Date(),
184
 
                stopwatch = stopwatches[name];
185
 
                
186
 
            if (stopwatch && stopwatch.state == WATCH_STARTED){
187
 
                stopwatch.total += (now - stopwatch.start);
188
 
                stopwatch.start = 0;
189
 
                stopwatch.state = WATCH_PAUSED;
190
 
            }
191
 
        
192
 
        },
193
 
        
194
 
        /**
195
 
         * Start profiling information for a given name. The name cannot be the name
196
 
         * of a registered function or object. This is used to start timing for a
197
 
         * particular block of code rather than instrumenting the entire function.
198
 
         * @param {String} name The name of the data point.
199
 
         * @return {Void}
200
 
         * @method start
201
 
         * @static
202
 
         */
203
 
        start: function(name){
204
 
            if(container[name]){
205
 
                throw new Error("Cannot use '" + name + "' for profiling through start(), name is already in use.");
206
 
            } else {
207
 
            
208
 
                //create report if necessary
209
 
                if (!report[name]){
210
 
                    createReport(name);
211
 
                }
212
 
                
213
 
                //create stopwatch object if necessary
214
 
                if (!stopwatches[name]){             
215
 
                    stopwatches[name] = {
216
 
                        state: WATCH_STOPPED,
217
 
                        start: 0,
218
 
                        total: 0
219
 
                    };
220
 
                }
221
 
                
222
 
                if (stopwatches[name].state == WATCH_STOPPED){
223
 
                    stopwatches[name].state = WATCH_STARTED;
224
 
                    stopwatches[name].start = new Date();                    
225
 
                }
226
 
 
227
 
            }
228
 
        },
229
 
        
230
 
        /**
231
 
         * Stops profiling information for a given name.
232
 
         * @param {String} name The name of the data point.
233
 
         * @return {Void}
234
 
         * @method stop
235
 
         * @static
236
 
         */
237
 
        stop: function(name){
238
 
            var now = new Date(),
239
 
                stopwatch = stopwatches[name];
240
 
                
241
 
            if (stopwatch){
242
 
                if (stopwatch.state == WATCH_STARTED){
243
 
                    saveDataPoint(name, stopwatch.total + (now - stopwatch.start));                    
244
 
                } else if (stopwatch.state == WATCH_PAUSED){
245
 
                    saveDataPoint(name, stopwatch.total);
246
 
                }
247
 
                
248
 
                //reset stopwatch information
249
 
                stopwatch.start = 0;
250
 
                stopwatch.total = 0;
251
 
                stopwatch.state = WATCH_STOPPED;                
252
 
            }
253
 
        },
254
 
    
255
 
        //-------------------------------------------------------------------------
256
 
        // Reporting Methods
257
 
        //-------------------------------------------------------------------------    
258
 
        
259
 
        /**
260
 
         * Returns the average amount of time (in milliseconds) that the function
261
 
         * with the given name takes to execute.
262
 
         * @param {String} name The name of the function whose data should be returned.
263
 
         *      If an object type method, it should be 'constructor.prototype.methodName';
264
 
         *      a normal object method would just be 'object.methodName'.
265
 
         * @return {float} The average time it takes the function to execute.
266
 
         * @method getAverage
267
 
         * @static
268
 
         */
269
 
        getAverage : function (name /*:String*/) /*:float*/ {
270
 
            return report[name].avg;
271
 
        },
272
 
    
273
 
        /**
274
 
         * Returns the number of times that the given function has been called.
275
 
         * @param {String} name The name of the function whose data should be returned.
276
 
         * @return {int} The number of times the function was called.
277
 
         * @method getCallCount
278
 
         * @static
279
 
         */
280
 
        getCallCount : function (name /*:String*/) /*:int*/ {
281
 
            return report[name].calls;    
282
 
        },
283
 
        
284
 
        /**
285
 
         * Returns the maximum amount of time (in milliseconds) that the function
286
 
         * with the given name takes to execute.
287
 
         * @param {String} name The name of the function whose data should be returned.
288
 
         *      If an object type method, it should be 'constructor.prototype.methodName';
289
 
         *      a normal object method would just be 'object.methodName'.
290
 
         * @return {float} The maximum time it takes the function to execute.
291
 
         * @method getMax
292
 
         * @static
293
 
         */
294
 
        getMax : function (name /*:String*/) /*:int*/ {
295
 
            return report[name].max;
296
 
        },
297
 
        
298
 
        /**
299
 
         * Returns the minimum amount of time (in milliseconds) that the function
300
 
         * with the given name takes to execute.
301
 
         * @param {String} name The name of the function whose data should be returned.
302
 
         *      If an object type method, it should be 'constructor.prototype.methodName';
303
 
         *      a normal object method would just be 'object.methodName'.
304
 
         * @return {float} The minimum time it takes the function to execute.
305
 
         * @method getMin
306
 
         * @static
307
 
         */
308
 
        getMin : function (name /*:String*/) /*:int*/ {
309
 
            return report[name].min;
310
 
        },
311
 
    
312
 
        /**
313
 
         * Returns an object containing profiling data for a single function.
314
 
         * The object has an entry for min, max, avg, calls, and points).
315
 
         * @return {Object} An object containing profile data for a given function.
316
 
         * @method getFunctionReport
317
 
         * @static
318
 
         * @deprecated Use getReport() instead.
319
 
         */
320
 
        getFunctionReport : function (name /*:String*/) /*:Object*/ {
321
 
            return report[name];
322
 
        },
323
 
    
324
 
        /**
325
 
         * Returns an object containing profiling data for a single function.
326
 
         * The object has an entry for min, max, avg, calls, and points).
327
 
         * @return {Object} An object containing profile data for a given function.
328
 
         * @method getReport
329
 
         * @static
330
 
         */
331
 
        getReport : function (name /*:String*/) /*:Object*/ {
332
 
            return report[name];
333
 
        },
334
 
    
335
 
        /**
336
 
         * Returns an object containing profiling data for all of the functions 
337
 
         * that were profiled. The object has an entry for each function and 
338
 
         * returns all information (min, max, average, calls, etc.) for each
339
 
         * function.
340
 
         * @return {Object} An object containing all profile data.
341
 
         * @method getFullReport
342
 
         * @static
343
 
         */
344
 
        getFullReport : function (filter /*:Function*/) /*:Object*/ {
345
 
            filter = filter || function(){return true;};
346
 
        
347
 
            if (L.isFunction(filter)) {
348
 
                var fullReport = {};
349
 
                
350
 
                for (var name in report){
351
 
                    if (filter(report[name])){
352
 
                        fullReport[name] = report[name];    
353
 
                    }
354
 
                }
355
 
                
356
 
                return fullReport;
357
 
            }
358
 
        },
359
 
    
360
 
        //-------------------------------------------------------------------------
361
 
        // Profiling Methods
362
 
        //-------------------------------------------------------------------------   
363
 
        
364
 
        /**
365
 
         * Sets up a constructor for profiling, including all properties and methods on the prototype.
366
 
         * @param {string} name The fully-qualified name of the function including namespace information.
367
 
         * @param {Object} owner (Optional) The object that owns the function (namespace or containing object).
368
 
         * @return {Void}
369
 
         * @method registerConstructor
370
 
         * @static
371
 
         */
372
 
        registerConstructor : function (name /*:String*/, owner /*:Object*/) /*:Void*/ {    
373
 
            this.registerFunction(name, owner, true);
374
 
        },
375
 
    
376
 
        /**
377
 
         * Sets up a function for profiling. It essentially overwrites the function with one
378
 
         * that has instrumentation data. This method also creates an entry for the function
379
 
         * in the profile report. The original function is stored on the container object.
380
 
         * @param {String} name The full name of the function including namespacing. This
381
 
         *      is the name of the function that is stored in the report.
382
 
         * @param {Object} owner (Optional) The object that owns the function. If the function
383
 
         *      isn't global then this argument is required. This could be the namespace that
384
 
         *      the function belongs to or the object on which it's
385
 
         *      a method.
386
 
         * @param {Boolean} registerPrototype (Optional) Indicates that the prototype should
387
 
         *      also be instrumented. Setting to true has the same effect as calling
388
 
         *      registerConstructor().
389
 
         * @return {Void}
390
 
         * @method registerFunction
391
 
         * @static
392
 
         */     
393
 
        registerFunction : function(name /*:String*/, owner /*:Object*/, registerPrototype /*:Boolean*/) /*:Void*/{
394
 
        
395
 
            //figure out the function name without namespacing
396
 
            var funcName = (name.indexOf(".") > -1 ? 
397
 
                    name.substring(name.lastIndexOf(".")+1) : name),
398
 
                method,
399
 
                prototype;
400
 
                
401
 
            //if owner isn't an object, try to find it from the name
402
 
            if (!L.isObject(owner)){
403
 
                owner = eval(name.substring(0, name.lastIndexOf(".")));
404
 
            }
405
 
            
406
 
            //get the method and prototype
407
 
            method = owner[funcName];
408
 
            prototype = method.prototype;
409
 
            
410
 
            //see if the method has already been registered
411
 
            if (L.isFunction(method) && !method.__yuiProfiled){
412
 
                
413
 
                //replace the function with the profiling one
414
 
                owner[funcName] = this.instrument(name, method);
415
 
                        
416
 
                /*
417
 
                 * Store original function information. We store the actual
418
 
                 * function as well as the owner and the name used to identify
419
 
                 * the function so it can be restored later.
420
 
                 */
421
 
                container[name].__yuiOwner = owner;
422
 
                container[name].__yuiFuncName = funcName;  //overwrite with less-specific name
423
 
                 
424
 
                //register prototype if necessary
425
 
                if (registerPrototype) {            
426
 
                    this.registerObject(name + ".prototype", prototype);          
427
 
                }
428
 
    
429
 
            }
430
 
        
431
 
        },
432
 
            
433
 
        
434
 
        /**
435
 
         * Sets up an object for profiling. It takes the object and looks for functions.
436
 
         * When a function is found, registerMethod() is called on it. If set to recrusive
437
 
         * mode, it will also setup objects found inside of this object for profiling, 
438
 
         * using the same methodology.
439
 
         * @param {String} name The name of the object to profile (shows up in report).
440
 
         * @param {Object} owner (Optional) The object represented by the name.
441
 
         * @param {Boolean} recurse (Optional) Determines if subobject methods are also profiled.
442
 
         * @return {Void}
443
 
         * @method registerObject
444
 
         * @static
445
 
         */
446
 
        registerObject : function (name /*:String*/, object /*:Object*/, recurse /*:Boolean*/) /*:Void*/{
447
 
        
448
 
            //get the object
449
 
            object = (L.isObject(object) ? object : eval(name));
450
 
        
451
 
            //save the object
452
 
            container[name] = object;
453
 
        
454
 
            for (var prop in object) {
455
 
                if (typeof object[prop] == "function"){
456
 
                    if (prop != "constructor" && prop != "superclass"){ //don't do constructor or superclass, it's recursive
457
 
                        this.registerFunction(name + "." + prop, object);
458
 
                    }
459
 
                } else if (typeof object[prop] == "object" && recurse){
460
 
                    this.registerObject(name + "." + prop, object[prop], recurse);
461
 
                }
462
 
            }
463
 
        
464
 
        },    
465
 
        
466
 
        /**
467
 
         * Removes a constructor function from profiling. Reverses the registerConstructor() method.
468
 
         * @param {String} name The full name of the function including namespacing. This
469
 
         *      is the name of the function that is stored in the report.
470
 
         * @return {Void}
471
 
         * @method unregisterFunction
472
 
         * @static
473
 
         */     
474
 
        unregisterConstructor : function(name /*:String*/) /*:Void*/{
475
 
                
476
 
            //see if the method has been registered
477
 
            if (L.isFunction(container[name])){
478
 
                this.unregisterFunction(name, true);
479
 
            }    
480
 
        },
481
 
        
482
 
        /**
483
 
         * Removes function from profiling. Reverses the registerFunction() method.
484
 
         * @param {String} name The full name of the function including namespacing. This
485
 
         *      is the name of the function that is stored in the report.
486
 
         * @return {Void}
487
 
         * @method unregisterFunction
488
 
         * @static
489
 
         */     
490
 
        unregisterFunction : function(name /*:String*/, unregisterPrototype /*:Boolean*/) /*:Void*/{
491
 
                
492
 
            //see if the method has been registered
493
 
            if (L.isFunction(container[name])){
494
 
            
495
 
                //check to see if you should unregister the prototype
496
 
                if (unregisterPrototype){
497
 
                    this.unregisterObject(name + ".prototype", container[name].prototype);
498
 
                }
499
 
                    
500
 
                //get original data
501
 
                var owner /*:Object*/ = container[name].__yuiOwner,
502
 
                    funcName /*:String*/ = container[name].__yuiFuncName;
503
 
                    
504
 
                //delete extra information
505
 
                delete container[name].__yuiOwner;
506
 
                delete container[name].__yuiFuncName;
507
 
                
508
 
                //replace instrumented function
509
 
                owner[funcName] = container[name];
510
 
                
511
 
                //delete supporting information
512
 
                delete container[name];          
513
 
            }
514
 
                
515
 
        
516
 
        },
517
 
        
518
 
        /**
519
 
         * Unregisters an object for profiling. It takes the object and looks for functions.
520
 
         * When a function is found, unregisterMethod() is called on it. If set to recrusive
521
 
         * mode, it will also unregister objects found inside of this object, 
522
 
         * using the same methodology.
523
 
         * @param {String} name The name of the object to unregister.
524
 
         * @param {Boolean} recurse (Optional) Determines if subobject methods should also be
525
 
         *      unregistered.
526
 
         * @return {Void}
527
 
         * @method unregisterObject
528
 
         * @static
529
 
         */
530
 
        unregisterObject : function (name /*:String*/, recurse /*:Boolean*/) /*:Void*/{
531
 
        
532
 
            //get the object
533
 
            if (L.isObject(container[name])){            
534
 
                var object = container[name];    
535
 
            
536
 
                for (var prop in object) {
537
 
                    if (typeof object[prop] == "function"){
538
 
                        this.unregisterFunction(name + "." + prop);
539
 
                    } else if (typeof object[prop] == "object" && recurse){
540
 
                        this.unregisterObject(name + "." + prop, recurse);
541
 
                    }
542
 
                }
543
 
                
544
 
                delete container[name];
545
 
            }
546
 
        
547
 
        }
548
 
             
549
 
    
550
 
    };
551
 
 
552
 
 
553
 
}, '3.4.1' ,{requires:['yui-base']});