extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/src/perf/Accumulator.js

@@ -0,0 +1,244 @@
+/**
+ * @class Ext.perf.Accumulator
+ * @private
+ */
+Ext.define('Ext.perf.Accumulator', (function () {
+    var currentFrame = null,
+        khrome = Ext.global['chrome'],
+        formatTpl,
+        // lazy init on first request for timestamp (avoids infobar in IE until needed)
+        // Also avoids kicking off Chrome's microsecond timer until first needed
+        getTimestamp = function () {
+
+            getTimestamp = function () {
+                return new Date().getTime();
+            };
+            
+            var interval, toolbox;
+
+            // If Chrome is started with the --enable-benchmarking switch
+            if (Ext.isChrome && khrome && khrome.Interval) {
+                interval = new khrome.Interval();
+                interval.start();
+                getTimestamp = function () {
+                    return interval.microseconds() / 1000;
+                };
+            } else if (window.ActiveXObject) {
+                try {
+                    // the above technique is not very accurate for small intervals...
+                    toolbox = new ActiveXObject('SenchaToolbox.Toolbox');
+                    Ext.senchaToolbox = toolbox; // export for other uses
+                    getTimestamp = function () {
+                        return toolbox.milliseconds;
+                    };
+                } catch (e) {
+                    // ignore
+                }
+            } else if (Date.now) {
+                getTimestamp = Date.now;
+            }
+
+            Ext.perf.getTimestamp = Ext.perf.Accumulator.getTimestamp = getTimestamp;
+            return getTimestamp();
+        };
+
+    function adjustSet (set, time) {
+        set.sum += time;
+        set.min = Math.min(set.min, time);
+        set.max = Math.max(set.max, time);
+    }
+
+    function leaveFrame (time) {
+        var totalTime = time ? time : (getTimestamp() - this.time), // do this first
+            me = this, // me = frame
+            accum = me.accum;
+
+        ++accum.count;
+        if (! --accum.depth) {
+            adjustSet(accum.total, totalTime);
+        }
+        adjustSet(accum.pure, totalTime - me.childTime);
+
+        currentFrame = me.parent;
+        if (currentFrame) {
+            ++currentFrame.accum.childCount;
+            currentFrame.childTime += totalTime;
+        }
+    }
+
+    function makeSet () {
+        return {
+            min: Number.MAX_VALUE,
+            max: 0,
+            sum: 0
+        };
+    }
+
+    function makeTap (me, fn) {
+        return function () {
+            var frame = me.enter(),
+                ret = fn.apply(this, arguments);
+
+            frame.leave();
+            return ret;
+        };
+    }
+
+    function round (x) {
+        return Math.round(x * 100) / 100;
+    }
+
+    function setToJSON (count, childCount, calibration, set) {
+        var data = {
+            avg: 0,
+            min: set.min,
+            max: set.max,
+            sum: 0
+        };
+
+        if (count) {
+            calibration = calibration || 0;
+            data.sum = set.sum - childCount * calibration;
+            data.avg = data.sum / count;
+            // min and max cannot be easily corrected since we don't know the number of
+            // child calls for them.
+        }
+
+        return data;
+    }
+
+    return {
+        constructor: function (name) {
+            var me = this;
+
+            me.count = me.childCount = me.depth = me.maxDepth = 0;
+            me.pure = makeSet();
+            me.total = makeSet();
+            me.name = name;
+        },
+
+        statics: {
+            getTimestamp: getTimestamp
+        },
+
+        format: function (calibration) {
+            if (!formatTpl) {
+                formatTpl = new Ext.XTemplate([
+                        '{name} - {count} call(s)',
+                        '<tpl if="count">',
+                            '<tpl if="childCount">',
+                                ' ({childCount} children)',
+                            '</tpl>',
+                            '<tpl if="depth - 1">',
+                                ' ({depth} deep)',
+                            '</tpl>',
+                            '<tpl for="times">',
+                                ', {type}: {[this.time(values.sum)]} msec (',
+                                     //'min={[this.time(values.min)]}, ',
+                                     'avg={[this.time(values.sum / parent.count)]}',
+                                     //', max={[this.time(values.max)]}',
+                                     ')',
+                            '</tpl>',
+                        '</tpl>'
+                    ].join(''), {
+                        time: function (t) {
+                            return Math.round(t * 100) / 100;
+                        }
+                    });
+            }
+
+            var data = this.getData(calibration);
+            data.name = this.name;
+            data.pure.type = 'Pure';
+            data.total.type = 'Total';
+            data.times = [data.pure, data.total];
+            return formatTpl.apply(data);
+        },
+
+        getData: function (calibration) {
+            var me = this;
+
+            return {
+                count: me.count,
+                childCount: me.childCount,
+                depth: me.maxDepth,
+                pure: setToJSON(me.count, me.childCount, calibration, me.pure),
+                total: setToJSON(me.count, me.childCount, calibration, me.total)
+            };
+        },
+
+        enter: function () {
+            var me = this,
+                frame = {
+                    accum: me,
+                    leave: leaveFrame,
+                    childTime: 0,
+                    parent: currentFrame
+                };
+
+            ++me.depth;
+            if (me.maxDepth < me.depth) {
+                me.maxDepth = me.depth;
+            }
+
+            currentFrame = frame;
+            frame.time = getTimestamp(); // do this last
+            return frame;
+        },
+
+        monitor: function (fn, scope, args) {
+            var frame = this.enter();
+            if (args) {
+                fn.apply(scope, args);
+            } else {
+                fn.call(scope);
+            }
+            frame.leave();
+        },
+
+        report: function () {
+            Ext.log(this.format());
+        },
+
+        tap: function (className, methodName) {
+            var me = this,
+                methods = typeof methodName == 'string' ? [methodName] : methodName,
+                klass, statik, i, parts, length, name, src,
+                tapFunc;
+
+            tapFunc = function(){
+                if (typeof className == 'string') {
+                    klass = Ext.global;
+                    parts = className.split('.');
+                    for (i = 0, length = parts.length; i < length; ++i) {
+                        klass = klass[parts[i]];
+                    }
+                } else {
+                    klass = className;
+                }
+
+                for (i = 0, length = methods.length; i < length; ++i) {
+                    name = methods[i];
+                    statik = name.charAt(0) == '!';
+
+                    if (statik) {
+                        name = name.substring(1);
+                    } else {
+                        statik = !(name in klass.prototype);
+                    }
+
+                    src = statik ? klass : klass.prototype;
+                    src[name] = makeTap(me, src[name]);
+                }
+            };
+
+            Ext.ClassManager.onCreated(tapFunc, me, className);
+
+            return me;
+        }
+    };
+}()),
+
+function () {
+    Ext.perf.getTimestamp = this.getTimestamp;
+});

