extjs-rails 4.1.0.alpha1

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

@@ -0,0 +1,417 @@
+/**
+ * Provides the ability to execute one or more arbitrary tasks in a asynchronous manner.
+ * Generally, you can use the singleton {@link Ext.TaskManager} instead, but if needed,
+ * you can create separate instances of TaskRunner. Any number of separate tasks can be
+ * started at any time and will run independently of each other.
+ * 
+ * Example usage:
+ *
+ *      // Start a simple clock task that updates a div once per second
+ *      var updateClock = function () {
+ *          Ext.fly('clock').update(new Date().format('g:i:s A'));
+ *      }
+ *
+ *      var runner = new Ext.util.TaskRunner();
+ *      var task = runner.start({
+ *          run: updateClock,
+ *          interval: 1000
+ *      }
+ *
+ * The equivalent using TaskManager:
+ *
+ *      var task = Ext.TaskManager.start({
+ *          run: updateClock,
+ *          interval: 1000
+ *      });
+ *
+ * To end a running task:
+ * 
+ *      task.destroy();
+ *
+ * If a task needs to be started and stopped repeated over time, you can create a
+ * {@link Ext.util.TaskRunner.Task Task} instance.
+ *
+ *      var task = runner.newTask({
+ *          run: function () {
+ *              // useful code
+ *          },
+ *          interval: 1000
+ *      });
+ *      
+ *      task.start();
+ *      
+ *      // ...
+ *      
+ *      task.stop();
+ *      
+ *      // ...
+ *      
+ *      task.start();
+ *
+ * A re-usable, one-shot task can be managed similar to the above:
+ *
+ *      var task = runner.newTask({
+ *          run: function () {
+ *              // useful code to run once
+ *          },
+ *          repeat: 1
+ *      });
+ *      
+ *      task.start();
+ *      
+ *      // ...
+ *      
+ *      task.start();
+ *
+ * See the {@link #start} method for details about how to configure a task object.
+ *
+ * Also see {@link Ext.util.DelayedTask}. 
+ * 
+ * @constructor
+ * @param {Number/Object} [interval=10] The minimum precision in milliseconds supported by this
+ * TaskRunner instance. Alternatively, a config object to apply to the new instance.
+ */
+Ext.define('Ext.util.TaskRunner', {
+    /**
+     * @cfg interval
+     * The timer resolution.
+     */
+    interval: 10,
+
+    /**
+     * @property timerId
+     * The id of the current timer.
+     * @private
+     */
+    timerId: null,
+
+    constructor: function (interval) {
+        var me = this;
+
+        if (typeof interval == 'number') {
+            me.interval = interval;
+        } else if (interval) {
+            Ext.apply(me, interval);
+        }
+
+        me.tasks = [];
+        me.timerFn = Ext.Function.bind(me.onTick, me);
+    },
+
+    /**
+     * Creates a new {@link Ext.util.TaskRunner.Task Task} instance. These instances can
+     * be easily started and stopped.
+     * @param {Object} config The config object. For details on the supported properties,
+     * see {@link #start}.
+     */
+    newTask: function (config) {
+        var task = new Ext.util.TaskRunner.Task(config);
+        task.manager = this;
+        return task;
+    },
+
+    /**
+     * Starts a new task.
+     *
+     * Before each invocation, Ext injects the property `taskRunCount` into the task object
+     * so that calculations based on the repeat count can be performed.
+     * 
+     * The returned task will contain a `destroy` method that can be used to destroy the
+     * task and cancel further calls. This is equivalent to the {@link #stop} method.
+     *
+     * @param {Object} task A config object that supports the following properties:
+     * @param {Function} task.run The function to execute each time the task is invoked. The
+     * function will be called at each interval and passed the `args` argument if specified,
+     * and the current invocation count if not.
+     * 
+     * If a particular scope (`this` reference) is required, be sure to specify it using
+     * the `scope` argument.
+     * 
+     * @param {Function} task.onError The function to execute in case of unhandled
+     * error on task.run.
+     *
+     * @param {Boolean} task.run.return `false` from this function to terminate the task.
+     *
+     * @param {Number} task.interval The frequency in milliseconds with which the task
+     * should be invoked.
+     *
+     * @param {Object[]} task.args An array of arguments to be passed to the function
+     * specified by `run`. If not specified, the current invocation count is passed.
+     *
+     * @param {Object} task.scope The scope (`this` reference) in which to execute the
+     * `run` function. Defaults to the task config object.
+     *
+     * @param {Number} task.duration The length of time in milliseconds to invoke the task
+     * before stopping automatically (defaults to indefinite).
+     *
+     * @param {Number} task.repeat The number of times to invoke the task before stopping
+     * automatically (defaults to indefinite).
+     * @return {Object} The task
+     */
+    start: function(task) {
+        var me = this,
+            now = new Date().getTime();
+
+        if (!task.pending) {
+            me.tasks.push(task);
+            task.pending = true; // don't allow the task to be added to me.tasks again
+        }
+
+        task.stopped = false; // might have been previously stopped...
+        task.taskStartTime = now;
+        task.taskRunTime = task.fireOnStart !== false ? 0 : task.taskStartTime;
+        task.taskRunCount = 0;
+
+        if (!me.firing) {
+            if (task.fireOnStart !== false) {
+                me.startTimer(0, now);
+            } else {
+                me.startTimer(task.interval, now);
+            }
+        }
+
+        return task;
+    },
+
+    /**
+     * Stops an existing running task.
+     * @param {Object} task The task to stop
+     * @return {Object} The task
+     */
+    stop: function(task) {
+        // NOTE: we don't attempt to remove the task from me.tasks at this point because
+        // this could be called from inside a task which would then corrupt the state of
+        // the loop in onTick
+        if (!task.stopped) {
+            task.stopped = true;
+
+            if (task.onStop) {
+                task.onStop.call(task.scope || task, task);
+            }
+        }
+
+        return task;
+    },
+
+    /**
+     * Stops all tasks that are currently running.
+     */
+    stopAll: function() {
+        // onTick will take care of cleaning up the mess after this point...
+        Ext.each(this.tasks, this.stop, this);
+    },
+
+    //-------------------------------------------------------------------------
+
+    firing: false,
+
+    nextExpires: 1e99,
+
+    // private
+    onTick: function () {
+        var me = this,
+            tasks = me.tasks,
+            now = new Date().getTime(),
+            nextExpires = 1e99,
+            len = tasks.length,
+            expires, newTasks, i, task, rt, remove;
+
+        me.timerId = null;
+        me.firing = true; // ensure we don't startTimer during this loop...
+
+        // tasks.length can be > len if start is called during a task.run call... so we
+        // first check len to avoid tasks.length reference but eventually we need to also
+        // check tasks.length. we avoid repeating use of tasks.length by setting len at
+        // that time (to help the next loop)
+        for (i = 0; i < len || i < (len = tasks.length); ++i) {
+            task = tasks[i];
+
+            if (!(remove = task.stopped)) {
+                expires = task.taskRunTime + task.interval;
+
+                if (expires <= now) {
+                    rt = 1; // otherwise we have a stale "rt"
+                    try {
+                        rt = task.run.apply(task.scope || task, task.args || [++task.taskRunCount]);
+                    } catch (taskError) {
+                        try {
+                            if (task.onError) {
+                                rt = task.onError.call(task.scope || task, task, taskError);
+                            }
+                        } catch (ignore) { }
+                    }
+                    task.taskRunTime = now;
+                    if (rt === false || task.taskRunCount === task.repeat) {
+                        me.stop(task);
+                        remove = true;
+                    } else {
+                        remove = task.stopped; // in case stop was called by run
+                        expires = now + task.interval;
+                    }
+                }
+
+                if (!remove && task.duration && task.duration <= (now - task.taskStartTime)) {
+                    me.stop(task);
+                    remove = true;
+                }
+            }
+
+            if (remove) {
+                task.pending = false; // allow the task to be added to me.tasks again
+
+                // once we detect that a task needs to be removed, we copy the tasks that
+                // will carry forward into newTasks... this way we avoid O(N*N) to remove
+                // each task from the tasks array (and ripple the array down) and also the
+                // potentially wasted effort of making a new tasks[] even if all tasks are
+                // going into the next wave.
+                if (!newTasks) {
+                    newTasks = tasks.slice(0, i);
+                    // we don't set me.tasks here because callbacks can also start tasks,
+                    // which get added to me.tasks... so we will visit them in this loop
+                    // and account for their expirations in nextExpires...
+                }
+            } else {
+                if (newTasks) {
+                    newTasks.push(task); // we've cloned the tasks[], so keep this one...
+                }
+
+                if (nextExpires > expires) {
+                    nextExpires = expires; // track the nearest expiration time
+                }
+            }
+        }
+
+        if (newTasks) {
+            // only now can we copy the newTasks to me.tasks since no user callbacks can
+            // take place
+            me.tasks = newTasks;
+        }
+
+        me.firing = false; // we're done, so allow startTimer afterwards
+
+        if (me.tasks.length) {
+            // we create a new Date here because all the callbacks could have taken a long
+            // time... we want to base the next timeout on the current time (after the
+            // callback storm):
+            me.startTimer(nextExpires - now, new Date().getTime());
+        }
+    },
+
+    // private
+    startTimer: function (timeout, now) {
+        var me = this,
+            expires = now + timeout,
+            timerId = me.timerId;
+
+        // Check to see if this request is enough in advance of the current timer. If so,
+        // we reschedule the timer based on this new expiration.
+        if (timerId && me.nextExpires - expires > me.interval) {
+            clearTimeout(timerId);
+            timerId = null;
+        }
+
+        if (!timerId) {
+            if (timeout < me.interval) {
+                timeout = me.interval;
+            }
+
+            me.timerId = setTimeout(me.timerFn, timeout);
+            me.nextExpires = expires;
+        }
+    }
+},
+function () {
+    var me = this,
+        proto = me.prototype;
+
+    /**
+     * Destroys this instance, stopping all tasks that are currently running.
+     * @method destroy
+     */
+    proto.destroy = proto.stopAll;
+
+    /**
+    * @class Ext.TaskManager
+    * @extends Ext.util.TaskRunner
+    * @singleton
+    *
+    * A static {@link Ext.util.TaskRunner} instance that can be used to start and stop
+    * arbitrary tasks. See {@link Ext.util.TaskRunner} for supported methods and task
+    * config properties.
+    *
+    *    // Start a simple clock task that updates a div once per second
+    *    var task = {
+    *       run: function(){
+    *           Ext.fly('clock').update(new Date().format('g:i:s A'));
+    *       },
+    *       interval: 1000 //1 second
+    *    }
+    *
+    *    Ext.TaskManager.start(task);
+    *
+    * See the {@link #start} method for details about how to configure a task object.
+    */
+    Ext.util.TaskManager = Ext.TaskManager = new me();
+
+    /**
+     * Instances of this class are created by {@link Ext.util.TaskRunner#newTask} method.
+     * 
+     * For details on config properties, see {@link Ext.util.TaskRunner#start}.
+     * @class Ext.util.TaskRunner.Task
+     */
+    me.Task = new Ext.Class({
+        isTask: true,
+
+        /**
+         * This flag is set to `true` by {@link #stop}.
+         * @private
+         */
+        stopped: true, // this avoids the odd combination of !stopped && !pending
+
+        /**
+         * Override default behavior
+         */
+        fireOnStart: false,
+
+        constructor: function (config) {
+            Ext.apply(this, config);
+        },
+
+        /**
+         * Restarts this task, clearing it duration, expiration and run count.
+         * @param {Number} [interval] Optionally reset this task's interval.
+         */
+        restart: function (interval) {
+            if (interval !== undefined) {
+                this.interval = interval;
+            }
+
+            this.manager.start(this);
+        },
+
+        /**
+         * Starts this task if it is not already started.
+         * @param {Number} [interval] Optionally reset this task's interval.
+         */
+        start: function (interval) {
+            if (this.stopped) {
+                this.restart(interval);
+            }
+        },
+
+        /**
+         * Stops this task.
+         */
+        stop: function () {
+            this.manager.stop(this);
+        }
+    });
+
+    proto = me.Task.prototype;
+
+    /**
+     * Destroys this instance, stopping this task's execution.
+     * @method destroy
+     */
+    proto.destroy = proto.stop;
+});

