sproutcore 1.0.1046 → 1.0.1049.pre.1

data/frameworks/sproutcore/frameworks/datastore/models/record_attribute.js

@@ -2,10 +2,11 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('models/record');
+sc_require('models/child_record');
 
 /** @class
 
@@ -215,22 +216,30 @@ SC.RecordAttribute = SC.Object.extend(
   call: function(record, key, value) {
     var attrKey = this.get('key') || key, nvalue;
     
-    if (value !== undefined) {
-
+    if ((value !== undefined) && this.get('isEditable')) {
       // careful: don't overwrite value here.  we want the return value to 
       // cache.
       nvalue = this.fromType(record, key, value) ; // convert to attribute.
       record.writeAttribute(attrKey, nvalue); 
-    } else {
-      value = record.readAttribute(attrKey);
-      if (SC.none(value) && (value = this.get('defaultValue'))) {
-        if (typeof value === SC.T_FUNCTION) {
-          value = this.defaultValue(record, key, this);
-          // write default value so it doesn't have to be executed again
-          if(record.attributes()) record.writeAttribute(attrKey, value, true);
+    } 
+
+    nvalue = value = record.readAttribute(attrKey);
+    if (SC.none(value) && (value = this.get('defaultValue')) && record.get('status') & SC.Record.READY_NEW) {
+       if (typeof value === SC.T_FUNCTION) {
+        nvalue = this.defaultValue(record, key, this);
+        // write default value so it doesn't have to be executed again
+        if ((nvalue !== value)  &&  record.get('store').readDataHash(record.get('storeKey'))) {
+          value = nvalue;
+          record.writeAttribute(attrKey, value, true);
         }
-      } else value = this.toType(record, key, value);
-    }
+      } else {
+        if (SC.kindOf(value, SC.DateTime)) {
+          record.writeAttribute(attrKey, value.toISO8601(), true);
+        } else {
+          record.writeAttribute(attrKey, value, true);
+        }
+      }
+    } else value = this.toType(record, key, value);
     
     return value ;
   },
@@ -391,13 +400,18 @@ SC.RecordAttribute.registerTransform(Date, {
 
   /** @private - convert a string to a Date */
   to: function(str, attr) {
+    if (str === null) {
+      return null;
+    }
+    
     var ret ;
+    str = str.toString() || '';
     
     if (attr.get('useIsoDate')) {
       var regexp = "([0-9]{4})(-([0-9]{2})(-([0-9]{2})" +
              "(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(\\.([0-9]+))?)?" +
              "(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?",
-          d      = str.toString().match(new RegExp(regexp)),
+          d      = str.match(new RegExp(regexp)),
           offset = 0,
           date   = new Date(d[1], 0, 1),
           time ;

data/frameworks/sproutcore/frameworks/datastore/models/single_attribute.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('models/record');

data/frameworks/sproutcore/frameworks/datastore/system/child_array.js

@@ -0,0 +1,242 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2010 Evin Grano
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  @class
+
+  A ChildArray is used to map an array of ChildRecord
+  
+  @extends SC.Enumerable
+  @extends SC.Array
+  @since SproutCore 1.0
+*/
+
+SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
+  /** @scope SC.ManyArray.prototype */ {
+    
+  /**
+    If set, it is the default record recordType
+  
+    @property {SC.Record}
+  */
+  defaultRecordType: null,
+  
+  /**
+    If set, the parent record will be notified whenever the array changes so that 
+    it can change its own state
+    
+    @property {SC.Record}
+  */
+  record: null,
+  
+  /**
+    If set will be used by the many array to get an editable version of the
+    storeIds from the owner.
+    
+    @property {String}
+  */
+  propertyName: null,
+  
+  /**
+    Actual references to the hashes
+  */
+  children: null,
+  
+  /**
+    The store that owns this record array.  All record arrays must have a 
+    store to function properly.
+
+    @property {SC.Store}
+  */
+  store: function() {
+    return this.get('record').get('store');
+  }.property('record').cacheable(),
+  
+  /**
+    The storeKey for the parent record of this many array.  Editing this 
+    array will place the parent record into a READY_DIRTY state.
+
+    @property {Number}
+  */
+  storeKey: function() {
+    return this.get('record').get('storeKey');
+  }.property('record').cacheable(),
+  
+  /**
+    Returns the storeIds in read only mode.  Avoids modifying the record 
+    unnecessarily.
+    
+    @property {SC.Array}
+  */
+  readOnlyChildren: function() {
+    return this.get('record').readAttribute(this.get('propertyName'));
+  }.property(),
+  
+  /**
+    Returns an editable array of child hashes.  Marks the owner records as 
+    modified. 
+    
+    @property {SC.Array}
+  */
+  editableChildren: function() {
+    var store    = this.get('store'),
+        storeKey = this.get('storeKey'),
+        pname    = this.get('propertyName'),
+        ret, hash;
+        
+    ret = store.readEditableProperty(storeKey, pname);    
+    if (!ret) {
+      hash = store.readEditableDataHash(storeKey);
+      ret = hash[pname] = [];      
+    }
+    
+    if (ret !== this._prevChildren) this.recordPropertyDidChange();
+    return ret ;
+  }.property(),
+    
+  // ..........................................................
+  // ARRAY PRIMITIVES
+  // 
+
+  /** @private
+    Returned length is a pass-through to the storeIds array.
+    
+    @property {Number}
+  */
+  length: function() {
+    var children = this.get('readOnlyChildren');
+    return children ? children.length : 0;
+  }.property('readOnlyChildren'),
+
+  /** @private
+    Looks up the store id in the store ids array and materializes a
+    records.
+  */
+  objectAt: function(idx) {
+    var recs      = this._records, 
+        children = this.get('readOnlyChildren'),
+        hash, ret;
+    var len = children ? children.length : 0;
+    
+    if (!children) return undefined; // nothing to do
+    if (recs && (ret=recs[idx])) return ret ; // cached
+    if (!recs) this._records = recs = [] ; // create cache
+    
+    // If not a good index return undefined
+    if (idx >= len) return undefined;
+    hash = children.objectAt(idx);
+    if (!hash) return undefined;
+    
+    // not in cache, materialize
+    recs[idx] = ret = this._materializeChild(hash);
+    
+    return ret;
+  },
+
+  /** @private
+    Pass through to the underlying array.  The passed in objects must be
+    records, which can be converted to storeIds.
+  */
+  replace: function(idx, amt, recs) {
+    var children = this.get('editableChildren'), 
+        len      = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
+        record   = this.get('record'),
+        
+        pname    = this.get('propertyName'),
+        cr, recordType;  
+    children.replace(idx, amt, recs);
+    for(var i = idx; i <= idx+amt; i+=1){
+      this.objectAt(i);
+    }
+    // notify that the record did change...
+    record.recordDidChange(pname);
+    
+    return this;
+  },
+  
+  /*
+  calls normalize on each object in the array
+  */
+  normalize: function(){
+    this.forEach(function(child,id){
+      if(child.normalize) child.normalize();
+    });
+  },
+  
+  // ..........................................................
+  // INTERNAL SUPPORT
+  //  
+  
+  /** @private
+    Call to create an object from a hash
+  */
+  _materializeChild: function(hash){
+    var store = this.get('store'),
+        parentRecord = this.get('record'), 
+        recordType = this.get('defaultRecordType'),
+        id, ret, storeKey, pm;
+        
+    // Find the record type
+    if (!parentRecord) return undefined;
+    var nspace = parentRecord.get('childRecordNamespace');
+    // Get the record type.
+    if (hash.type && !SC.none(nspace)) {
+      recordType = nspace[hash.type];
+    }
+
+    if (!recordType || SC.typeOf(recordType) !== SC.T_CLASS) {
+      throw 'ChildrenArray: Error during transform: Invalid record type.';
+    }
+    
+    pm = recordType.prototype.primaryKey || 'childRecordKey';
+    id = hash[pm];
+    storeKey = store.storeKeyExists(recordType, id);
+    if (storeKey){
+      ret = store.materializeRecord(storeKey);
+    } 
+    else {
+      ret = parentRecord.registerChildRecord(recordType, hash);
+    }
+    return ret;
+  },
+
+  /** @private 
+    Invoked whenever the children array changes.  Observes changes.
+  */
+  recordPropertyDidChange: function(keys) {
+    
+    if (keys && !keys.contains(this.get('propertyName'))) return this;
+    
+    var children = this.get('readOnlyChildren');
+    var prev = this._prevChildren, f = this._childrenContentDidChange;
+    
+    if (children === prev) return this; // nothing to do
+    
+    if (prev) prev.removeObserver('[]', this, f);
+    this._prevChildren = children;
+    if (children) children.addObserver('[]', this, f);
+    
+    var rev = (children) ? children.propertyRevision : -1 ;
+    this._childrenContentDidChange(children, '[]', children, rev);
+  },
+
+  /** @private
+    Invoked whenever the content of the children array changes.  This will
+    dump any cached record lookup and then notify that the enumerable content
+    has changed.
+  */
+  _childrenContentDidChange: function(target, key, value, rev) {
+    this._records = null ; // clear cache
+    this.enumerableContentDidChange();
+  },
+  
+  /** @private */
+  init: function() {
+    sc_super();
+    this.recordPropertyDidChange();
+  }
+  
+}) ;

data/frameworks/sproutcore/frameworks/datastore/system/many_array.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 /**
@@ -170,7 +170,7 @@ SC.ManyArray = SC.Object.extend(SC.Enumerable, SC.Array,
   length: function() {
     var storeIds = this.get('readOnlyStoreIds');
     return storeIds ? storeIds.get('length') : 0;
-  }.property('readOnlyStoreIds').cacheable(),
+  }.property('readOnlyStoreIds'),
 
   /** @private
     Looks up the store id in the store ids array and materializes a
@@ -232,7 +232,7 @@ SC.ManyArray = SC.Object.extend(SC.Enumerable, SC.Array,
       if (toRemove) SC.ManyArray._toRemove = null; // reuse if possible
       else toRemove = [];
       
-      for(i=0;i<amt;i++) toRemove[i] = this.objectAt(i);
+      for(i=0;i<amt;i++) toRemove[i] = this.objectAt(idx + i);
     }
     
     // pass along - if allowed, this should trigger the content observer 

data/frameworks/sproutcore/frameworks/datastore/system/nested_store.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('system/store');
@@ -95,7 +95,7 @@ SC.NestedStore = SC.Store.extend(
     chained stores.  For a log changes that may actually be committed back to
     the server see the changelog property.
     
-    @property {Array}
+    @property {SC.Set}
   */
   chainedChanges: null,
     
@@ -141,23 +141,22 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   discardChanges: function() {
-    
     // any locked records whose rev or lock rev differs from parent need to
     // be notified.
     var records, locks;
     if ((records = this.records) && (locks = this.locks)) {
       var pstore = this.get('parentStore'), psRevisions = pstore.revisions;
       var revisions = this.revisions, storeKey, lock, rev;
-      for(storeKey in records) {
+      for (storeKey in records) {
         if (!records.hasOwnProperty(storeKey)) continue ;
         if (!(lock = locks[storeKey])) continue; // not locked.
 
         rev = psRevisions[storeKey];
         if ((rev !== lock) || (revisions[storeKey] > rev)) {
-          this._notifyRecordPropertyChange(storeKey);
+          this._notifyRecordPropertyChange(parseInt(storeKey, 10));
         }
       }
-    }
+    }   
     
     this.reset();
     this.flush();
@@ -325,20 +324,37 @@ SC.NestedStore = SC.Store.extend(
     much. 
   */
   writeDataHash: function(storeKey, hash, status) {
-    var locks = this.locks, rev ;
-    
-    // update dataHashes and optionally status.  Note that if status is not
-    // passed, we want to copy the reference to the status anyway to lock it
-    // in.
-    if (hash) this.dataHashes[storeKey] = hash;
-    this.statuses[storeKey] = status ? status : (this.statuses[storeKey] || SC.Record.READY_NEW);
-    rev = this.revisions[storeKey] = this.revisions[storeKey]; // copy ref
+    var locks = this.locks, didLock = NO, rev ;
+
+    // Update our dataHash and/or status, depending on what was passed in.
+    // Note that if no new hash was passed in, we'll lock the storeKey to
+    // properly fork our dataHash from our parent store.  Similarly, if no
+    // status was passed in, we'll save our own copy of the value.
+    if (hash) {
+      this.dataHashes[storeKey] = hash;
+    }
+    else {
+      this._lock(storeKey);
+      didLock = YES;
+    }
+
+    if (status) {
+      this.statuses[storeKey] = status;
+    }
+    else {
+      if (!didLock) this.statuses[storeKey] = (this.statuses[storeKey] || SC.Record.READY_NEW);
+    }
+
+    if (!didLock) {
+      rev = this.revisions[storeKey] = this.revisions[storeKey]; // copy ref
     
-    // make sure we lock if needed.
-    if (!locks) locks = this.locks = [];
-    if (!locks[storeKey]) locks[storeKey] = rev || 1;
+      // make sure we lock if needed.
+      if (!locks) locks = this.locks = [];
+      if (!locks[storeKey]) locks[storeKey] = rev || 1;
+    }
     
-    // also note that this hash is now editable
+    // Also note that this hash is now editable.  (Even if we locked it,
+    // above, it may not have been marked as editable.)
     var editables = this.editables;
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support

data/frameworks/sproutcore/frameworks/datastore/system/query.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('core') ;
@@ -178,11 +178,15 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
   conditions:  null,
   
   /**
-    Optional orderBy parameters.  This will be a string of keys, optionally
+    Optional orderBy parameters.  This can be a string of keys, optionally
     beginning with the strings "DESC " or "ASC " to select descending or 
     ascending order.
     
-    @property {String}
+    Alternatively, you can specify a comparison function, in which case the
+    two records will be sent to it.  Your comparison function, as with any
+    other, is expected to return -1, 0, or 1.
+    
+    @property {String | Function}
   */
   orderBy:     null,
   
@@ -383,6 +387,13 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
                       0 if equal
   */
   compare: function(record1, record2) {
+    // IMPORTANT:  THIS CODE IS ALSO INLINED INSIDE OF THE 'compareStoreKeys'
+    //             CLASS METHOD.  IF YOU CHANGE THIS IMPLEMENTATION, BE SURE
+    //             TO UPDATE IT THERE, TOO.
+    //
+    // (Any clients overriding this method will have their version called,
+    // however.  That's why we'll keep this here; clients might want to
+    // override it and call sc_super()).
 
     var result = 0, 
         propertyName, order, len, i;
@@ -396,23 +407,30 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       return SC.compare(record1.get('id'),record2.get('id'));
     }
     
-    // for every property specified in orderBy until non-eql result is found
+    // For every property specified in orderBy until non-eql result is found.
+    // Or, if orderBy is a comparison function, simply invoke it with the
+    // records.
     order = this._order;
-    len   = order ? order.length : 0;
-    for (i=0; result===0 && (i < len); i++) {
-      propertyName = order[i].propertyName;
-      // if this property has a registered comparison use that
-      if (SC.Query.comparisons[propertyName]) {
-        result = SC.Query.comparisons[propertyName](
-                  record1.get(propertyName),record2.get(propertyName));
+    if (SC.typeOf(order) === SC.T_FUNCTION) {
+      result = order.call(null, record1, record2);
+    }
+    else {
+      len   = order ? order.length : 0;
+      for (i=0; result===0 && (i < len); i++) {
+        propertyName = order[i].propertyName;
+        // if this property has a registered comparison use that
+        if (SC.Query.comparisons[propertyName]) {
+          result = SC.Query.comparisons[propertyName](
+                    record1.get(propertyName),record2.get(propertyName));
                   
-      // if not use default SC.compare()
-      } else {
-        result = SC.compare(
-                  record1.get(propertyName), record2.get(propertyName) );
-      }
+        // if not use default SC.compare()
+        } else {
+          result = SC.compare(
+                    record1.get(propertyName), record2.get(propertyName) );
+        }
       
-      if ((result!==0) && order[i].descending) result = (-1) * result;
+        if ((result!==0) && order[i].descending) result = (-1) * result;
+      }
     }
 
     // return result or compare by guid
@@ -528,9 +546,9 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     },
 
     'NUMBER': {
-      firstCharacter:   /\d/,
-      notAllowed:       /[^\d\.]/,
-      format:           /^\d+$|^\d+\.\d+$/,
+      firstCharacter:   /[\d\-]/,
+      notAllowed:       /[^\d\-\.]/,
+      format:           /^-?\d+$|^-?\d+\.\d+$/,
       evalType:         'PRIMITIVE',
       
       /** @ignore */
@@ -625,7 +643,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left == right;
+                          return SC.isEqual(left, right); 
                         }
     },
 
@@ -639,7 +657,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left != right;
+                          return !SC.isEqual(left, right); 
                         }
     },
 
@@ -653,7 +671,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left < right;
+                          return SC.compare(left, right) == -1; //left < right;
                         }
     },
 
