extjs-rails 4.1.0.alpha1

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

@@ -0,0 +1,257 @@
+/**
+ * @private
+ * @class Ext.util.LruCache
+ * @extend Ext.util.HashMap
+ * A linked {@link Ext.util.HashMap HashMap} implementation which maintains most recently accessed
+ * items at the end of the list, and purges the cache down to the most recently accessed {@link #maxSize} items
+ * upon add.
+ */
+Ext.define('Ext.util.LruCache', {
+    extend: 'Ext.util.HashMap',
+
+    /**
+     * @cfg {Number} maxSize The maximum size the cache is allowed to grow to before further additions cause
+     * removal of the least recently used entry.
+     */
+
+    constructor: function(config) {
+        Ext.apply(this, config);
+        this.callParent([config]);
+    },
+
+    /*
+     * @inheritdoc
+     */
+    add: function(key, newValue) {
+        var me = this,
+            existingKey = me.findKey(newValue),
+            entry;
+
+        // "new" value is in the list.
+        if (existingKey) {
+            me.unlinkEntry(entry = me.map[existingKey]);
+            entry.prev = me.last;
+            entry.next = null;
+        }
+        // Genuinely new: create an entry for it.
+        else {
+            entry = {
+                prev: me.last,
+                next: null,
+                key: key,
+                value: newValue
+            };
+        }
+
+        // If the list is not empty, update the last entry
+        if (me.last) {
+            me.last.next = entry;
+        }
+        // List is empty
+        else {
+            me.first = entry;
+        }
+        me.last = entry;
+        me.callParent([key, entry]);
+        me.prune();
+        return newValue;
+    },
+
+    // @private
+    insertBefore: function(key, newValue, sibling) {
+        var me = this,
+            existingKey,
+            entry;
+
+        // NOT an assignment.
+        // If there is a following sibling
+        if (sibling = this.map[this.findKey(sibling)]) {
+            existingKey = me.findKey(newValue);
+
+            // "new" value is in the list.
+            if (existingKey) {
+                me.unlinkEntry(entry = me.map[existingKey]);
+            }
+            // Genuinely new: create an entry for it.
+            else {
+                entry = {
+                    prev: sibling.prev,
+                    next: sibling,
+                    key: key,
+                    value: newValue
+                };
+            }
+
+            if (sibling.prev) {
+                entry.prev.next = entry;
+            } else {
+                me.first = entry;
+            }
+            entry.next = sibling;
+            sibling.prev = entry;
+            me.prune();
+            return newValue;
+        }
+        // No following sibling, it's just an add.
+        else {
+            return me.add(key, newValue);
+        }
+    },
+
+    /*
+     * @inheritdoc
+     */
+    get: function(key) {
+        var entry = this.map[key];
+        if (entry) {
+
+            // If it's not the end, move to end of list on get
+            if (entry.next) {
+                this.moveToEnd(entry);
+            }
+            return entry.value;
+        }
+    },
+
+    /*
+     * @private
+     */
+    removeAtKey: function(key) {
+        this.unlinkEntry(this.map[key]);
+        return this.callParent(arguments);
+    },
+
+    /*
+     * @inheritdoc
+     */
+    clear: function(/* private */ initial) {
+        this.first = this.last = null;
+        return this.callParent(arguments);
+    },
+
+    // private. Only used by internal methods.
+    unlinkEntry: function(entry) {
+        // Stitch the list back up.
+        if (entry) {
+            if (entry.next) {
+                entry.next.prev = entry.prev;
+            } else {
+                this.last = entry.prev;
+            }
+            if (entry.prev) {
+                entry.prev.next = entry.next;
+            } else {
+                this.first = entry.next;
+            }
+            entry.prev = entry.next = null;
+        }
+    },
+
+    // private. Only used by internal methods.
+    moveToEnd: function(entry) {
+        this.unlinkEntry(entry);
+
+        // NOT an assignment.
+        // If the list is not empty, update the last entry
+        if (entry.prev = this.last) {
+            this.last.next = entry;
+        }
+        // List is empty
+        else {
+            this.first = entry;
+        }
+        this.last = entry;
+    },
+
+    /*
+     * @private
+     */
+    getArray: function(isKey) {
+        var arr = [],
+            entry = this.first;
+
+        while (entry) {
+            arr.push(isKey ? entry.key: entry.value);
+            entry = entry.next;
+        }
+        return arr;
+    },
+
+    /**
+     * Executes the specified function once for each item in the cache.
+     * Returning false from the function will cease iteration.
+     *
+     * By default, iteration is from least recently used to most recent.
+     *
+     * The paramaters passed to the function are:
+     * <div class="mdetail-params"><ul>
+     * <li><b>key</b> : String<p class="sub-desc">The key of the item</p></li>
+     * <li><b>value</b> : Number<p class="sub-desc">The value of the item</p></li>
+     * <li><b>length</b> : Number<p class="sub-desc">The total number of items in the hash</p></li>
+     * </ul></div>
+     * @param {Function} fn The function to execute.
+     * @param {Object} scope The scope (<code>this</code> reference) to execute in. Defaults to this LruCache.
+     * @param {Boolean} [reverse=false] Pass <code>true</code> to iterate the list in reverse (most recent first) order.
+     * @return {Ext.util.LruCache} this
+     */
+    each: function(fn, scope, reverse) {
+        var me = this,
+            entry = reverse ? me.last : me.first,
+            length = me.length;
+
+        scope = scope || me;
+        while (entry) {
+            if (fn.call(scope, entry.key, entry.value, length) === false) {
+                break;
+            }
+            entry = reverse ? entry.prev : entry.next;
+        }
+        return me;
+    },
+
+    /**
+     * @private
+     */
+    findKey: function(value) {
+        var key,
+            map = this.map;
+
+        for (key in map) {
+            if (map.hasOwnProperty(key) && map[key].value === value) {
+                return key;
+            }
+        }
+        return undefined;
+    },
+
+    /**
+     * Purge the least recently used entries if the maxSize has been exceeded.
+     */
+    prune: function() {
+        var me = this,
+            purgeCount = me.maxSize ? (me.length - me.maxSize) : 0;
+
+        if (purgeCount > 0) {
+            for (; me.first && purgeCount; purgeCount--) {
+                me.removeAtKey(me.first.key);
+            }
+        }
+    }
+
+  /**
+   * @method containsKey
+   * @private
+   */
+  /**
+   * @method contains
+   * @private
+   */
+  /**
+   * @method getKeys
+   * @private
+   */
+  /**
+   * @method getValues
+   * @private
+   */
+});

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

