extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/data/JsonP.js

@@ -1,253 +0,0 @@
-/**
- * @class Ext.data.JsonP
- * @singleton
- * This class is used to create JSONP requests. JSONP is a mechanism that allows for making
- * requests for data cross domain. More information is available <a href="http://en.wikipedia.org/wiki/JSONP">here</a>.
- */
-Ext.define('Ext.data.JsonP', {
-
-    /* Begin Definitions */
-
-    singleton: true,
-
-    statics: {
-        requestCount: 0,
-        requests: {}
-    },
-
-    /* End Definitions */
-
-    /**
-     * @property timeout
-     * @type Number
-     * A default timeout for any JsonP requests. If the request has not completed in this time the
-     * failure callback will be fired. The timeout is in ms. Defaults to <tt>30000</tt>.
-     */
-    timeout: 30000,
-
-    /**
-     * @property disableCaching
-     * @type Boolean
-     * True to add a unique cache-buster param to requests. Defaults to <tt>true</tt>.
-     */
-    disableCaching: true,
-
-    /**
-     * @property disableCachingParam
-     * @type String
-     * Change the parameter which is sent went disabling caching through a cache buster. Defaults to <tt>'_dc'</tt>.
-     */
-    disableCachingParam: '_dc',
-
-    /**
-     * @property callbackKey
-     * @type String
-     * Specifies the GET parameter that will be sent to the server containing the function name to be executed when
-     * the request completes. Defaults to <tt>callback</tt>. Thus, a common request will be in the form of
-     * url?callback=Ext.data.JsonP.callback1
-     */
-    callbackKey: 'callback',
-
-    /**
-     * Makes a JSONP request.
-     * @param {Object} options An object which may contain the following properties. Note that options will
-     * take priority over any defaults that are specified in the class.
-     * <ul>
-     * <li><b>url</b> : String <div class="sub-desc">The URL to request.</div></li>
-     * <li><b>params</b> : Object (Optional)<div class="sub-desc">An object containing a series of
-     * key value pairs that will be sent along with the request.</div></li>
-     * <li><b>timeout</b> : Number (Optional) <div class="sub-desc">See {@link #timeout}</div></li>
-     * <li><b>callbackKey</b> : String (Optional) <div class="sub-desc">See {@link #callbackKey}</div></li>
-     * <li><b>callbackName</b> : String (Optional) <div class="sub-desc">The function name to use for this request.
-     * By default this name will be auto-generated: Ext.data.JsonP.callback1, Ext.data.JsonP.callback2, etc.
-     * Setting this option to "my_name" will force the function name to be Ext.data.JsonP.my_name.
-     * Use this if you want deterministic behavior, but be careful - the callbackName should be different
-     * in each JsonP request that you make.</div></li>
-     * <li><b>disableCaching</b> : Boolean (Optional) <div class="sub-desc">See {@link #disableCaching}</div></li>
-     * <li><b>disableCachingParam</b> : String (Optional) <div class="sub-desc">See {@link #disableCachingParam}</div></li>
-     * <li><b>success</b> : Function (Optional) <div class="sub-desc">A function to execute if the request succeeds.</div></li>
-     * <li><b>failure</b> : Function (Optional) <div class="sub-desc">A function to execute if the request fails.</div></li>
-     * <li><b>callback</b> : Function (Optional) <div class="sub-desc">A function to execute when the request
-     * completes, whether it is a success or failure.</div></li>
-     * <li><b>scope</b> : Object (Optional)<div class="sub-desc">The scope in
-     * which to execute the callbacks: The "this" object for the callback function. Defaults to the browser window.</div></li>
-     * </ul>
-     * @return {Object} request An object containing the request details.
-     */
-    request: function(options){
-        options = Ext.apply({}, options);
-
-        //<debug>
-        if (!options.url) {
-            Ext.Error.raise('A url must be specified for a JSONP request.');
-        }
-        //</debug>
-
-        var me = this,
-            disableCaching = Ext.isDefined(options.disableCaching) ? options.disableCaching : me.disableCaching,
-            cacheParam = options.disableCachingParam || me.disableCachingParam,
-            id = ++me.statics().requestCount,
-            callbackName = options.callbackName || 'callback' + id,
-            callbackKey = options.callbackKey || me.callbackKey,
-            timeout = Ext.isDefined(options.timeout) ? options.timeout : me.timeout,
-            params = Ext.apply({}, options.params),
-            url = options.url,
-            name = Ext.name,
-            request,
-            script;
-
-        params[callbackKey] = name + '.data.JsonP.' + callbackName;
-        if (disableCaching) {
-            params[cacheParam] = new Date().getTime();
-        }
-
-        script = me.createScript(url, params, options);
-
-        me.statics().requests[id] = request = {
-            url: url,
-            params: params,
-            script: script,
-            id: id,
-            scope: options.scope,
-            success: options.success,
-            failure: options.failure,
-            callback: options.callback,
-            callbackKey: callbackKey,
-            callbackName: callbackName
-        };
-
-        if (timeout > 0) {
-            request.timeout = setTimeout(Ext.bind(me.handleTimeout, me, [request]), timeout);
-        }
-
-        me.setupErrorHandling(request);
-        me[callbackName] = Ext.bind(me.handleResponse, me, [request], true);
-        me.loadScript(request);
-        return request;
-    },
-
-    /**
-     * Abort a request. If the request parameter is not specified all open requests will
-     * be aborted.
-     * @param {Object/String} request (Optional) The request to abort
-     */
-    abort: function(request){
-        var me = this,
-            requests = me.statics().requests,
-            key;
-
-        if (request) {
-            if (!request.id) {
-                request = requests[request];
-            }
-            me.handleAbort(request);
-        } else {
-            for (key in requests) {
-                if (requests.hasOwnProperty(key)) {
-                    me.abort(requests[key]);
-                }
-            }
-        }
-    },
-
-    /**
-     * Sets up error handling for the script
-     * @private
-     * @param {Object} request The request
-     */
-    setupErrorHandling: function(request){
-        request.script.onerror = Ext.bind(this.handleError, this, [request]);
-    },
-
-    /**
-     * Handles any aborts when loading the script
-     * @private
-     * @param {Object} request The request
-     */
-    handleAbort: function(request){
-        request.errorType = 'abort';
-        this.handleResponse(null, request);
-    },
-
-    /**
-     * Handles any script errors when loading the script
-     * @private
-     * @param {Object} request The request
-     */
-    handleError: function(request){
-        request.errorType = 'error';
-        this.handleResponse(null, request);
-    },
-
-    /**
-     * Cleans up anu script handling errors
-     * @private
-     * @param {Object} request The request
-     */
-    cleanupErrorHandling: function(request){
-        request.script.onerror = null;
-    },
-
-    /**
-     * Handle any script timeouts
-     * @private
-     * @param {Object} request The request
-     */
-    handleTimeout: function(request){
-        request.errorType = 'timeout';
-        this.handleResponse(null, request);
-    },
-
-    /**
-     * Handle a successful response
-     * @private
-     * @param {Object} result The result from the request
-     * @param {Object} request The request
-     */
-    handleResponse: function(result, request){
-
-        var success = true;
-
-        if (request.timeout) {
-            clearTimeout(request.timeout);
-        }
-        delete this[request.callbackName];
-        delete this.statics().requests[request.id];
-        this.cleanupErrorHandling(request);
-        Ext.fly(request.script).remove();
-
-        if (request.errorType) {
-            success = false;
-            Ext.callback(request.failure, request.scope, [request.errorType]);
-        } else {
-            Ext.callback(request.success, request.scope, [result]);
-        }
-        Ext.callback(request.callback, request.scope, [success, result, request.errorType]);
-    },
-
-    /**
-     * Create the script tag given the specified url, params and options. The options
-     * parameter is passed to allow an override to access it.
-     * @private
-     * @param {String} url The url of the request
-     * @param {Object} params Any extra params to be sent
-     * @param {Object} options The object passed to {@link #request}.
-     */
-    createScript: function(url, params, options) {
-        var script = document.createElement('script');
-        script.setAttribute("src", Ext.urlAppend(url, Ext.Object.toQueryString(params)));
-        script.setAttribute("async", true);
-        script.setAttribute("type", "text/javascript");
-        return script;
-    },
-
-    /**
-     * Loads the script for the given request by appending it to the HEAD element. This is
-     * its own method so that users can override it (as well as {@link #createScript}).
-     * @private
-     * @param request The request object.
-     */
-    loadScript: function (request) {
-        Ext.getHead().appendChild(request.script);
-    }
-});