data/app/assets/javascripts/extjs-rails/src/core/src/version/Version.js

@@ -0,0 +1,364 @@
+/**
+ * @author Jacky Nguyen <jacky@sencha.com>
+ * @docauthor Jacky Nguyen <jacky@sencha.com>
+ * @class Ext.Version
+ *
+ * A utility class that wrap around a string version number and provide convenient
+ * method to perform comparison. See also: {@link Ext.Version#compare compare}. Example:
+
+    var version = new Ext.Version('1.0.2beta');
+    console.log("Version is " + version); // Version is 1.0.2beta
+
+    console.log(version.getMajor()); // 1
+    console.log(version.getMinor()); // 0
+    console.log(version.getPatch()); // 2
+    console.log(version.getBuild()); // 0
+    console.log(version.getRelease()); // beta
+
+    console.log(version.isGreaterThan('1.0.1')); // True
+    console.log(version.isGreaterThan('1.0.2alpha')); // True
+    console.log(version.isGreaterThan('1.0.2RC')); // False
+    console.log(version.isGreaterThan('1.0.2')); // False
+    console.log(version.isLessThan('1.0.2')); // True
+
+    console.log(version.match(1.0)); // True
+    console.log(version.match('1.0.2')); // True
+
+ * @markdown
+ */
+(function() {
+
+// Current core version
+var version = '4.1.0', Version;
+    Ext.Version = Version = Ext.extend(Object, {
+
+        /**
+         * @param {String/Number} version The version number in the follow standard format: major[.minor[.patch[.build[release]]]]
+         * Examples: 1.0 or 1.2.3beta or 1.2.3.4RC
+         * @return {Ext.Version} this
+         */
+        constructor: function(version) {
+            var parts, releaseStartIndex;
+
+            if (version instanceof Version) {
+                return version;
+            }
+
+            this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
+
+            releaseStartIndex = this.version.search(/([^\d\.])/);
+
+            if (releaseStartIndex !== -1) {
+                this.release = this.version.substr(releaseStartIndex, version.length);
+                this.shortVersion = this.version.substr(0, releaseStartIndex);
+            }
+
+            this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
+
+            parts = this.version.split('.');
+
+            this.major = parseInt(parts.shift() || 0, 10);
+            this.minor = parseInt(parts.shift() || 0, 10);
+            this.patch = parseInt(parts.shift() || 0, 10);
+            this.build = parseInt(parts.shift() || 0, 10);
+
+            return this;
+        },
+
+        /**
+         * Override the native toString method
+         * @private
+         * @return {String} version
+         */
+        toString: function() {
+            return this.version;
+        },
+
+        /**
+         * Override the native valueOf method
+         * @private
+         * @return {String} version
+         */
+        valueOf: function() {
+            return this.version;
+        },
+
+        /**
+         * Returns the major component value
+         * @return {Number} major
+         */
+        getMajor: function() {
+            return this.major || 0;
+        },
+
+        /**
+         * Returns the minor component value
+         * @return {Number} minor
+         */
+        getMinor: function() {
+            return this.minor || 0;
+        },
+
+        /**
+         * Returns the patch component value
+         * @return {Number} patch
+         */
+        getPatch: function() {
+            return this.patch || 0;
+        },
+
+        /**
+         * Returns the build component value
+         * @return {Number} build
+         */
+        getBuild: function() {
+            return this.build || 0;
+        },
+
+        /**
+         * Returns the release component value
+         * @return {Number} release
+         */
+        getRelease: function() {
+            return this.release || '';
+        },
+
+        /**
+         * Returns whether this version if greater than the supplied argument
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version if greater than the target, false otherwise
+         */
+        isGreaterThan: function(target) {
+            return Version.compare(this.version, target) === 1;
+        },
+
+        /**
+         * Returns whether this version if greater than or equal to the supplied argument
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version if greater than or equal to the target, false otherwise
+         */
+        isGreaterThanOrEqual: function(target) {
+            return Version.compare(this.version, target) >= 0;
+        },
+
+        /**
+         * Returns whether this version if smaller than the supplied argument
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version if smaller than the target, false otherwise
+         */
+        isLessThan: function(target) {
+            return Version.compare(this.version, target) === -1;
+        },
+
+        /**
+         * Returns whether this version if less than or equal to the supplied argument
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version if less than or equal to the target, false otherwise
+         */
+        isLessThanOrEqual: function(target) {
+            return Version.compare(this.version, target) <= 0;
+        },
+
+        /**
+         * Returns whether this version equals to the supplied argument
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version equals to the target, false otherwise
+         */
+        equals: function(target) {
+            return Version.compare(this.version, target) === 0;
+        },
+
+        /**
+         * Returns whether this version matches the supplied argument. Example:
+         * <pre><code>
+         * var version = new Ext.Version('1.0.2beta');
+         * console.log(version.match(1)); // True
+         * console.log(version.match(1.0)); // True
+         * console.log(version.match('1.0.2')); // True
+         * console.log(version.match('1.0.2RC')); // False
+         * </code></pre>
+         * @param {String/Number} target The version to compare with
+         * @return {Boolean} True if this version matches the target, false otherwise
+         */
+        match: function(target) {
+            target = String(target);
+            return this.version.substr(0, target.length) === target;
+        },
+
+        /**
+         * Returns this format: [major, minor, patch, build, release]. Useful for comparison
+         * @return {Number[]}
+         */
+        toArray: function() {
+            return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
+        },
+
+        /**
+         * Returns shortVersion version without dots and release
+         * @return {String}
+         */
+        getShortVersion: function() {
+            return this.shortVersion;
+        },
+
+        /**
+         * Convenient alias to {@link Ext.Version#isGreaterThan isGreaterThan}
+         * @param {String/Number} target
+         * @return {Boolean}
+         */
+        gt: function() {
+            return this.isGreaterThan.apply(this, arguments);
+        },
+
+        /**
+         * Convenient alias to {@link Ext.Version#isLessThan isLessThan}
+         * @param {String/Number} target
+         * @return {Boolean}
+         */
+        lt: function() {
+            return this.isLessThan.apply(this, arguments);
+        },
+
+        /**
+         * Convenient alias to {@link Ext.Version#isGreaterThanOrEqual isGreaterThanOrEqual}
+         * @param {String/Number} target
+         * @return {Boolean}
+         */
+        gtEq: function() {
+            return this.isGreaterThanOrEqual.apply(this, arguments);
+        },
+
+        /**
+         * Convenient alias to {@link Ext.Version#isLessThanOrEqual isLessThanOrEqual}
+         * @param {String/Number} target
+         * @return {Boolean}
+         */
+        ltEq: function() {
+            return this.isLessThanOrEqual.apply(this, arguments);
+        }
+    });
+
+    Ext.apply(Version, {
+        // @private
+        releaseValueMap: {
+            'dev': -6,
+            'alpha': -5,
+            'a': -5,
+            'beta': -4,
+            'b': -4,
+            'rc': -3,
+            '#': -2,
+            'p': -1,
+            'pl': -1
+        },
+
+        /**
+         * Converts a version component to a comparable value
+         *
+         * @static
+         * @param {Object} value The value to convert
+         * @return {Object}
+         */
+        getComponentValue: function(value) {
+            return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
+        },
+
+        /**
+         * Compare 2 specified versions, starting from left to right. If a part contains special version strings,
+         * they are handled in the following order:
+         * 'dev' < 'alpha' = 'a' < 'beta' = 'b' < 'RC' = 'rc' < '#' < 'pl' = 'p' < 'anything else'
+         *
+         * @static
+         * @param {String} current The current version to compare to
+         * @param {String} target The target version to compare to
+         * @return {Number} Returns -1 if the current version is smaller than the target version, 1 if greater, and 0 if they're equivalent
+         */
+        compare: function(current, target) {
+            var currentValue, targetValue, i;
+
+            current = new Version(current).toArray();
+            target = new Version(target).toArray();
+
+            for (i = 0; i < Math.max(current.length, target.length); i++) {
+                currentValue = this.getComponentValue(current[i]);
+                targetValue = this.getComponentValue(target[i]);
+
+                if (currentValue < targetValue) {
+                    return -1;
+                } else if (currentValue > targetValue) {
+                    return 1;
+                }
+            }
+
+            return 0;
+        }
+    });
+
+    Ext.apply(Ext, {
+        /**
+         * @private
+         */
+        versions: {},
+
+        /**
+         * @private
+         */
+        lastRegisteredVersion: null,
+
+        /**
+         * Set version number for the given package name.
+         *
+         * @param {String} packageName The package name, for example: 'core', 'touch', 'extjs'
+         * @param {String/Ext.Version} version The version, for example: '1.2.3alpha', '2.4.0-dev'
+         * @return {Ext}
+         */
+        setVersion: function(packageName, version) {
+            Ext.versions[packageName] = new Version(version);
+            Ext.lastRegisteredVersion = Ext.versions[packageName];
+
+            return this;
+        },
+
+        /**
+         * Get the version number of the supplied package name; will return the last registered version
+         * (last Ext.setVersion call) if there's no package name given.
+         *
+         * @param {String} packageName (Optional) The package name, for example: 'core', 'touch', 'extjs'
+         * @return {Ext.Version} The version
+         */
+        getVersion: function(packageName) {
+            if (packageName === undefined) {
+                return Ext.lastRegisteredVersion;
+            }
+
+            return Ext.versions[packageName];
+        },
+
+        /**
+         * Create a closure for deprecated code.
+         *
+    // This means Ext.oldMethod is only supported in 4.0.0beta and older.
+    // If Ext.getVersion('extjs') returns a version that is later than '4.0.0beta', for example '4.0.0RC',
+    // the closure will not be invoked
+    Ext.deprecate('extjs', '4.0.0beta', function() {
+        Ext.oldMethod = Ext.newMethod;
+
+        ...
+    });
+
+         * @param {String} packageName The package name
+         * @param {String} since The last version before it's deprecated
+         * @param {Function} closure The callback function to be executed with the specified version is less than the current version
+         * @param {Object} scope The execution scope (<tt>this</tt>) if the closure
+         * @markdown
+         */
+        deprecate: function(packageName, since, closure, scope) {
+            if (Version.compare(Ext.getVersion(packageName), since) < 1) {
+                closure.call(scope);
+            }
+        }
+    }); // End Versioning
+
+    Ext.setVersion('core', version);
+
+}());