extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/data/NodeStore.js

@@ -0,0 +1,254 @@
+/**
+ * Node Store
+ * @private
+ */
+Ext.define('Ext.data.NodeStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.node',
+    requires: ['Ext.data.NodeInterface'],
+
+    /**
+     * @cfg {Ext.data.Model} node
+     * The Record you want to bind this Store to. Note that
+     * this record will be decorated with the Ext.data.NodeInterface if this is not the
+     * case yet.
+     */
+    node: null,
+
+    /**
+     * @cfg {Boolean} recursive
+     * Set this to true if you want this NodeStore to represent
+     * all the descendents of the node in its flat data collection. This is useful for
+     * rendering a tree structure to a DataView and is being used internally by
+     * the TreeView. Any records that are moved, removed, inserted or appended to the
+     * node at any depth below the node this store is bound to will be automatically
+     * updated in this Store's internal flat data structure.
+     */
+    recursive: false,
+    
+    /** 
+     * @cfg {Boolean} rootVisible
+     * False to not include the root node in this Stores collection.
+     */    
+    rootVisible: false,
+
+    /**
+     * @cfg {Ext.data.TreeStore} treeStore
+     * The TreeStore that is used by this NodeStore's Ext.tree.View.
+     */
+
+    constructor: function(config) {
+        var me = this,
+            node;
+
+        config = config || {};
+        Ext.apply(me, config);
+
+        //<debug>
+        if (Ext.isDefined(me.proxy)) {
+            Ext.Error.raise("A NodeStore cannot be bound to a proxy. Instead bind it to a record " +
+                            "decorated with the NodeInterface by setting the node config.");
+        }
+        me.useModelWarning = false;
+        //</debug>
+
+        config.proxy = {type: 'proxy'};
+        me.callParent([config]);
+
+        node = me.node;
+        if (node) {
+            me.node = null;
+            me.setNode(node);
+        }
+    },
+
+    setNode: function(node) {
+        var me = this;
+        if (me.node && me.node != node) {
+            // We want to unbind our listeners on the old node
+            me.mun(me.node, {
+                expand: me.onNodeExpand,
+                collapse: me.onNodeCollapse,
+                append: me.onNodeAppend,
+                insert: me.onNodeInsert,
+                remove: me.onNodeRemove,
+                sort: me.onNodeSort,
+                scope: me
+            });
+            me.node = null;
+        }
+
+        if (node) {
+            Ext.data.NodeInterface.decorate(node.self);
+            me.removeAll();
+            if (me.rootVisible) {
+                me.add(node);
+            } else if (!node.isExpanded() && me.treeStore.autoLoad !== false) {
+                node.expand();
+            }
+
+            me.mon(node, {
+                expand: me.onNodeExpand,
+                collapse: me.onNodeCollapse,
+                append: me.onNodeAppend,
+                insert: me.onNodeInsert,
+                remove: me.onNodeRemove,
+                sort: me.onNodeSort,
+                scope: me
+            });
+            me.node = node;
+            if (node.isExpanded() && node.isLoaded()) {
+                me.onNodeExpand(node, node.childNodes, true);
+            }
+        }
+    },
+
+    onNodeSort: function(node, childNodes) {
+        var me = this;
+
+        if ((me.indexOf(node) !== -1 || (node === me.node && !me.rootVisible) && node.isExpanded())) {
+            me.onNodeCollapse(node, childNodes, true);
+            me.onNodeExpand(node, childNodes, true);
+        }
+    },
+
+    onNodeExpand: function(parent, records, suppressEvent) {
+        var me = this,
+            insertIndex = me.indexOf(parent) + 1,
+            ln = records ? records.length : 0,
+            i, record;
+
+        if (!me.recursive && parent !== me.node) {
+            return;
+        }
+
+        if (parent !== this.node && !me.isVisible(parent)) {
+            return;
+        }
+
+        if (!suppressEvent && me.fireEvent('beforeexpand', parent, records, insertIndex) === false) {
+            return;
+        }
+
+        if (ln) {
+            me.insert(insertIndex, records);
+            for (i = 0; i < ln; i++) {
+                record = records[i];
+                if (record.isExpanded()) {
+                    if (record.isLoaded()) {
+                        // Take a shortcut
+                        me.onNodeExpand(record, record.childNodes, true);
+                    }
+                    else {
+                        record.set('expanded', false);
+                        record.expand();
+                    }
+                }
+            }
+        }
+
+        if (!suppressEvent) {
+            me.fireEvent('expand', parent, records);
+        }
+    },
+
+    onNodeCollapse: function(parent, records, suppressEvent) {
+        var me = this,
+            ln = records.length,
+            collapseIndex = me.indexOf(parent) + 1,
+            i, record;
+
+        if (!me.recursive && parent !== me.node) {
+            return;
+        }
+
+        if (!suppressEvent && me.fireEvent('beforecollapse', parent, records, collapseIndex) === false) {
+            return;
+        }
+
+        for (i = 0; i < ln; i++) {
+            record = records[i];
+            me.remove(record);
+            if (record.isExpanded()) {
+                me.onNodeCollapse(record, record.childNodes, true);
+            }
+        }
+
+        if (!suppressEvent) {
+            me.fireEvent('collapse', parent, records, collapseIndex);
+        }
+    },
+
+    onNodeAppend: function(parent, node, index) {
+        var me = this,
+            refNode, sibling;
+
+        if (me.isVisible(node)) {
+            if (index === 0) {
+                refNode = parent;
+            } else {
+                sibling = node.previousSibling;
+                while (sibling.isExpanded() && sibling.lastChild) {
+                    sibling = sibling.lastChild;
+                }
+                refNode = sibling;
+            }
+            me.insert(me.indexOf(refNode) + 1, node);
+            if (!node.isLeaf() && node.isExpanded()) {
+                if (node.isLoaded()) {
+                    // Take a shortcut
+                    me.onNodeExpand(node, node.childNodes, true);
+                }
+                else {
+                    node.set('expanded', false);
+                    node.expand();
+                }
+            }
+        }
+    },
+
+    onNodeInsert: function(parent, node, refNode) {
+        var me = this,
+            index = this.indexOf(refNode);
+
+        if (index != -1 && me.isVisible(node)) {
+            me.insert(index, node);
+            if (!node.isLeaf() && node.isExpanded()) {
+                if (node.isLoaded()) {
+                    // Take a shortcut
+                    me.onNodeExpand(node, node.childNodes, true);
+                }
+                else {
+                    node.set('expanded', false);
+                    node.expand();
+                }
+            }
+        }
+    },
+
+    onNodeRemove: function(parent, node, index) {
+        var me = this;
+        if (me.indexOf(node) != -1) {
+            if (!node.isLeaf() && node.isExpanded()) {
+                me.onNodeCollapse(node, node.childNodes, true);
+            }
+            me.remove(node);
+        }
+    },
+
+    isVisible: function(node) {
+        var parent = node.parentNode;
+        while (parent) {
+            if (parent === this.node && !this.rootVisible && parent.isExpanded()) {
+                return true;
+            }
+
+            if (this.indexOf(parent) === -1 || !parent.isExpanded()) {
+                return false;
+            }
+
+            parent = parent.parentNode;
+        }
+        return true;
+    }
+});