data/app/assets/javascripts/src/data/JsonPStore.js

@@ -1,51 +0,0 @@
-/**
- * @class Ext.data.JsonPStore
- * @extends Ext.data.Store
- * <p>Small helper class to make creating {@link Ext.data.Store}s from different domain JSON data easier.
- * A JsonPStore will be automatically configured with a {@link Ext.data.reader.Json} and a {@link Ext.data.proxy.JsonP JsonPProxy}.</p>
- * <p>A store configuration would be something like:<pre><code>
-var store = new Ext.data.JsonPStore({
-    // store configs
-    autoDestroy: true,
-    storeId: 'myStore',
-
-    // proxy configs
-    url: 'get-images.php',
-
-    // reader configs
-    root: 'images',
-    idProperty: 'name',
-    fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}]
-});
- * </code></pre></p>
- * <p>This store is configured to consume a returned object of the form:<pre><code>
-stcCallback({
-    images: [
-        {name: 'Image one', url:'/GetImage.php?id=1', size:46.5, lastmod: new Date(2007, 10, 29)},
-        {name: 'Image Two', url:'/GetImage.php?id=2', size:43.2, lastmod: new Date(2007, 10, 30)}
-    ]
-})
- * </code></pre>
- * <p>Where stcCallback is the callback name passed in the request to the remote domain. See {@link Ext.data.proxy.JsonP JsonPProxy}
- * for details of how this works.</p>
- * An object literal of this form could also be used as the {@link #cfg-data} config option.</p>
- * @xtype jsonpstore
- */
-Ext.define('Ext.data.JsonPStore', {
-    extend: 'Ext.data.Store',
-    alias : 'store.jsonp',
-    requires: [
-        'Ext.data.proxy.JsonP',
-        'Ext.data.reader.Json'
-    ],
-
-    constructor: function(config) {
-        config = Ext.apply({
-            proxy: {
-                type: 'jsonp',
-                reader: 'json'
-            }
-        }, config);
-        this.callParent([config]);
-    }
-});

data/app/assets/javascripts/src/data/JsonStore.js

@@ -1,60 +0,0 @@
-/**
- * @author Ed Spencer
- *
- * <p>Small helper class to make creating {@link Ext.data.Store}s from JSON data easier.
- * A JsonStore will be automatically configured with a {@link Ext.data.reader.Json}.</p>
- *
- * <p>A store configuration would be something like:</p>
- *
-<pre><code>
-var store = new Ext.data.JsonStore({
-    // store configs
-    autoDestroy: true,
-    storeId: 'myStore',
-
-    proxy: {
-        type: 'ajax',
-        url: 'get-images.php',
-        reader: {
-            type: 'json',
-            root: 'images',
-            idProperty: 'name'
-        }
-    },
-
-    //alternatively, a {@link Ext.data.Model} name can be given (see {@link Ext.data.Store} for an example)
-    fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}]
-});
-</code></pre>
- *
- * <p>This store is configured to consume a returned object of the form:<pre><code>
-{
-    images: [
-        {name: 'Image one', url:'/GetImage.php?id=1', size:46.5, lastmod: new Date(2007, 10, 29)},
-        {name: 'Image Two', url:'/GetImage.php?id=2', size:43.2, lastmod: new Date(2007, 10, 30)}
-    ]
-}
-</code></pre>
- *
- * <p>An object literal of this form could also be used as the {@link #cfg-data} config option.</p>
- */
-Ext.define('Ext.data.JsonStore',  {
-    extend: 'Ext.data.Store',
-    alias: 'store.json',
-    requires: [
-        'Ext.data.proxy.Ajax',
-        'Ext.data.reader.Json',
-        'Ext.data.writer.Json'
-    ],
-
-    constructor: function(config) {
-        config = Ext.apply({
-            proxy: {
-                type  : 'ajax',
-                reader: 'json',
-                writer: 'json'
-            }
-        }, config);
-        this.callParent([config]);
-    }
-});

data/app/assets/javascripts/src/data/Model.js