data/app/assets/javascripts/extjs-rails/src/core/src/perf/Monitor.js

@@ -0,0 +1,197 @@
+/**
+ * @class Ext.perf.Monitor
+ * @singleton
+ * @private
+ */
+Ext.define('Ext.perf.Monitor', {
+    singleton: true,
+    alternateClassName: 'Ext.Perf',
+
+    requires: [
+        'Ext.perf.Accumulator'
+    ],
+
+    constructor: function () {
+        this.accumulators = [];
+        this.accumulatorsByName = {};
+    },
+
+    calibrate: function () {
+        var accum = new Ext.perf.Accumulator('$'),
+            total = accum.total,
+            getTimestamp = Ext.perf.Accumulator.getTimestamp,
+            count = 0,
+            frame,
+            endTime,
+            startTime;
+
+        startTime = getTimestamp();
+
+        do {
+            frame = accum.enter();
+            frame.leave();
+            ++count;
+        } while (total.sum < 100);
+
+        endTime = getTimestamp();
+
+        return (endTime - startTime) / count;
+    },
+
+    get: function (name) {
+        var me = this,
+            accum = me.accumulatorsByName[name];
+
+        if (!accum) {
+            me.accumulatorsByName[name] = accum = new Ext.perf.Accumulator(name);
+            me.accumulators.push(accum);
+        }
+
+        return accum;
+    },
+
+    enter: function (name) {
+        return this.get(name).enter();
+    },
+
+    monitor: function (name, fn, scope) {
+        this.get(name).monitor(fn, scope);
+    },
+
+    report: function () {
+        var me = this,
+            accumulators = me.accumulators,
+            calibration = me.calibrate();
+
+        accumulators.sort(function (a, b) {
+            return (a.name < b.name) ? -1 : ((b.name < a.name) ? 1 : 0);
+        });
+
+        me.updateGC();
+
+        Ext.log('Calibration: ' + Math.round(calibration * 100) / 100 + ' msec/sample');
+        Ext.each(accumulators, function (accum) {
+            Ext.log(accum.format(calibration));
+        });
+    },
+
+    getData: function (all) {
+        var ret = {},
+            accumulators = this.accumulators;
+
+        Ext.each(accumulators, function (accum) {
+            if (all || accum.count) {
+                ret[accum.name] = accum.getData();
+            }
+        });
+
+        return ret;
+    },
+
+    updateGC: function () {
+        var accumGC = this.accumulatorsByName.GC,
+            toolbox = Ext.senchaToolbox,
+            bucket;
+
+        if (accumGC) {
+            accumGC.count = toolbox.garbageCollectionCounter || 0;
+
+            if (accumGC.count) {
+                bucket = accumGC.pure;
+                accumGC.total.sum = bucket.sum = toolbox.garbageCollectionMilliseconds;
+                bucket.min = bucket.max = bucket.sum / accumGC.count;
+                bucket = accumGC.total;
+                bucket.min = bucket.max = bucket.sum / accumGC.count;
+            }
+        }
+    },
+
+    watchGC: function () {
+        Ext.perf.getTimestamp(); // initializes SenchaToolbox (if available)
+
+        var toolbox = Ext.senchaToolbox;
+
+        if (toolbox) {
+            this.get("GC");
+            toolbox.watchGarbageCollector(false); // no logging, just totals
+        }
+    },
+
+    setup: function (config) {
+        if (!config) {
+            config = {
+                /*insertHtml: {
+                    'Ext.dom.Helper': 'insertHtml'
+                },*/
+                /*xtplCompile: {
+                    'Ext.XTemplateCompiler': 'compile'
+                },*/
+//                doInsert: {
+//                    'Ext.Template': 'doInsert'
+//                },
+//                applyOut: {
+//                    'Ext.XTemplate': 'applyOut'
+//                },
+                render: {
+                    'Ext.AbstractComponent': 'render'
+                },
+//                fnishRender: {
+//                    'Ext.AbstractComponent': 'finishRender'
+//                },
+//                renderSelectors: {
+//                    'Ext.AbstractComponent': 'applyRenderSelectors'
+//                },
+//                compAddCls: {
+//                    'Ext.AbstractComponent': 'addCls'
+//                },
+//                compRemoveCls: {
+//                    'Ext.AbstractComponent': 'removeCls'
+//                },
+//                getStyle: {
+//                    'Ext.core.Element': 'getStyle'
+//                },
+//                setStyle: {
+//                    'Ext.core.Element': 'setStyle'
+//                },
+//                addCls: {
+//                    'Ext.core.Element': 'addCls'
+//                },
+//                removeCls: {
+//                    'Ext.core.Element': 'removeCls'
+//                },
+//                measure: {
+//                    'Ext.layout.component.Component': 'measureAutoDimensions'
+//                },
+//                moveItem: {
+//                    'Ext.layout.Layout': 'moveItem'
+//                },
+//                layoutFlush: {
+//                    'Ext.layout.Context': 'flush'
+//                },
+                layout: {
+                    'Ext.layout.Context': 'run'
+                }
+            };
+        }
+
+        this.currentConfig = config;
+
+        var key, prop,
+            accum, className, methods;
+        for (key in config) {
+            if (config.hasOwnProperty(key)) {
+                prop = config[key];
+                accum = Ext.Perf.get(key);
+
+                for (className in prop) {
+                    if (prop.hasOwnProperty(className)) {
+                        methods = prop[className];
+                        accum.tap(className, methods);
+                    }
+                }
+            }
+        }
+
+        this.watchGC();
+    }
+});