@@ -0,0 +1,131 @@
+/**
+ * @class Ext.util.Memento
+ * This class manages a set of captured properties from an object. These captured properties
+ * can later be restored to an object.
+ */
+Ext.define('Ext.util.Memento', (function () {
+
+    function captureOne (src, target, prop, prefix) {
+        src[prefix ? prefix + prop : prop] = target[prop];
+    }
+
+    function removeOne (src, target, prop) {
+        delete src[prop];
+    }
+
+    function restoreOne (src, target, prop, prefix) {
+        var name = prefix ? prefix + prop : prop,
+            value = src[name];
+
+        if (value || src.hasOwnProperty(name)) {
+            restoreValue(target, prop, value);
+        }
+    }
+
+    function restoreValue (target, prop, value) {
+        if (Ext.isDefined(value)) {
+            target[prop] = value;
+        } else {
+            delete target[prop];
+        }
+    }
+
+    function doMany (doOne, src, target, props, prefix) {
+        if (src) {
+            if (Ext.isArray(props)) {
+                var p, pLen = props.length;
+                for (p = 0; p < pLen; p++) {
+                    doOne(src, target, props[p], prefix);
+                }
+            } else {
+                doOne(src, target, props, prefix);
+            }
+        }
+    }
+
+    return {
+        /**
+         * @property data
+         * The collection of captured properties.
+         * @private
+         */
+        data: null,
+
+        /**
+         * @property target
+         * The default target object for capture/restore (passed to the constructor).
+         */
+        target: null,
+
+        /**
+         * Creates a new memento and optionally captures properties from the target object.
+         * @param {Object} target The target from which to capture properties. If specified in the
+         * constructor, this target becomes the default target for all other operations.
+         * @param {String/String[]} props The property or array of properties to capture.
+         */
+        constructor: function (target, props) {
+            if (target) {
+                this.target = target;
+                if (props) {
+                    this.capture(props);
+                }
+            }
+        },
+
+        /**
+         * Captures the specified properties from the target object in this memento.
+         * @param {String/String[]} props The property or array of properties to capture.
+         * @param {Object} target The object from which to capture properties.
+         */
+        capture: function (props, target, prefix) {
+            var me = this;
+            doMany(captureOne, me.data || (me.data = {}), target || me.target, props, prefix);
+        },
+
+        /**
+         * Removes the specified properties from this memento. These properties will not be
+         * restored later without re-capturing their values.
+         * @param {String/String[]} props The property or array of properties to remove.
+         */
+        remove: function (props) {
+            doMany(removeOne, this.data, null, props);
+        },
+
+        /**
+         * Restores the specified properties from this memento to the target object.
+         * @param {String/String[]} props The property or array of properties to restore.
+         * @param {Boolean} clear True to remove the restored properties from this memento or
+         * false to keep them (default is true).
+         * @param {Object} target The object to which to restore properties.
+         */
+        restore: function (props, clear, target, prefix) {
+            doMany(restoreOne, this.data, target || this.target, props, prefix);
+            if (clear !== false) {
+                this.remove(props);
+            }
+        },
+
+        /**
+         * Restores all captured properties in this memento to the target object.
+         * @param {Boolean} clear True to remove the restored properties from this memento or
+         * false to keep them (default is true).
+         * @param {Object} target The object to which to restore properties.
+         */
+        restoreAll: function (clear, target) {
+            var me   = this,
+                t    = target || this.target,
+                data = me.data,
+                prop;
+
+            for (prop in data) {
+                if (data.hasOwnProperty(prop)) {
+                    restoreValue(t, prop, data[prop]);
+                }
+            }
+
+            if (clear !== false) {
+                delete me.data;
+            }
+        }
+    };
+}()));

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