@@ -1,1673 +0,0 @@
-/**
- * @author Ed Spencer
- *
- * A Model represents some object that your application manages. For example, one might define a Model for Users,
- * Products, Cars, or any other real-world object that we want to model in the system. Models are registered via the
- * {@link Ext.ModelManager model manager}, and are used by {@link Ext.data.Store stores}, which are in turn used by many
- * of the data-bound components in Ext.
- *
- * Models are defined as a set of fields and any arbitrary methods and properties relevant to the model. For example:
- *
- *     Ext.define('User', {
- *         extend: 'Ext.data.Model',
- *         fields: [
- *             {name: 'name',  type: 'string'},
- *             {name: 'age',   type: 'int', convert: null},
- *             {name: 'phone', type: 'string'},
- *             {name: 'alive', type: 'boolean', defaultValue: true, convert: null}
- *         ],
- *
- *         changeName: function() {
- *             var oldName = this.get('name'),
- *                 newName = oldName + " The Barbarian";
- *
- *             this.set('name', newName);
- *         }
- *     });
- *
- * The fields array is turned into a {@link Ext.util.MixedCollection MixedCollection} automatically by the {@link
- * Ext.ModelManager ModelManager}, and all other functions and properties are copied to the new Model's prototype.
- * 
- * By default, the built in numeric and boolean field types have a (@link Ext.data.Field#convert} function which coerces string
- * values in raw data into the field's type. For better performance with {@link Ext.data.reader.Json Json} or {@link Ext.data.reader.Array Array}
- * readers *if you are in control of the data fed into this Model*, you can null out the default convert function which will cause
- * the raw property to be copied directly into the Field's value.
- *
- * Now we can create instances of our User model and call any model logic we defined:
- *
- *     var user = Ext.create('User', {
- *         name : 'Conan',
- *         age  : 24,
- *         phone: '555-555-5555'
- *     });
- *
- *     user.changeName();
- *     user.get('name'); //returns "Conan The Barbarian"
- *
- * # Validations
- *
- * Models have built-in support for validations, which are executed against the validator functions in {@link
- * Ext.data.validations} ({@link Ext.data.validations see all validation functions}). Validations are easy to add to
- * models:
- *
- *     Ext.define('User', {
- *         extend: 'Ext.data.Model',
- *         fields: [
- *             {name: 'name',     type: 'string'},
- *             {name: 'age',      type: 'int'},
- *             {name: 'phone',    type: 'string'},
- *             {name: 'gender',   type: 'string'},
- *             {name: 'username', type: 'string'},
- *             {name: 'alive',    type: 'boolean', defaultValue: true}
- *         ],
- *
- *         validations: [
- *             {type: 'presence',  field: 'age'},
- *             {type: 'length',    field: 'name',     min: 2},
- *             {type: 'inclusion', field: 'gender',   list: ['Male', 'Female']},
- *             {type: 'exclusion', field: 'username', list: ['Admin', 'Operator']},
- *             {type: 'format',    field: 'username', matcher: /([a-z]+)[0-9]{2,3}/}
- *         ]
- *     });
- *
- * The validations can be run by simply calling the {@link #validate} function, which returns a {@link Ext.data.Errors}
- * object:
- *
- *     var instance = Ext.create('User', {
- *         name: 'Ed',
- *         gender: 'Male',
- *         username: 'edspencer'
- *     });
- *
- *     var errors = instance.validate();
- *
- * # Associations
- *
- * Models can have associations with other Models via {@link Ext.data.association.HasOne},
- * {@link Ext.data.association.BelongsTo belongsTo} and {@link Ext.data.association.HasMany hasMany} associations.
- * For example, let's say we're writing a blog administration application which deals with Users, Posts and Comments.
- * We can express the relationships between these models like this:
- *
- *     Ext.define('Post', {
- *         extend: 'Ext.data.Model',
- *         fields: ['id', 'user_id'],
- *
- *         belongsTo: 'User',
- *         hasMany  : {model: 'Comment', name: 'comments'}
- *     });
- *
- *     Ext.define('Comment', {
- *         extend: 'Ext.data.Model',
- *         fields: ['id', 'user_id', 'post_id'],
- *
- *         belongsTo: 'Post'
- *     });
- *
- *     Ext.define('User', {
- *         extend: 'Ext.data.Model',
- *         fields: ['id'],
- *
- *         hasMany: [
- *             'Post',
- *             {model: 'Comment', name: 'comments'}
- *         ]
- *     });
- *
- * See the docs for {@link Ext.data.association.HasOne}, {@link Ext.data.association.BelongsTo} and
- * {@link Ext.data.association.HasMany} for details on the usage and configuration of associations.
- * Note that associations can also be specified like this:
- *
- *     Ext.define('User', {
- *         extend: 'Ext.data.Model',
- *         fields: ['id'],
- *
- *         associations: [
- *             {type: 'hasMany', model: 'Post',    name: 'posts'},
- *             {type: 'hasMany', model: 'Comment', name: 'comments'}
- *         ]
- *     });
- *
- * # Using a Proxy
- *
- * Models are great for representing types of data and relationships, but sooner or later we're going to want to load or
- * save that data somewhere. All loading and saving of data is handled via a {@link Ext.data.proxy.Proxy Proxy}, which
- * can be set directly on the Model:
- *
- *     Ext.define('User', {
- *         extend: 'Ext.data.Model',
- *         fields: ['id', 'name', 'email'],
- *
- *         proxy: {
- *             type: 'rest',
- *             url : '/users'
- *         }
- *     });
- *
- * Here we've set up a {@link Ext.data.proxy.Rest Rest Proxy}, which knows how to load and save data to and from a
- * RESTful backend. Let's see how this works:
- *
- *     var user = Ext.create('User', {name: 'Ed Spencer', email: 'ed@sencha.com'});
- *
- *     user.save(); //POST /users
- *
- * Calling {@link #save} on the new Model instance tells the configured RestProxy that we wish to persist this Model's
- * data onto our server. RestProxy figures out that this Model hasn't been saved before because it doesn't have an id,
- * and performs the appropriate action - in this case issuing a POST request to the url we configured (/users). We
- * configure any Proxy on any Model and always follow this API - see {@link Ext.data.proxy.Proxy} for a full list.
- *
- * Loading data via the Proxy is equally easy:
- *
- *     //get a reference to the User model class
- *     var User = Ext.ModelManager.getModel('User');
- *
- *     //Uses the configured RestProxy to make a GET request to /users/123
- *     User.load(123, {
- *         success: function(user) {
- *             console.log(user.getId()); //logs 123
- *         }
- *     });
- *
- * Models can also be updated and destroyed easily:
- *
- *     //the user Model we loaded in the last snippet:
- *     user.set('name', 'Edward Spencer');
- *
- *     //tells the Proxy to save the Model. In this case it will perform a PUT request to /users/123 as this Model already has an id
- *     user.save({
- *         success: function() {
- *             console.log('The User was updated');
- *         }
- *     });
- *
- *     //tells the Proxy to destroy the Model. Performs a DELETE request to /users/123
- *     user.destroy({
- *         success: function() {
- *             console.log('The User was destroyed!');
- *         }
- *     });
- *
- * # Usage in Stores
- *
- * It is very common to want to load a set of Model instances to be displayed and manipulated in the UI. We do this by
- * creating a {@link Ext.data.Store Store}:
- *
- *     var store = Ext.create('Ext.data.Store', {
- *         model: 'User'
- *     });
- *
- *     //uses the Proxy we set up on Model to load the Store data
- *     store.load();
- *
- * A Store is just a collection of Model instances - usually loaded from a server somewhere. Store can also maintain a
- * set of added, updated and removed Model instances to be synchronized with the server via the Proxy. See the {@link
- * Ext.data.Store Store docs} for more information on Stores.
- *
- * @constructor
- * Creates new Model instance.
- * @param {Object} data An object containing keys corresponding to this model's fields, and their associated values
- */
-
-Ext.define('Ext.data.Model', {
-    alternateClassName: 'Ext.data.Record',
-
-    mixins: {
-        observable: 'Ext.util.Observable'
-    },
-    
-    requires: [
-        'Ext.ModelManager',
-        'Ext.data.IdGenerator',
-        'Ext.data.Field',
-        'Ext.data.Errors',
-        'Ext.data.Operation',
-        'Ext.data.validations',
-        'Ext.util.MixedCollection'
-    ],
-
-    compareConvertFields: function(f1, f2) {
-        var f1SpecialConvert = f1.convert && f1.type && f1.convert !== f1.type.convert,
-            f2SpecialConvert = f2.convert && f2.type && f2.convert !== f2.type.convert;
-
-        if (f1SpecialConvert && !f2SpecialConvert) {
-            return 1;
-        }
-
-        if (!f1SpecialConvert && f2SpecialConvert) {
-            return -1;
-        }
-        return 0;
-    },
-
-    itemNameFn: function(item) {
-        return item.name;
-    },
-
-    onClassExtended: function(cls, data, hooks) {
-        var onBeforeClassCreated = hooks.onBeforeCreated;
-
-        hooks.onBeforeCreated = function(cls, data) {
-            var me = this,
-                name = Ext.getClassName(cls),
-                prototype = cls.prototype,
-                superCls = cls.prototype.superclass,
-
-                validations = data.validations || [],
-                fields = data.fields || [],
-                associations = data.associations || [],
-                addAssociations = function(items, type) {
-                    var i = 0,
-                        len,
-                        item;
-
-                    if (items) {
-                        items = Ext.Array.from(items);
-
-                        for (len = items.length; i < len; ++i) {
-                            item = items[i];
-
-                            if (!Ext.isObject(item)) {
-                                item = {model: item};
-                            }
-
-                            item.type = type;
-                            associations.push(item);
-                        }
-                    }
-                },
-                idgen = data.idgen,
-
-                fieldsMixedCollection = new Ext.util.MixedCollection(false, prototype.itemNameFn),
-
-                associationsMixedCollection = new Ext.util.MixedCollection(false, prototype.itemNameFn),
-
-                superValidations = superCls.validations,
-                superFields = superCls.fields,
-                superAssociations = superCls.associations,
-
-                association, i, ln,
-                dependencies = [],
-                idProperty = data.idProperty || cls.prototype.idProperty,
-
-                // Process each Field upon add into the collection
-                onFieldAddReplace = function(arg0, arg1, arg2) {
-                    var newField,
-                        pos;
-
-                    if (fieldsMixedCollection.events.add.firing) {
-                        // Add event signature is (position, value, key);
-                        pos = arg0;
-                        newField  = arg1;
-                    } else {
-                        // Replace event signature is (key, oldValue, newValue);
-                        newField = arg2;
-                        pos = arg1.originalIndex;
-                    }
-
-                    // Set the originalIndex for ArrayReader to get the default mapping from in case
-                    // compareConvertFields changes the order due to some fields having custom convert functions.
-                    newField.originalIndex = pos;
-
-                    // The field(s) which encapsulates the idProperty must never have a default value set
-                    // if no value arrives from the server side. So override any possible prototype-provided
-                    // defaultValue with undefined which will inhibit generation of defaulting code in Reader.buildRecordDataExtractor
-                    if (newField.mapping === idProperty || (newField.mapping == null && newField.name === idProperty)) {
-                        newField.defaultValue = undefined;
-                    }
-                },
-
-                // Use the proxy from the class definition object if present, otherwise fall back to the inherited one, or the default    
-                clsProxy = data.proxy || cls.prototype.proxy || cls.prototype.defaultProxyType,
-
-                // Sort upon add function to be used in case of dynamically added Fields
-                fieldConvertSortFn = function() {
-                    fieldsMixedCollection.sortBy(prototype.compareConvertFields);
-                };
-
-            // Save modelName on class and its prototype
-            cls.modelName = name;
-            prototype.modelName = name;
-
-            // Merge the validations of the superclass and the new subclass
-            if (superValidations) {
-                validations = superValidations.concat(validations);
-            }
-
-            data.validations = validations;
-
-            // Merge the fields of the superclass and the new subclass
-            if (superFields) {
-                fields = superFields.items.concat(fields);
-            }
-
-            fieldsMixedCollection.on({
-                add:     onFieldAddReplace,
-                replace: onFieldAddReplace
-            });  
-
-            for (i = 0, ln = fields.length; i < ln; ++i) {
-                fieldsMixedCollection.add(new Ext.data.Field(fields[i]));
-            }
-            if (!fieldsMixedCollection.get(idProperty)) {
-                fieldsMixedCollection.add(new Ext.data.Field(idProperty));
-            }
-
-            // Ensure the Fields are on correct order: Fields with custom convert function last
-            fieldConvertSortFn();
-            fieldsMixedCollection.on({
-                add:     fieldConvertSortFn,
-                replace: fieldConvertSortFn
-            });
-
-            data.fields = fieldsMixedCollection;
-
-            if (idgen) {
-                data.idgen = Ext.data.IdGenerator.get(idgen);
-            }
-
-            //associations can be specified in the more convenient format (e.g. not inside an 'associations' array).
-            //we support that here
-            addAssociations(data.belongsTo, 'belongsTo');
-            delete data.belongsTo;
-            addAssociations(data.hasMany, 'hasMany');
-            delete data.hasMany;
-            addAssociations(data.hasOne, 'hasOne');
-            delete data.hasOne;
-
-            if (superAssociations) {
-                associations = superAssociations.items.concat(associations);
-            }
-
-            for (i = 0, ln = associations.length; i < ln; ++i) {
-                dependencies.push('association.' + associations[i].type.toLowerCase());
-            }
-
-            // If we have not been supplied with a Proxy *instance*, then add the proxy type to our dependency list
-            if (clsProxy && !clsProxy.isProxy) {
-                dependencies.push('proxy.' + (typeof clsProxy === 'string' ? clsProxy : clsProxy.type));
-            }
-
-            Ext.require(dependencies, function() {
-                Ext.ModelManager.registerType(name, cls);
-
-                for (i = 0, ln = associations.length; i < ln; ++i) {
-                    association = associations[i];
-
-                    Ext.apply(association, {
-                        ownerModel: name,
-                        associatedModel: association.model
-                    });
-
-                    if (Ext.ModelManager.getModel(association.model) === undefined) {
-                        Ext.ModelManager.registerDeferredAssociation(association);
-                    } else {
-                        associationsMixedCollection.add(Ext.data.association.Association.create(association));
-                    }
-                }
-
-                data.associations = associationsMixedCollection;
-
-                // onBeforeCreated may get called *asynchronously* if any of those required classes caused
-                // an asynchronous script load. This would mean that the class definition object
-                // has not been applied to the prototype when the Model definition has returned.
-                // The Reader constructor does not attempt to buildExtractors if the fields MixedCollection
-                // has not yet been set. The cls.setProxy call triggers a build of extractor methods.
-                onBeforeClassCreated.call(me, cls, data, hooks);
-
-                cls.setProxy(clsProxy);
-
-                // Fire the onModelDefined template method on ModelManager
-                Ext.ModelManager.onModelDefined(cls);
-            });
-        };
-    },
-
-    inheritableStatics: {
-        /**
-         * Sets the Proxy to use for this model. Accepts any options that can be accepted by
-         * {@link Ext#createByAlias Ext.createByAlias}.
-         * @param {String/Object/Ext.data.proxy.Proxy} proxy The proxy
-         * @return {Ext.data.proxy.Proxy}
-         * @static
-         * @inheritable
-         */
-        setProxy: function(proxy) {
-            //make sure we have an Ext.data.proxy.Proxy object
-            if (!proxy.isProxy) {
-                if (typeof proxy == "string") {
-                    proxy = {
-                        type: proxy
-                    };
-                }
-                proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
-            }
-            proxy.setModel(this);
-            this.proxy = this.prototype.proxy = proxy;
-
-            return proxy;
-        },
-
-        /**
-         * Returns the configured Proxy for this Model
-         * @return {Ext.data.proxy.Proxy} The proxy
-         * @static
-         * @inheritable
-         */
-        getProxy: function() {
-            return this.proxy;
-        },
-
-        /**
-         * Apply a new set of field and/or property definitions to the existing model. This will replace any existing
-         * fields, including fields inherited from superclasses. Mainly for reconfiguring the
-         * model based on changes in meta data (called from Reader's onMetaChange method).
-         * @static
-         * @inheritable
-         */
-        setFields: function(fields, idProperty, clientIdProperty) {
-            var me = this,
-                proto = me.prototype,
-                prototypeFields = proto.fields,
-                len = fields ? fields.length : 0,
-                i = 0;
-
-
-            if (idProperty) {
-                proto.idProperty = idProperty;
-            }
-            if (clientIdProperty) {
-                proto.clientIdProperty = clientIdProperty;
-            }
-
-            if (prototypeFields) {
-                prototypeFields.clear();
-            }
-            else {
-                prototypeFields = me.prototype.fields = new Ext.util.MixedCollection(false, function(field) {
-                    return field.name;
-                });
-            }
-
-            for (; i < len; i++) {
-                prototypeFields.add(new Ext.data.Field(fields[i]));
-            }
-            if (!prototypeFields.get(proto.idProperty)) {
-                prototypeFields.add(new Ext.data.Field(proto.idProperty));
-            }
-
-            me.fields = prototypeFields;
-
-            return prototypeFields;
-        },
-
-        /**
-         * Returns an Array of {@link Ext.data.Field Field} definitions which define this Model's structure
-         *
-         * Fields are sorted upon Model class definition. Fields with custom {@link Ext.data.Field#convert convert} functions
-         * are moved to *after* fields with no convert functions. This is so that convert functions which rely on existing
-         * field values will be able to read those field values.
-         *
-         * @return {Ext.data.Field[]} The defined Fields for this Model.
-         *
-         */
-        getFields: function() {
-            return this.prototype.fields.items;
-        },
-
-        /**
-         * Asynchronously loads a model instance by id. Sample usage:
-         *
-         *     Ext.define('MyApp.User', {
-         *         extend: 'Ext.data.Model',
-         *         fields: [
-         *             {name: 'id', type: 'int'},
-         *             {name: 'name', type: 'string'}
-         *         ]
-         *     });
-         *
-         *     MyApp.User.load(10, {
-         *         scope: this,
-         *         failure: function(record, operation) {
-         *             //do something if the load failed
-         *         },
-         *         success: function(record, operation) {
-         *             //do something if the load succeeded
-         *         },
-         *         callback: function(record, operation) {
-         *             //do something whether the load succeeded or failed
-         *         }
-         *     });
-         *
-         * @param {Number/String} id The id of the model to load
-         * @param {Object} config (optional) config object containing success, failure and callback functions, plus
-         * optional scope
-         * @static
-         * @inheritable
-         */
-        load: function(id, config) {
-            config = Ext.apply({}, config);
-            config = Ext.applyIf(config, {
-                action: 'read',
-                id    : id
-            });
-
-            var operation  = new Ext.data.Operation(config),
-                scope      = config.scope || this,
-                record     = null,
-                callback;
-
-            callback = function(operation) {
-                if (operation.wasSuccessful()) {
-                    record = operation.getRecords()[0];
-                    Ext.callback(config.success, scope, [record, operation]);
-                } else {
-                    Ext.callback(config.failure, scope, [record, operation]);
-                }
-                Ext.callback(config.callback, scope, [record, operation]);
-            };
-
-            this.proxy.read(operation, callback, this);
-        }
-    },
-
-    statics: {
-        PREFIX : 'ext-record',
-        AUTO_ID: 1,
-        EDIT   : 'edit',
-        REJECT : 'reject',
-        COMMIT : 'commit',
-
-        /**
-         * Generates a sequential id. This method is typically called when a record is {@link Ext#create
-         * create}d and {@link #constructor no id has been specified}. The id will automatically be assigned to the
-         * record. The returned id takes the form: {PREFIX}-{AUTO_ID}.
-         *
-         * - **PREFIX** : String - Ext.data.Model.PREFIX (defaults to 'ext-record')
-         * - **AUTO_ID** : String - Ext.data.Model.AUTO_ID (defaults to 1 initially)
-         *
-         * @param {Ext.data.Model} rec The record being created. The record does not exist, it's a {@link #phantom}.
-         * @return {String} auto-generated string id, `"ext-record-i++"`;
-         * @static
-         */
-        id: function(rec) {
-            var id = [this.PREFIX, '-', this.AUTO_ID++].join('');
-            rec.phantom = true;
-            rec.internalId = id;
-            return id;
-        }
-    },
-
-    /**
-     * @cfg {String/Object} idgen
-     * The id generator to use for this model. The default id generator does not generate
-     * values for the {@link #idProperty}.
-     *
-     * This can be overridden at the model level to provide a custom generator for a model.
-     * The simplest form of this would be:
-     *
-     *      Ext.define('MyApp.data.MyModel', {
-     *          extend: 'Ext.data.Model',
-     *          requires: ['Ext.data.SequentialIdGenerator'],
-     *          idgen: 'sequential',
-     *          ...
-     *      });
-     *
-     * The above would generate {@link Ext.data.SequentialIdGenerator sequential} id's such
-     * as 1, 2, 3 etc..
-     *
-     * Another useful id generator is {@link Ext.data.UuidGenerator}:
-     *
-     *      Ext.define('MyApp.data.MyModel', {
-     *          extend: 'Ext.data.Model',
-     *          requires: ['Ext.data.UuidGenerator'],
-     *          idgen: 'uuid',
-     *          ...
-     *      });
-     *
-     * An id generation can also be further configured:
-     *
-     *      Ext.define('MyApp.data.MyModel', {
-     *          extend: 'Ext.data.Model',
-     *          idgen: {
-     *              type: 'sequential',
-     *              seed: 1000,
-     *              prefix: 'ID_'
-     *          }
-     *      });
-     *
-     * The above would generate id's such as ID_1000, ID_1001, ID_1002 etc..
-     *
-     * If multiple models share an id space, a single generator can be shared:
-     *
-     *      Ext.define('MyApp.data.MyModelX', {
-     *          extend: 'Ext.data.Model',
-     *          idgen: {
-     *              type: 'sequential',
-     *              id: 'xy'
-     *          }
-     *      });
-     *
-     *      Ext.define('MyApp.data.MyModelY', {
-     *          extend: 'Ext.data.Model',
-     *          idgen: {
-     *              type: 'sequential',
-     *              id: 'xy'
-     *          }
-     *      });
-     *
-     * For more complex, shared id generators, a custom generator is the best approach.
-     * See {@link Ext.data.IdGenerator} for details on creating custom id generators.
-     *
-     * @markdown
-     */
-    idgen: {
-        isGenerator: true,
-        type: 'default',
-
-        generate: function () {
-            return null;
-        },
-        getRecId: function (rec) {
-            return rec.modelName + '-' + rec.internalId;
-        }
-    },
-
-    /**
-     * @property {Boolean} editing
-     * Internal flag used to track whether or not the model instance is currently being edited.
-     * @readonly
-     */
-    editing : false,
-
-    /**
-     * @property {Boolean} dirty
-     * True if this Record has been modified.
-     * @readonly
-     */
-    dirty : false,
-
-    /**
-     * @cfg {String} persistenceProperty
-     * The name of the property on this Persistable object that its data is saved to. Defaults to 'data'
-     * (i.e: all persistable data resides in `this.data`.)
-     */
-    persistenceProperty: 'data',
-
-    evented: false,
-
-    /**
-     * @property {Boolean} isModel
-     * `true` in this class to identify an object as an instantiated Model, or subclass thereof.
-     */
-    isModel: true,
-
-    /**
-     * @property {Boolean} phantom
-     * True when the record does not yet exist in a server-side database (see {@link #setDirty}).
-     * Any record which has a real database pk set as its id property is NOT a phantom -- it's real.
-     */
-    phantom : false,
-
-    /**
-     * @cfg {String} idProperty
-     * The name of the field treated as this Model's unique id. Defaults to 'id'.
-     */
-    idProperty: 'id',
-
-    /**
-     * @cfg {String} [clientIdProperty]
-     * The name of a property that is used for submitting this Model's unique client-side identifier
-     * to the server when multiple phantom records are saved as part of the same {@link Ext.data.Operation Operation}.
-     * In such a case, the server response should include the client id for each record
-     * so that the server response data can be used to update the client-side records if necessary.
-     * This property cannot have the same name as any of this Model's fields.
-     */
-    clientIdProperty: null,
-
-    /**
-     * @cfg {String} defaultProxyType
-     * The string type of the default Model Proxy. Defaults to 'ajax'.
-     */
-    defaultProxyType: 'ajax',
-
-    // Fields config and property
-    /**
-     * @cfg {Object[]/String[]} fields
-     * The fields for this model. This is an Array of **{@link Ext.data.Field Field}** definition objects. A Field
-     * definition may simply be the *name* of the Field, but a Field encapsulates {@link Ext.data.Field#type data type},
-     * {@link Ext.data.Field#convert custom conversion} of raw data, and a {@link Ext.data.Field#mapping mapping}
-     * property to specify by name of index, how to extract a field's value from a raw data object, so it is best practice
-     * to specify a full set of {@link Ext.data.Field Field} config objects.
-     */
-    /**
-     * @property {Ext.util.MixedCollection} fields
-     * A {@link Ext.util.MixedCollection Collection} of the fields defined for this Model (including fields defined in superclasses)
-     *
-     * This is a collection of {@link Ext.data.Field} instances, each of which encapsulates information that the field was configured with.
-     * By default, you can specify a field as simply a String, representing the *name* of the field, but a Field encapsulates
-     * {@link Ext.data.Field#type data type}, {@link Ext.data.Field#convert custom conversion} of raw data, and a {@link Ext.data.Field#mapping mapping}
-     * property to specify by name of index, how to extract a field's value from a raw data object.
-     */
-
-    /**
-     * @cfg {Object[]} validations
-     * An array of {@link Ext.data.validations validations} for this model.
-     */
-
-    // Associations configs and properties
-    /**
-     * @cfg {Object[]} associations
-     * An array of {@link Ext.data.Association associations} for this model.
-     */
-    /**
-     * @cfg {String/Object/String[]/Object[]} hasMany
-     * One or more {@link Ext.data.HasManyAssociation HasMany associations} for this model.
-     */
-    /**
-     * @cfg {String/Object/String[]/Object[]} belongsTo
-     * One or more {@link Ext.data.BelongsToAssociation BelongsTo associations} for this model.
-     */
-    /**
-     * @cfg {String/Object/Ext.data.proxy.Proxy} proxy
-     * The {@link Ext.data.proxy.Proxy proxy} to use for this model.
-     */
-
-    /**
-     * @event idchanged
-     * Fired when this model's id changes
-     * @param {Ext.data.Model} this
-     * @param {Number/String} oldId The old id
-     * @param {Number/String} newId The new id
-     */
-
-    // id, raw and convertedData not documented intentionally, meant to be used internally.
-    constructor: function(data, id, raw, convertedData) {
-        data = data || {};
-
-        var me = this,
-            fields,
-            length,
-            field,
-            name,
-            value,
-            newId,
-            persistenceProperty,
-            i;
-
-
-        /**
-         * @property {Number/String} internalId
-         * An internal unique ID for each Model instance, used to identify Models that don't have an ID yet
-         * @private
-         */
-        me.internalId = (id || id === 0) ? id : Ext.data.Model.id(me);
-
-        /**
-         * @property {Object} raw The raw data used to create this model if created via a reader.
-         */
-        me.raw = raw;
-
-        if (!me.data) {
-            me.data = {};
-        }
-
-        /**
-         * @property {Object} modified Key: value pairs of all fields whose values have changed
-         */
-        me.modified = {};
-
-        // Deal with spelling error in previous releases
-        if (me.persistanceProperty) {
-            //<debug>
-            if (Ext.isDefined(Ext.global.console)) {
-                Ext.global.console.warn('Ext.data.Model: persistanceProperty has been deprecated. Use persistenceProperty instead.');
-            }
-            //</debug>
-            me.persistenceProperty = me.persistanceProperty;
-        }
-
-        me[me.persistenceProperty] = convertedData || {};
-
-        me.mixins.observable.constructor.call(me);
-
-        if (!convertedData) {
-            //add default field values if present
-            fields = me.fields.items;
-            length = fields.length;
-            i = 0;
-            persistenceProperty = me[me.persistenceProperty];
-
-            if (Ext.isArray(data)) {
-                for (; i < length; i++) {
-                    field = fields[i];
-                    name  = field.name;
-                    value = data[i];
-
-                    if (value === undefined) {
-                        value = field.defaultValue;
-                    }
-                    // Have to map array data so the values get assigned to the named fields
-                    // rather than getting set as the field names with undefined values.
-                    if (field.convert) {
-                        value = field.convert(value, me);
-                    }
-                    // On instance construction, do not create data properties based on undefined input properties
-                    if (value !== undefined) {
-                        persistenceProperty[name] = value;
-                    }
-                }
-
-            } else {
-               for (; i < length; i++) {
-                    field = fields[i];
-                    name  = field.name;
-                    value = data[name];
-                    if (value === undefined) {
-                        value = field.defaultValue;
-                    }
-                    if (field.convert) {
-                        value = field.convert(value, me);
-                    }
-                    // On instance construction, do not create data properties based on undefined input properties
-                    if (value !== undefined) {
-                        persistenceProperty[name] = value;
-                    }
-               }
-            }
-        }
-
-        /**
-         * @property {Ext.data.Store[]} stores
-         * The {@link Ext.data.Store Stores} to which this instance is bound.
-         */
-        me.stores = [];
-
-        if (me.getId()) {
-            me.phantom = false;
-        } else if (me.phantom) {
-            newId = me.idgen.generate();
-            if (newId !== null) {
-                me.setId(newId);
-            }
-        }
-
-        // clear any dirty/modified since we're initializing
-        me.dirty = false;
-        me.modified = {};
-
-        if (typeof me.init == 'function') {
-            me.init();
-        }
-
-        me.id = me.idgen.getRecId(me);
-    },
-
-    /**
-     * Returns the value of the given field
-     * @param {String} fieldName The field to fetch the value for
-     * @return {Object} The value
-     */
-    get: function(field) {
-        return this[this.persistenceProperty][field];
-    },
-
-    // This object is used whenever the set() method is called and given a string as the
-    // first argument. This approach saves memory (and GC costs) since we could be called
-    // a lot.
-    _singleProp: {},
-
-    /**
-     * Sets the given field to the given value, marks the instance as dirty
-     * @param {String/Object} fieldName The field to set, or an object containing key/value pairs
-     * @param {Object} newValue The value to set
-     * @return {String[]} The array of modified field names or null if nothing was modified.
-     */
-    set: function (fieldName, newValue) {
-        var me = this,
-            data = me[me.persistenceProperty],
-            fields = me.fields,
-            modified = me.modified,
-            single = (typeof fieldName == 'string'),
-            currentValue, field, idChanged, key, modifiedFieldNames, name, oldId,
-            newId, value, values;
-
-        if (single) {
-            values = me._singleProp;
-            values[fieldName] = newValue;
-        } else {
-            values = fieldName;
-        }
-
-        for (name in values) {
-            if (values.hasOwnProperty(name)) {
-                value = values[name];
-
-                if (fields && (field = fields.get(name)) && field.convert) {
-                    value = field.convert(value, me);
-                }
-
-                currentValue = data[name];
-                if (me.isEqual(currentValue, value)) {
-                    continue; // new value is the same, so no change...
-                }
-
-                data[name] = value;
-                (modifiedFieldNames || (modifiedFieldNames = [])).push(name);
-
-                if (field && field.persist) {
-                    if (modified.hasOwnProperty(name)) {
-                        if (me.isEqual(modified[name], value)) {
-                            // The original value in me.modified equals the new value, so
-                            // the field is no longer modified:
-                            delete modified[name];
-
-                            // We might have removed the last modified field, so check to
-                            // see if there are any modified fields remaining and correct
-                            // me.dirty:
-                            me.dirty = false;
-                            for (key in modified) {
-                                if (modified.hasOwnProperty(key)){
-                                    me.dirty = true;
-                                    break;
-                                }
-                            }
-                        }
-                    } else {
-                        me.dirty = true;
-                        modified[name] = currentValue;
-                    }
-                }
-
-                if (name == me.idProperty) {
-                    idChanged = true;
-                    oldId = currentValue;
-                    newId = value;
-                }
-            }
-        }
-
-        if (single) {
-            // cleanup our reused object for next time... important to do this before
-            // we fire any events or call anyone else (like afterEdit)!
-            delete values[fieldName];
-        }
-
-        if (idChanged) {
-            me.fireEvent('idchanged', me, oldId, newId);
-        }
-
-        if (!me.editing && modifiedFieldNames) {
-            me.afterEdit(modifiedFieldNames);
-        }
-
-        return modifiedFieldNames || null;
-    },
-
-    /**
-     * @private
-     * Copies data from the passed record into this record. If the passed record is undefined, does nothing.
-     *
-     * If this is a phantom record (represented only in the client, with no corresponding database entry), and
-     * the source record is not a phantom, then this record acquires the id of the source record.
-     *
-     * @param {Ext.data.Model} sourceRecord The record to copy data from.
-     */
-    copyFrom: function(sourceRecord) {
-        if (sourceRecord) {
-
-            var me = this,
-                fields = me.fields.items,
-                fieldCount = fields.length,
-                field, i = 0,
-                myData = me[me.persistenceProperty],
-                sourceData = sourceRecord[sourceRecord.persistenceProperty],
-                value;
-
-            for (; i < fieldCount; i++) {
-                field = fields[i];
-
-                // Do not use setters.
-                // Copy returned values in directly from the data object.
-                // Converters have already been called because new Records
-                // have been created to copy from.
-                // This is a direct record-to-record value copy operation.
-                value = sourceData[field.name];
-                if (value !== undefined) {
-                    myData[field.name] = value;
-                }
-            }
-
-            // If this is a phantom record being updated from a concrete record, copy the ID in.
-            if (me.phantom && !sourceRecord.phantom) {
-                me.setId(sourceRecord.getId());
-            }
-        }
-    },
-
-    /**
-     * Checks if two values are equal, taking into account certain
-     * special factors, for example dates.
-     * @private
-     * @param {Object} a The first value
-     * @param {Object} b The second value
-     * @return {Boolean} True if the values are equal
-     */
-    isEqual: function(a, b){
-        if (Ext.isDate(a) && Ext.isDate(b)) {
-            return Ext.Date.isEqual(a, b);
-        }
-        return a === b;
-    },
-
-    /**
-     * Begins an edit. While in edit mode, no events (e.g.. the `update` event) are relayed to the containing store.
-     * When an edit has begun, it must be followed by either {@link #endEdit} or {@link #cancelEdit}.
-     */
-    beginEdit : function(){
-        var me = this;
-        if (!me.editing) {
-            me.editing = true;
-            me.dirtySave = me.dirty;
-            me.dataSave = Ext.apply({}, me[me.persistenceProperty]);
-            me.modifiedSave = Ext.apply({}, me.modified);
-        }
-    },
-
-    /**
-     * Cancels all changes made in the current edit operation.
-     */
-    cancelEdit : function(){
-        var me = this;
-        if (me.editing) {
-            me.editing = false;
-            // reset the modified state, nothing changed since the edit began
-            me.modified = me.modifiedSave;
-            me[me.persistenceProperty] = me.dataSave;
-            me.dirty = me.dirtySave;
-            delete me.modifiedSave;
-            delete me.dataSave;
-            delete me.dirtySave;
-        }
-    },
-
-    /**
-     * Ends an edit. If any data was modified, the containing store is notified (ie, the store's `update` event will
-     * fire).
-     * @param {Boolean} silent True to not notify the store of the change
-     * @param {String[]} modifiedFieldNames Array of field names changed during edit.
-     */
-    endEdit : function(silent, modifiedFieldNames){
-        var me = this,
-            changed;
-        if (me.editing) {
-            me.editing = false;
-            if(!modifiedFieldNames) {
-                modifiedFieldNames = me.getModifiedFieldNames();
-            }
-            changed = me.dirty || modifiedFieldNames.length > 0;
-            delete me.modifiedSave;
-            delete me.dataSave;
-            delete me.dirtySave;
-            if (changed && silent !== true) {
-                me.afterEdit(modifiedFieldNames);
-            }
-        }
-    },
-
-    /**
-     * Gets the names of all the fields that were modified during an edit
-     * @private
-     * @return {String[]} An array of modified field names
-     */
-    getModifiedFieldNames: function(){
-        var me = this,
-            saved = me.dataSave,
-            data = me[me.persistenceProperty],
-            modified = [],
-            key;
-
-        for (key in data) {
-            if (data.hasOwnProperty(key)) {
-                if (!me.isEqual(data[key], saved[key])) {
-                    modified.push(key);
-                }
-            }
-        }
-        return modified; 
-    },
-
-    /**
-     * Gets a hash of only the fields that have been modified since this Model was created or commited.
-     * @return {Object}
-     */
-    getChanges : function(){
-        var modified = this.modified,
-            changes  = {},
-            field;
-
-        for (field in modified) {
-            if (modified.hasOwnProperty(field)){
-                changes[field] = this.get(field);
-            }
-        }
-
-        return changes;
-    },
-
-    /**
-     * Returns true if the passed field name has been `{@link #modified}` since the load or last commit.
-     * @param {String} fieldName {@link Ext.data.Field#name}
-     * @return {Boolean}
-     */
-    isModified : function(fieldName) {
-        return this.modified.hasOwnProperty(fieldName);
-    },
-
-    /**
-     * Marks this **Record** as `{@link #dirty}`. This method is used interally when adding `{@link #phantom}` records
-     * to a {@link Ext.data.proxy.Server#writer writer enabled store}.
-     *
-     * Marking a record `{@link #dirty}` causes the phantom to be returned by {@link Ext.data.Store#getUpdatedRecords}
-     * where it will have a create action composed for it during {@link Ext.data.Model#save model save} operations.
-     */
-    setDirty : function() {
-        var me     = this,
-            fields = me.fields.items,
-            fLen   = fields.length,
-            field, name, f;
-
-        me.dirty = true;
-
-        for (f = 0; f < fLen; f++) {
-            field = fields[f];
-
-            if (field.persist) {
-                name  = field.name;
-                me.modified[name] = me.get(name);
-            }
-        }
-    },
-
-    //<debug>
-    markDirty : function() {
-        if (Ext.isDefined(Ext.global.console)) {
-            Ext.global.console.warn('Ext.data.Model: markDirty has been deprecated. Use setDirty instead.');
-        }
-        return this.setDirty.apply(this, arguments);
-    },
-    //</debug>
-
-    /**
-     * Usually called by the {@link Ext.data.Store} to which this model instance has been {@link #join joined}. Rejects
-     * all changes made to the model instance since either creation, or the last commit operation. Modified fields are
-     * reverted to their original values.
-     *
-     * Developers should subscribe to the {@link Ext.data.Store#update} event to have their code notified of reject
-     * operations.
-     *
-     * @param {Boolean} silent (optional) True to skip notification of the owning store of the change.
-     * Defaults to false.
-     */
-    reject : function(silent) {
-        var me = this,
-            modified = me.modified,
-            field;
-
-        for (field in modified) {
-            if (modified.hasOwnProperty(field)) {
-                if (typeof modified[field] != "function") {
-                    me[me.persistenceProperty][field] = modified[field];
-                }
-            }
-        }
-
-        me.dirty = false;
-        me.editing = false;
-        me.modified = {};
-
-        if (silent !== true) {
-            me.afterReject();
-        }
-    },
-
-    /**
-     * Usually called by the {@link Ext.data.Store} which owns the model instance. Commits all changes made to the
-     * instance since either creation or the last commit operation.
-     *
-     * Developers should subscribe to the {@link Ext.data.Store#update} event to have their code notified of commit
-     * operations.
-     *
-     * @param {Boolean} silent (optional) True to skip notification of the owning store of the change.
-     * Defaults to false.
-     */
-    commit : function(silent) {
-        var me = this;
-
-        me.phantom = me.dirty = me.editing = false;
-        me.modified = {};
-
-        if (silent !== true) {
-            me.afterCommit();
-        }
-    },
-
-    /**
-     * Creates a copy (clone) of this Model instance.
-     *
-     * @param {String} [id] A new id, defaults to the id of the instance being copied.
-     * See `{@link Ext.data.Model#id id}`. To generate a phantom instance with a new id use:
-     *
-     *     var rec = record.copy(); // clone the record
-     *     Ext.data.Model.id(rec); // automatically generate a unique sequential id
-     *
-     * @return {Ext.data.Model}
-     */
-    copy : function(newId) {
-        var me = this;
-
-        return new me.self(Ext.apply({}, me[me.persistenceProperty]), newId);
-    },
-
-    /**
-     * Sets the Proxy to use for this model. Accepts any options that can be accepted by
-     * {@link Ext#createByAlias Ext.createByAlias}.
-     *
-     * @param {String/Object/Ext.data.proxy.Proxy} proxy The proxy
-     * @return {Ext.data.proxy.Proxy}
-     */
-    setProxy: function(proxy) {
-        //make sure we have an Ext.data.proxy.Proxy object
-        if (!proxy.isProxy) {
-            if (typeof proxy === "string") {
-                proxy = {
-                    type: proxy
-                };
-            }
-            proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
-        }
-        proxy.setModel(this.self);
-        this.proxy = proxy;
-
-        return proxy;
-    },
-
-    /**
-     * Returns the configured Proxy for this Model.
-     * @return {Ext.data.proxy.Proxy} The proxy
-     */
-    getProxy: function() {
-        return this.proxy;
-    },
-
-    /**
-     * Validates the current data against all of its configured {@link #validations}.
-     * @return {Ext.data.Errors} The errors object
-     */
-    validate: function() {
-        var errors      = new Ext.data.Errors(),
-            validations = this.validations,
-            validators  = Ext.data.validations,
-            length, validation, field, valid, type, i;
-
-        if (validations) {
-            length = validations.length;
-
-            for (i = 0; i < length; i++) {
-                validation = validations[i];
-                field = validation.field || validation.name;
-                type  = validation.type;
-                valid = validators[type](validation, this.get(field));
-
-                if (!valid) {
-                    errors.add({
-                        field  : field,
-                        message: validation.message || validators[type + 'Message']
-                    });
-                }
-            }
-        }
-
-        return errors;
-    },
-
-    /**
-     * Checks if the model is valid. See {@link #validate}.
-     * @return {Boolean} True if the model is valid.
-     */
-    isValid: function(){
-        return this.validate().isValid();
-    },
-
-    /**
-     * Saves the model instance using the configured proxy.
-     * @param {Object} options Options to pass to the proxy. Config object for {@link Ext.data.Operation}.
-     * @return {Ext.data.Model} The Model instance
-     */
-    save: function(options) {
-        options = Ext.apply({}, options);
-
-        var me     = this,
-            action = me.phantom ? 'create' : 'update',
-            scope  = options.scope || me,
-            stores = me.stores,
-            i = 0,
-            storeCount,
-            store,
-            args,
-            operation,
-            callback;
-
-        Ext.apply(options, {
-            records: [me],
-            action : action
-        });
-
-        operation = new Ext.data.Operation(options);
-
-        callback = function(operation) {
-            args = [me, operation];
-            if (operation.wasSuccessful()) {
-                for(storeCount = stores.length; i < storeCount; i++) {
-                    store = stores[i];
-                    store.fireEvent('write', store, operation);
-                    store.fireEvent('datachanged', store);
-                    // Not firing refresh here, since it's a single record
-                }
-                Ext.callback(options.success, scope, args);
-            } else {
-                Ext.callback(options.failure, scope, args);
-            }
-
-            Ext.callback(options.callback, scope, args);
-        };
-
-        me.getProxy()[action](operation, callback, me);
-
-        return me;
-    },
-
-    /**
-     * Destroys the model using the configured proxy.
-     * @param {Object} options Options to pass to the proxy. Config object for {@link Ext.data.Operation}.
-     * @return {Ext.data.Model} The Model instance
-     */
-    destroy: function(options){
-        options = Ext.apply({}, options);
-
-        var me     = this,
-            scope  = options.scope || me,
-            stores = me.stores,
-            i = 0,
-            storeCount,
-            store,
-            args,
-            operation,
-            callback;
-
-        Ext.apply(options, {
-            records: [me],
-            action : 'destroy'
-        });
-
-        operation = new Ext.data.Operation(options);
-        callback = function(operation) {
-            args = [me, operation];
-            if (operation.wasSuccessful()) {
-                for(storeCount = stores.length; i < storeCount; i++) {
-                    store = stores[i];
-                    store.fireEvent('write', store, operation);
-                    store.fireEvent('datachanged', store);
-                    // Not firing refresh here, since it's a single record
-                }
-                me.clearListeners();
-                Ext.callback(options.success, scope, args);
-            } else {
-                Ext.callback(options.failure, scope, args);
-            }
-            Ext.callback(options.callback, scope, args);
-        };
-
-        me.getProxy().destroy(operation, callback, me);
-        return me;
-    },
-
-    /**
-     * Returns the unique ID allocated to this model instance as defined by {@link #idProperty}.
-     * @return {Number/String} The id
-     */
-    getId: function() {
-        return this.get(this.idProperty);
-    },
-
-    /**
-     * @private
-     */
-    getObservableId: function() {
-        return this.id;
-    },
-
-    /**
-     * Sets the model instance's id field to the given id.
-     * @param {Number/String} id The new id
-     */
-    setId: function(id) {
-        this.set(this.idProperty, id);
-        this.phantom  = !(id || id === 0);
-    },
-
-    /**
-     * Tells this model instance that it has been added to a store.
-     * @param {Ext.data.Store} store The store to which this model has been added.
-     */
-    join : function(store) {
-        Ext.Array.include(this.stores, store);
-
-        /**
-         * @property {Ext.data.Store} store
-         * The {@link Ext.data.Store Store} to which this instance belongs. NOTE: If this
-         * instance is bound to multiple stores, this property will reference only the
-         * first. To examine all the stores, use the {@link #stores} property instead.
-         */
-        this.store = this.stores[0]; // compat w/all releases ever
-    },
-
-    /**
-     * Tells this model instance that it has been removed from the store.
-     * @param {Ext.data.Store} store The store from which this model has been removed.
-     */
-    unjoin: function(store) {
-        Ext.Array.remove(this.stores, store);
-        this.store = this.stores[0] || null; // compat w/all releases ever
-    },
-
-    /**
-     * @private
-     * If this Model instance has been {@link #join joined} to a {@link Ext.data.Store store}, the store's
-     * afterEdit method is called
-     * @param {String[]} modifiedFieldNames Array of field names changed during edit.
-     */
-    afterEdit : function(modifiedFieldNames) {
-        this.callStore('afterEdit', modifiedFieldNames);
-    },
-
-    /**
-     * @private
-     * If this Model instance has been {@link #join joined} to a {@link Ext.data.Store store}, the store's
-     * afterReject method is called
-     */
-    afterReject : function() {
-        this.callStore("afterReject");
-    },
-
-    /**
-     * @private
-     * If this Model instance has been {@link #join joined} to a {@link Ext.data.Store store}, the store's
-     * afterCommit method is called
-     */
-    afterCommit: function() {
-        this.callStore('afterCommit');
-    },
-
-    /**
-     * @private
-     * Helper function used by afterEdit, afterReject and afterCommit. Calls the given method on the
-     * {@link Ext.data.Store store} that this instance has {@link #join joined}, if any. The store function
-     * will always be called with the model instance as its single argument. If this model is joined to 
-     * a Ext.data.NodeStore, then this method calls the given method on the NodeStore and the associated Ext.data.TreeStore
-     * @param {String} fn The function to call on the store
-     */
-    callStore: function(fn) {
-        var args = Ext.Array.clone(arguments),
-            stores = this.stores,
-            i = 0,
-            len = stores.length,
-            store, treeStore;
-
-        args[0] = this;
-        for (; i < len; ++i) {
-            store = stores[i];
-            if (store && typeof store[fn] == "function") {
-                store[fn].apply(store, args);
-            }
-            // if the record is bound to a NodeStore call the TreeStore's method as well
-            treeStore = store.treeStore;
-            if (treeStore && typeof treeStore[fn] == "function") {
-                treeStore[fn].apply(treeStore, args);
-            }
-        }
-    },
-
-    /**
-     * Gets all values for each field in this model and returns an object
-     * containing the current data.
-     * @param {Boolean} includeAssociated True to also include associated data. Defaults to false.
-     * @return {Object} An object hash containing all the values in this model
-     */
-    getData: function(includeAssociated){
-        var me     = this,
-            fields = me.fields.items,
-            fLen   = fields.length,
-            data   = {},
-            name, f;
-
-        for (f = 0; f < fLen; f++) {
-            name = fields[f].name;
-            data[name] = me.get(name);
-        }
-
-        if (includeAssociated === true) {
-            Ext.apply(data, me.getAssociatedData());
-        }
-        return data;
-    },
-
-    /**
-     * Gets all of the data from this Models *loaded* associations. It does this recursively - for example if we have a
-     * User which hasMany Orders, and each Order hasMany OrderItems, it will return an object like this:
-     *
-     *     {
-     *         orders: [
-     *             {
-     *                 id: 123,
-     *                 status: 'shipped',
-     *                 orderItems: [
-     *                     ...
-     *                 ]
-     *             }
-     *         ]
-     *     }
-     *
-     * @return {Object} The nested data set for the Model's loaded associations
-     */
-    getAssociatedData: function(){
-        return this.prepareAssociatedData({}, 1);
-    },
-
-    /**
-     * @private
-     * This complex-looking method takes a given Model instance and returns an object containing all data from
-     * all of that Model's *loaded* associations. See {@link #getAssociatedData}
-     * @param {Object} seenKeys A hash of all the associations we've already seen
-     * @param {Number} depth The current depth
-     * @return {Object} The nested data set for the Model's loaded associations
-     */
-    prepareAssociatedData: function(seenKeys, depth) {
-        /**
-         * In this method we use a breadth first strategy instead of depth
-         * first. The reason for doing so is that it prevents messy & difficult
-         * issues when figuring out which associations we've already processed
-         * & at what depths.
-         */
-        var me               = this,
-            associations     = me.associations.items,
-            associationCount = associations.length,
-            associationData  = {},
-            // We keep 3 lists at the same index instead of using an array of objects.
-            // The reasoning behind this is that this method gets called a lot
-            // So we want to minimize the amount of objects we create for GC.
-            toRead           = [],
-            toReadKey        = [],
-            toReadIndex      = [],
-            associatedStore, associatedRecords, associatedRecord, o, index, result, seenDepth,
-            associationId, associatedRecordCount, association, i, j, type, name;
-
-        for (i = 0; i < associationCount; i++) {
-            association = associations[i];
-            associationId = association.associationId;
-            
-            seenDepth = seenKeys[associationId];
-            if (seenDepth && seenDepth !== depth) {
-                continue;
-            }
-            seenKeys[associationId] = depth;
-
-            type = association.type;
-            name = association.name;
-            if (type == 'hasMany') {
-                //this is the hasMany store filled with the associated data
-                associatedStore = me[association.storeName];
-
-                //we will use this to contain each associated record's data
-                associationData[name] = [];
-
-                //if it's loaded, put it into the association data
-                if (associatedStore && associatedStore.getCount() > 0) {
-                    associatedRecords = associatedStore.data.items;
-                    associatedRecordCount = associatedRecords.length;
-
-                    //now we're finally iterating over the records in the association. Get
-                    // all the records so we can process them
-                    for (j = 0; j < associatedRecordCount; j++) {
-                        associatedRecord = associatedRecords[j];
-                        associationData[name][j] = associatedRecord.getData();
-                        toRead.push(associatedRecord);
-                        toReadKey.push(name);
-                        toReadIndex.push(j);
-                    }
-                }
-            } else if (type == 'belongsTo' || type == 'hasOne') {
-                associatedRecord = me[association.instanceName];
-                // If we have a record, put it onto our list
-                if (associatedRecord !== undefined) {
-                    associationData[name] = associatedRecord.getData();
-                    toRead.push(associatedRecord);
-                    toReadKey.push(name);
-                    toReadIndex.push(-1);
-                }
-            }
-        }
-        
-        for (i = 0, associatedRecordCount = toRead.length; i < associatedRecordCount; ++i) {
-            associatedRecord = toRead[i];
-            o = associationData[toReadKey[i]];
-            index = toReadIndex[i];
-            result = associatedRecord.prepareAssociatedData(seenKeys, depth + 1);
-            if (index === -1) {
-                Ext.apply(o, result);
-            } else {
-                Ext.apply(o[index], result);
-            }
-        }
-
-        return associationData;
-    }
-});