data/app/assets/javascripts/extjs-rails/src/core/src/util/DelayedTask.js

@@ -0,0 +1,71 @@
+/**
+ * @class Ext.util.DelayedTask
+ * 
+ * The DelayedTask class provides a convenient way to "buffer" the execution of a method,
+ * performing setTimeout where a new timeout cancels the old timeout. When called, the
+ * task will wait the specified time period before executing. If durng that time period,
+ * the task is called again, the original call will be cancelled. This continues so that
+ * the function is only called a single time for each iteration.
+ * 
+ * This method is especially useful for things like detecting whether a user has finished
+ * typing in a text field. An example would be performing validation on a keypress. You can
+ * use this class to buffer the keypress events for a certain number of milliseconds, and
+ * perform only if they stop for that amount of time.  
+ * 
+ * ## Usage
+ * 
+ *     var task = new Ext.util.DelayedTask(function(){
+ *         alert(Ext.getDom('myInputField').value.length);
+ *     });
+ *     
+ *     // Wait 500ms before calling our function. If the user presses another key
+ *     // during that 500ms, it will be cancelled and we'll wait another 500ms.
+ *     Ext.get('myInputField').on('keypress', function(){
+ *         task.{@link #delay}(500);
+ *     });
+ * 
+ * Note that we are using a DelayedTask here to illustrate a point. The configuration
+ * option `buffer` for {@link Ext.util.Observable#addListener addListener/on} will
+ * also setup a delayed task for you to buffer events.
+ * 
+ * @constructor The parameters to this constructor serve as defaults and are not required.
+ * @param {Function} fn (optional) The default function to call. If not specified here, it must be specified during the {@link #delay} call.
+ * @param {Object} scope (optional) The default scope (The <code><b>this</b></code> reference) in which the
+ * function is called. If not specified, <code>this</code> will refer to the browser window.
+ * @param {Array} args (optional) The default Array of arguments.
+ */
+Ext.util.DelayedTask = function(fn, scope, args) {
+    var me = this,
+        id,
+        call = function() {
+            clearInterval(id);
+            id = null;
+            fn.apply(scope, args || []);
+        };
+
+    /**
+     * Cancels any pending timeout and queues a new one
+     * @param {Number} delay The milliseconds to delay
+     * @param {Function} newFn (optional) Overrides function passed to constructor
+     * @param {Object} newScope (optional) Overrides scope passed to constructor. Remember that if no scope
+     * is specified, <code>this</code> will refer to the browser window.
+     * @param {Array} newArgs (optional) Overrides args passed to constructor
+     */
+    this.delay = function(delay, newFn, newScope, newArgs) {
+        me.cancel();
+        fn = newFn || fn;
+        scope = newScope || scope;
+        args = newArgs || args;
+        id = setInterval(call, delay);
+    };
+
+    /**
+     * Cancel the last queued timeout
+     */
+    this.cancel = function(){
+        if (id) {
+            clearInterval(id);
+            id = null;
+        }
+    };
+};