@@ -0,0 +1,239 @@
+/**
+ * @class Ext.util.MixedCollection
+ * <p>
+ * Represents a collection of a set of key and value pairs. Each key in the MixedCollection
+ * must be unique, the same key cannot exist twice. This collection is ordered, items in the
+ * collection can be accessed by index  or via the key. Newly added items are added to
+ * the end of the collection. This class is similar to {@link Ext.util.HashMap} however it
+ * is heavier and provides more functionality. Sample usage:
+ * <pre><code>
+var coll = new Ext.util.MixedCollection();
+coll.add('key1', 'val1');
+coll.add('key2', 'val2');
+coll.add('key3', 'val3');
+
+console.log(coll.get('key1')); // prints 'val1'
+console.log(coll.indexOfKey('key3')); // prints 2
+ * </code></pre>
+ *
+ * <p>
+ * The MixedCollection also has support for sorting and filtering of the values in the collection.
+ * <pre><code>
+var coll = new Ext.util.MixedCollection();
+coll.add('key1', 100);
+coll.add('key2', -100);
+coll.add('key3', 17);
+coll.add('key4', 0);
+var biggerThanZero = coll.filterBy(function(value){
+    return value > 0;
+});
+console.log(biggerThanZero.getCount()); // prints 2
+ * </code></pre>
+ * </p>
+ */
+Ext.define('Ext.util.MixedCollection', {
+    extend: 'Ext.util.AbstractMixedCollection',
+    mixins: {
+        sortable: 'Ext.util.Sortable'
+    },
+
+    /**
+     * Creates new MixedCollection.
+     * @param {Boolean} allowFunctions Specify <tt>true</tt> if the {@link #addAll}
+     * function should add function references to the collection. Defaults to
+     * <tt>false</tt>.
+     * @param {Function} keyFn A function that can accept an item of the type(s) stored in this MixedCollection
+     * and return the key value for that item.  This is used when available to look up the key on items that
+     * were passed without an explicit key parameter to a MixedCollection method.  Passing this parameter is
+     * equivalent to providing an implementation for the {@link #getKey} method.
+     */
+    constructor: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.addEvents('sort');
+        me.mixins.sortable.initSortable.call(me);
+    },
+
+    doSort: function(sorterFn) {
+        this.sortBy(sorterFn);
+    },
+
+    /**
+     * @private
+     * Performs the actual sorting based on a direction and a sorting function. Internally,
+     * this creates a temporary array of all items in the MixedCollection, sorts it and then writes
+     * the sorted array data back into this.items and this.keys
+     * @param {String} property Property to sort by ('key', 'value', or 'index')
+     * @param {String} dir (optional) Direction to sort 'ASC' or 'DESC'. Defaults to 'ASC'.
+     * @param {Function} fn (optional) Comparison function that defines the sort order.
+     * Defaults to sorting by numeric value.
+     */
+    _sort : function(property, dir, fn){
+        var me = this,
+            i, len,
+            dsc   = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
+
+            //this is a temporary array used to apply the sorting function
+            c     = [],
+            keys  = me.keys,
+            items = me.items;
+
+        //default to a simple sorter function if one is not provided
+        fn = fn || function(a, b) {
+            return a - b;
+        };
+
+        //copy all the items into a temporary array, which we will sort
+        for(i = 0, len = items.length; i < len; i++){
+            c[c.length] = {
+                key  : keys[i],
+                value: items[i],
+                index: i
+            };
+        }
+
+        //sort the temporary array
+        Ext.Array.sort(c, function(a, b){
+            var v = fn(a[property], b[property]) * dsc;
+            if(v === 0){
+                v = (a.index < b.index ? -1 : 1);
+            }
+            return v;
+        });
+
+        //copy the temporary array back into the main this.items and this.keys objects
+        for(i = 0, len = c.length; i < len; i++){
+            items[i] = c[i].value;
+            keys[i]  = c[i].key;
+        }
+
+        me.fireEvent('sort', me);
+    },
+
+    /**
+     * Sorts the collection by a single sorter function
+     * @param {Function} sorterFn The function to sort by
+     */
+    sortBy: function(sorterFn) {
+        var me     = this,
+            items  = me.items,
+            keys   = me.keys,
+            length = items.length,
+            temp   = [],
+            i;
+
+        //first we create a copy of the items array so that we can sort it
+        for (i = 0; i < length; i++) {
+            temp[i] = {
+                key  : keys[i],
+                value: items[i],
+                index: i
+            };
+        }
+
+        Ext.Array.sort(temp, function(a, b) {
+            var v = sorterFn(a.value, b.value);
+            if (v === 0) {
+                v = (a.index < b.index ? -1 : 1);
+            }
+
+            return v;
+        });
+
+        //copy the temporary array back into the main this.items and this.keys objects
+        for (i = 0; i < length; i++) {
+            items[i] = temp[i].value;
+            keys[i]  = temp[i].key;
+        }
+
+        me.fireEvent('sort', me, items, keys);
+    },
+
+    /**
+     * Calculates the insertion index of the new item based upon the comparison function passed, or the current sort order.
+     * @param {Object} newItem The new object to find the insertion position of.
+     * @param {Function} [sorterFn] The function to sort by. This is the same as the sorting function
+     * passed to {@link #sortBy}. It accepts 2 items from this MixedCollection, and returns -1 0, or 1
+     * depending on the relative sort positions of the 2 compared items.
+     *
+     * If omitted, a function {@link #generateComparator generated} from the currently defined set of
+     * {@link #sorters} will be used.
+     *
+     * @return {Number} The insertion point to add the new item into this MixedCollection at using {@link #insert}
+     */
+    findInsertionIndex: function(newItem, sorterFn) {
+        var me    = this,
+            items = me.items,
+            start = 0,
+            end   = items.length - 1,
+            middle,
+            comparison;
+
+        if (!sorterFn) {
+            sorterFn = me.generateComparator();
+        }
+        while (start <= end) {
+            middle = (start + end) >> 1;
+            comparison = sorterFn(newItem, items[middle]);
+            if (comparison >= 0) {
+                start = middle + 1;
+            } else if (comparison < 0) {
+                end = middle - 1;
+            }
+        }
+        return start;
+    },
+
+    /**
+     * Reorders each of the items based on a mapping from old index to new index. Internally this
+     * just translates into a sort. The 'sort' event is fired whenever reordering has occured.
+     * @param {Object} mapping Mapping from old item index to new item index
+     */
+    reorder: function(mapping) {
+        var me = this,
+            items = me.items,
+            index = 0,
+            length = items.length,
+            order = [],
+            remaining = [],
+            oldIndex;
+
+        me.suspendEvents();
+
+        //object of {oldPosition: newPosition} reversed to {newPosition: oldPosition}
+        for (oldIndex in mapping) {
+            order[mapping[oldIndex]] = items[oldIndex];
+        }
+
+        for (index = 0; index < length; index++) {
+            if (mapping[index] == undefined) {
+                remaining.push(items[index]);
+            }
+        }
+
+        for (index = 0; index < length; index++) {
+            if (order[index] == undefined) {
+                order[index] = remaining.shift();
+            }
+        }
+
+        me.clear();
+        me.addAll(order);
+
+        me.resumeEvents();
+        me.fireEvent('sort', me);
+    },
+
+    /**
+     * Sorts this collection by <b>key</b>s.
+     * @param {String} direction (optional) 'ASC' or 'DESC'. Defaults to 'ASC'.
+     * @param {Function} fn (optional) Comparison function that defines the sort order.
+     * Defaults to sorting by case insensitive string.
+     */
+    sortByKey : function(dir, fn){
+        this._sort('key', dir, fn || function(a, b){
+            var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
+            return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+        });
+    }
+});