data/app/assets/javascripts/extjs-rails/src/data/Operation.js

@@ -0,0 +1,331 @@
+/**
+ * @author Ed Spencer
+ *
+ * Represents a single read or write operation performed by a {@link Ext.data.proxy.Proxy Proxy}. Operation objects are
+ * used to enable communication between Stores and Proxies. Application developers should rarely need to interact with
+ * Operation objects directly.
+ *
+ * Several Operations can be batched together in a {@link Ext.data.Batch batch}.
+ */
+Ext.define('Ext.data.Operation', {
+    /**
+     * @cfg {Boolean} synchronous
+     * True if this Operation is to be executed synchronously. This property is inspected by a
+     * {@link Ext.data.Batch Batch} to see if a series of Operations can be executed in parallel or not.
+     */
+    synchronous: true,
+
+    /**
+     * @cfg {String} action
+     * The action being performed by this Operation. Should be one of 'create', 'read', 'update' or 'destroy'.
+     */
+    action: undefined,
+
+    /**
+     * @cfg {Ext.util.Filter[]} filters
+     * Optional array of filter objects. Only applies to 'read' actions.
+     */
+    filters: undefined,
+
+    /**
+     * @cfg {Ext.util.Sorter[]} sorters
+     * Optional array of sorter objects. Only applies to 'read' actions.
+     */
+    sorters: undefined,
+
+    /**
+     * @cfg {Ext.util.Grouper[]} groupers
+     * Optional grouping configuration. Only applies to 'read' actions where grouping is desired.
+     */
+    groupers: undefined,
+
+    /**
+     * @cfg {Number} start
+     * The start index (offset), used in paging when running a 'read' action.
+     */
+    start: undefined,
+
+    /**
+     * @cfg {Number} limit
+     * The number of records to load. Used on 'read' actions when paging is being used.
+     */
+    limit: undefined,
+
+    /**
+     * @cfg {Ext.data.Batch} batch
+     * The batch that this Operation is a part of.
+     */
+    batch: undefined,
+
+    /**
+     * @cfg {Function} callback
+     * Function to execute when operation completed.
+     * @cfg {Ext.data.Model[]} callback.records Array of records.
+     * @cfg {Ext.data.Operation} callback.operation The Operation itself.
+     * @cfg {Boolean} callback.success True when operation completed successfully.
+     */
+    callback: undefined,
+
+    /**
+     * @cfg {Object} scope
+     * Scope for the {@link #callback} function.
+     */
+    scope: undefined,
+
+    /**
+     * @property {Boolean} started
+     * The start status of this Operation. Use {@link #isStarted}.
+     * @readonly
+     * @private
+     */
+    started: false,
+
+    /**
+     * @property {Boolean} running
+     * The run status of this Operation. Use {@link #isRunning}.
+     * @readonly
+     * @private
+     */
+    running: false,
+
+    /**
+     * @property {Boolean} complete
+     * The completion status of this Operation. Use {@link #isComplete}.
+     * @readonly
+     * @private
+     */
+    complete: false,
+
+    /**
+     * @property {Boolean} success
+     * Whether the Operation was successful or not. This starts as undefined and is set to true
+     * or false by the Proxy that is executing the Operation. It is also set to false by {@link #setException}. Use
+     * {@link #wasSuccessful} to query success status.
+     * @readonly
+     * @private
+     */
+    success: undefined,
+
+    /**
+     * @property {Boolean} exception
+     * The exception status of this Operation. Use {@link #hasException} and see {@link #getError}.
+     * @readonly
+     * @private
+     */
+    exception: false,
+
+    /**
+     * @property {String/Object} error
+     * The error object passed when {@link #setException} was called. This could be any object or primitive.
+     * @private
+     */
+    error: undefined,
+
+    /**
+     * @property {RegExp} actionCommitRecordsRe
+     * The RegExp used to categorize actions that require record commits.
+     */
+    actionCommitRecordsRe: /^(?:create|update)$/i,
+
+    /**
+     * @property {RegExp} actionSkipSyncRe
+     * The RegExp used to categorize actions that skip local record synchronization. This defaults
+     * to match 'destroy'.
+     */
+    actionSkipSyncRe: /^destroy$/i,
+
+    /**
+     * Creates new Operation object.
+     * @param {Object} config (optional) Config object.
+     */
+    constructor: function(config) {
+        Ext.apply(this, config || {});
+    },
+
+    /**
+     * This method is called to commit data to this instance's records given the records in
+     * the server response. This is followed by calling {@link Ext.data.Model#commit} on all
+     * those records (for 'create' and 'update' actions).
+     *
+     * If this {@link #action} is 'destroy', any server records are ignored and the
+     * {@link Ext.data.Model#commit} method is not called.
+     *
+     * @param {Ext.data.Model[]} serverRecords An array of {@link Ext.data.Model} objects returned by
+     * the server.
+     * @markdown
+     */
+    commitRecords: function (serverRecords) {
+        var me = this,
+            mc, index, clientRecords, serverRec, clientRec;
+
+        if (!me.actionSkipSyncRe.test(me.action)) {
+            clientRecords = me.records;
+
+            if (clientRecords && clientRecords.length) {
+                if (clientRecords.length > 1) {
+                    // if this operation has multiple records, client records need to be matched up with server records
+                    // so that any data returned from the server can be updated in the client records.
+                    mc = new Ext.util.MixedCollection();
+                    mc.addAll(serverRecords);
+
+                    for (index = clientRecords.length; index--; ) {
+                        clientRec = clientRecords[index];
+                        serverRec = mc.findBy(me.matchClientRec, clientRec);
+
+                        // Replace client record data with server record data
+                        clientRec.copyFrom(serverRec);
+                    }
+                } else {
+                    // operation only has one record, so just match the first client record up with the first server record
+                    clientRec = clientRecords[0];
+                    serverRec = serverRecords[0];
+                    // if the client record is not a phantom, make sure the ids match before replacing the client data with server data.
+                    if(serverRec && (clientRec.phantom || clientRec.getId() === serverRec.getId())) {
+                        clientRec.copyFrom(serverRec);
+                    }
+                }
+
+                if (me.actionCommitRecordsRe.test(me.action)) {
+                    for (index = clientRecords.length; index--; ) {
+                        clientRecords[index].commit();
+                    }
+                }
+            }
+        }
+    },
+
+    // Private.
+    // Record matching function used by commitRecords
+    // IMPORTANT: This is called in the scope of the clientRec being matched
+    matchClientRec: function(record) {
+        var clientRec = this,
+            clientRecordId = clientRec.getId();
+
+        if(clientRecordId && record.getId() === clientRecordId) {
+            return true;
+        }
+        // if the server record cannot be found by id, find by internalId.
+        // this allows client records that did not previously exist on the server
+        // to be updated with the correct server id and data.
+        return record.internalId === clientRec.internalId;
+    },
+
+    /**
+     * Marks the Operation as started.
+     */
+    setStarted: function() {
+        this.started = true;
+        this.running = true;
+    },
+
+    /**
+     * Marks the Operation as completed.
+     */
+    setCompleted: function() {
+        this.complete = true;
+        this.running  = false;
+    },
+
+    /**
+     * Marks the Operation as successful.
+     */
+    setSuccessful: function() {
+        this.success = true;
+    },
+
+    /**
+     * Marks the Operation as having experienced an exception. Can be supplied with an option error message/object.
+     * @param {String/Object} error (optional) error string/object
+     */
+    setException: function(error) {
+        this.exception = true;
+        this.success = false;
+        this.running = false;
+        this.error = error;
+    },
+
+    /**
+     * Returns true if this Operation encountered an exception (see also {@link #getError})
+     * @return {Boolean} True if there was an exception
+     */
+    hasException: function() {
+        return this.exception === true;
+    },
+
+    /**
+     * Returns the error string or object that was set using {@link #setException}
+     * @return {String/Object} The error object
+     */
+    getError: function() {
+        return this.error;
+    },
+
+    /**
+     * Returns the {@link Ext.data.Model record}s associated with this operation.  For read operations the records as set by the {@link Ext.data.proxy.Proxy Proxy} will be returned (returns `null` if the proxy has not yet set the records).
+     * For create, update, and destroy operations the operation's initially configured records will be returned, although the proxy may modify these records' data at some point after the operation is initialized.
+     * @return {Ext.data.Model[]}
+     */
+    getRecords: function() {
+        var resultSet = this.getResultSet();
+        return this.records || (resultSet ? resultSet.records : null);
+    },
+
+    /**
+     * Returns the ResultSet object (if set by the Proxy). This object will contain the {@link Ext.data.Model model}
+     * instances as well as meta data such as number of instances fetched, number available etc
+     * @return {Ext.data.ResultSet} The ResultSet object
+     */
+    getResultSet: function() {
+        return this.resultSet;
+    },
+
+    /**
+     * Returns true if the Operation has been started. Note that the Operation may have started AND completed, see
+     * {@link #isRunning} to test if the Operation is currently running.
+     * @return {Boolean} True if the Operation has started
+     */
+    isStarted: function() {
+        return this.started === true;
+    },
+
+    /**
+     * Returns true if the Operation has been started but has not yet completed.
+     * @return {Boolean} True if the Operation is currently running
+     */
+    isRunning: function() {
+        return this.running === true;
+    },
+
+    /**
+     * Returns true if the Operation has been completed
+     * @return {Boolean} True if the Operation is complete
+     */
+    isComplete: function() {
+        return this.complete === true;
+    },
+
+    /**
+     * Returns true if the Operation has completed and was successful
+     * @return {Boolean} True if successful
+     */
+    wasSuccessful: function() {
+        return this.isComplete() && this.success === true;
+    },
+
+    /**
+     * @private
+     * Associates this Operation with a Batch
+     * @param {Ext.data.Batch} batch The batch
+     */
+    setBatch: function(batch) {
+        this.batch = batch;
+    },
+
+    /**
+     * Checks whether this operation should cause writing to occur.
+     * @return {Boolean} Whether the operation should cause a write to occur.
+     */
+    allowWrite: function() {
+        return this.action != 'read';
+    }
+});