@@ -667,7 +685,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left <= right;
+                          return SC.compare(left, right) != 1; //left <= right;
                         }
     },
 
@@ -681,7 +699,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left > right;
+                          return SC.compare(left, right) == 1; //left > right;
                         }
     },
 
@@ -695,7 +713,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       evaluate:         function (r,w) {
                           var left  = this.leftSide.evaluate(r,w);
                           var right = this.rightSide.evaluate(r,w);
-                          return left >= right;
+                          return SC.compare(left, right) != -1; //left >= right;
                         }
     },
 
@@ -1176,15 +1194,18 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     describing this order for easier processing.
     Called by parse().
     
-    @param {String} orderString the string containing the order statement
-    @returns {Array} array of order statement
+    @param {String | Function} orderOp the string containing the order statement, or a comparison function
+    @returns {Array | Function} array of order statement, or a function if a function was specified
   */
-  buildOrder: function (orderString) {
-    if (!orderString) {
+  buildOrder: function (orderOp) {
+    if (!orderOp) {
       return [];
     }
+    else if (SC.typeOf(orderOp) === SC.T_FUNCTION) {
+      return orderOp;
+    }
     else {
-      var o = orderString.split(',');
+      var o = orderOp.split(',');
       for (var i=0; i < o.length; i++) {
         var p = o[i];
         p = p.replace(/^\s+|\s+$/,'');
@@ -1270,19 +1291,19 @@ SC.Query.mixin( /** @scope SC.Query */ {
       // Do this instead of generating a temporary closure function for perf.
       // We'll use a stack-based approach in case our sort routine ends up
       // calling code that triggers a recursive invocation of orderStoreKeys.
-      var K             = SC.Query;
-          tempStores    = K._TMP_STORES;
-          tempQueryKeys = K._TMP_QUERY_KEYS;
-      if (!tempStores)    tempStores    = K._TMP_STORES = [];
-      if (!tempQueryKeys) tempQueryKeys = K._TMP_QUERY_KEYS = [];
+      var K           = SC.Query,
+          tempStores  = K._TMP_STORES,
+          tempQueries = K._TMP_QUERIES;
+      if (!tempStores)  tempStores  = K._TMP_STORES = [];
+      if (!tempQueries) tempQueries = K._TMP_QUERIES = [];
       
       tempStores.push(store);
-      tempQueryKeys.push(query);
+      tempQueries.push(query);
         
       var res = storeKeys.sort(SC.Query.compareStoreKeys);
       
       K._TMP_STORES.pop();
-      K._TMP_QUERY_KEYS.pop();
+      K._TMP_QUERIES.pop();
     }
 
     return storeKeys;
@@ -1297,15 +1318,71 @@ SC.Query.mixin( /** @scope SC.Query */ {
     @param {Number} storeKey2 a store key
     @returns {Number} -1 if record1 < record2,  +1 if record1 > record2, 0 if equal
   */
-  compareStoreKeys: function(storeKey1, storeKey2) {    
-    var K             = SC.Query,
-        tempStores    = K._TMP_STORES,
-        tempQueryKeys = K._TMP_QUERY_KEYS;
-        store         = tempStores[tempStores.length - 1],
-        queryKey      = tempQueryKeys[tempQueryKeys.length - 1],
-        record1       = store.materializeRecord(storeKey1),
-        record2       = store.materializeRecord(storeKey2);
-    return queryKey.compare(record1, record2);
+  compareStoreKeys: function(storeKey1, storeKey2) {
+    var K           = SC.Query,
+        tempStores  = K._TMP_STORES,
+        tempQueries = K._TMP_QUERIES,
+        store       = tempStores[tempStores.length - 1],
+        query       = tempQueries[tempQueries.length - 1],
+        compareFunc = query.compare,
+        record1     = store.materializeRecord(storeKey1),
+        record2     = store.materializeRecord(storeKey2);
+
+    // If the query implements a custom 'compare' function, then use it.
+    // Otherwise, we have the logic from the standard version inlined here.
+    if (compareFunc !== K.prototype.compare) {
+      return compareFunc.call(query, record1, record2);
+    }
+    else {
+      // THIS CODE IS THE SAME AS THE 'compare' METHOD, EXCEPT THAT 'this' HAS
+      // BEEN CHANGED TO 'query'.
+      //
+      // It is inlined here to avoid the extra method invocation in the
+      // typical case where the client does not supply a custom 'compare'
+      // function.
+      
+      var result = 0, 
+          propertyName, order, len, i;
+
+      // fast cases go here
+      if (record1 === record2) return 0;
+    
+      // if called for the first time we have to build the order array
+      if (!query._isReady) query.parse();
+      if (!query._isReady) { // can't parse. guid is wrong but consistent
+        return SC.compare(record1.get('id'),record2.get('id'));
+      }
+    
+      // For every property specified in orderBy until non-eql result is found.
+      // Or, if orderBy is a comparison function, simply invoke it with the
+      // records.
+      order = query._order;
+      if (SC.typeOf(order) === SC.T_FUNCTION) {
+        result = order.call(null, record1, record2);
+      }
+      else {
+        len   = order ? order.length : 0;
+        for (i=0; result===0 && (i < len); i++) {
+          propertyName = order[i].propertyName;
+          // if query property has a registered comparison use that
+          if (SC.Query.comparisons[propertyName]) {
+            result = SC.Query.comparisons[propertyName](
+                      record1.get(propertyName),record2.get(propertyName));
+                  
+          // if not use default SC.compare()
+          } else {
+            result = SC.compare(
+                      record1.get(propertyName), record2.get(propertyName) );
+          }
+      
+          if ((result!==0) && order[i].descending) result = (-1) * result;
+        }
+      }
+
+      // return result or compare by guid
+      if (result !== 0) return result ;
+      else return SC.compare(record1.get('id'),record2.get('id'));
+    }
   },
   
   /**