sproutcore 1.11.0.rc2 → 1.11.0.rc3

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/theming.js

@@ -76,8 +76,9 @@ SC.View.reopen(
     Also, because
   */
   _sc_view_themeDidChange: function() {
-    if (this._lastTheme === this.get('theme')) { return; }
-    this._lastTheme = this.get('theme');
+    var curTheme = this.get('theme');
+    if (this._lastTheme === curTheme) { return; }
+    this._lastTheme = curTheme;
 
     // invalidate child view base themes, if present
     var childViews = this.childViews, len = childViews.length, idx;

data/lib/frameworks/sproutcore/frameworks/datastore/data_sources/data_source.js

@@ -194,18 +194,15 @@ SC.MIXED_STATE = '__MIXED__';
 
    * `dataSourceDidFetchQuery(query)` — the data source must call this when
      it has completed fetching any related data for the query. This returns the
-     query results (i.e. the record array) status into a `READY` state.
+     query results (i.e. the record array) status into a `READY` state. If the query is a 'remote'
+     type, the ordered array of store keys representing the results from the server must be passed
+     as a second argument.
    * `dataSourceDidErrorQuery(query, error)` — the data source should call
      this if it encounters an error in executing the query. This puts the query
      results into an `ERROR` state.
    * `dataSourceDidCancelQuery(query)` — the data source should call this
      if loading the results is cancelled.
 
-  In addition to these callbacks, the method `loadQueryResults(query, storeKey)`
-  is used by data sources when handling remote queries. This method is similar to
-  `dataSourceDidFetchQuery()`, except that you also provide an array of storeKeys
-  (or a promise to provide store keys) that comprises the result set.
-
   @extend SC.Object
   @since SproutCore 1.0
 */
@@ -248,13 +245,11 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
     server instead of from memory.  Usually you will only need to use this
     type of query when loading large amounts of data from the server.
 
-    Like Local queries, to fetch a remote query you will need to load any data
+    Like local queries, to fetch a remote query you will need to load any data
     you need to fetch from the server and add the records to the store.  Once
     you are finished loading this data, however, you must also call
-    SC.Store#loadQueryResults() to actually set an array of storeKeys that
-    represent the latest results from the server.  This will implicitly also
-    call datasSourceDidFetchQuery() so you don't need to call this method
-    yourself.
+    SC.Store#dataSourceDidFetchQuery() with the array of storeKeys that
+    represent the latest results from the server.
 
     If you want to support incremental loading from the server for remote
     queries, you can do so by passing a SC.SparseArray instance instead of

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

@@ -133,14 +133,52 @@ SC.NestedStore = SC.Store.extend(
   commitChanges: function(force) {
     if (this.get('hasChanges')) {
       var pstore = this.get('parentStore');
-      pstore.commitChangesFromNestedStore(this, this.chainedChanges, force);
+      pstore.commitChangesFromNestedStore(this, this.get('chainedChanges'), force);
     }
 
     // clear out custom changes - even if there is nothing to commit.
     this.reset();
-    return this ;
+    return this;
   },
 
+  /**
+    An array of store keys for all conflicting records with the parent store. If there are no
+    conflicting records, this property will be null.
+
+    @readonly
+    @field
+    @type Array
+    @default null
+  */
+  conflictedStoreKeys: function () {
+    var ret = null;
+
+    if (this.get('hasChanges')) {
+      var pstore = this.get('parentStore'),
+          locks = this.locks,
+          revisions = pstore.revisions;
+
+      if (locks && revisions) {
+        var changes = this.get('chainedChanges');
+
+        for (var i = 0, len = changes.length; i < len; i++) {
+          var storeKey = changes[i],
+              lock = locks[storeKey] || 1,
+              revision = revisions[storeKey] || 1;
+
+          // If the same revision for the item does not match the current revision, then someone has
+          // changed the data hash in this store and we have a conflict.
+          if (lock < revision) {
+            if (!ret) ret = [];
+            ret.push(storeKey);
+          }
+        }
+      }
+    }
+
+    return ret;
+  }.property('chainedChanges').cacheable(),
+
   /**
     Propagate this store's successful changes to its parent (if exists). At the end, it clears the
     local, private status of the committed records therefore the method can be called several times
@@ -150,37 +188,41 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   commitSuccessfulChanges: function(force) {
-    if (this.get('hasChanges') && this.chainedChanges) {
-      var chainedChanges = this.chainedChanges,
-          dataHashes = this.dataHashes,
+    var chainedChanges = this.get('chainedChanges');
+
+    if (this.get('hasChanges') && chainedChanges) {
+      var dataHashes = this.dataHashes,
           revisions  = this.revisions,
           statuses   = this.statuses,
           editables  = this.editables,
           locks      = this.locks;
+
       var successfulChanges = chainedChanges.filter( function(storeKey) {
         var state = this.readStatus(storeKey);
 
-        return state===SC.Record.READY_CLEAN || state===SC.Record.DESTROYED_CLEAN;
+        return state === SC.Record.READY_CLEAN || state === SC.Record.DESTROYED_CLEAN;
       }, this );
+
       var pstore = this.get('parentStore');
 
       pstore.commitChangesFromNestedStore(this, successfulChanges, force);
 
       // remove the local status so these records that have been successfully committed on the server
       // are no longer retrieved from this nested store but from the parent
-      successfulChanges.forEach(function(storeKey)
-      {
-        if (dataHashes && dataHashes.hasOwnProperty(storeKey))
-          delete dataHashes[storeKey];
-        if (revisions && revisions.hasOwnProperty(storeKey))
-          delete revisions[storeKey];
-        if (editables) delete editables[storeKey];
-        if (locks) delete locks[storeKey];
-        if (statuses && statuses.hasOwnProperty(storeKey))
-          delete statuses[storeKey];
-        chainedChanges.remove( storeKey );
-      }, this );
+      for (var i = 0, len = successfulChanges.get('length'); i < len; i++) {
+        var storeKey = successfulChanges.objectAt(i);
+
+        if (dataHashes && dataHashes.hasOwnProperty(storeKey)) { delete dataHashes[storeKey]; }
+        if (revisions && revisions.hasOwnProperty(storeKey)) { delete revisions[storeKey]; }
+        if (editables) { delete editables[storeKey]; }
+        if (locks) { delete locks[storeKey]; }
+        if (statuses && statuses.hasOwnProperty(storeKey)) { delete statuses[storeKey]; }
+
+        chainedChanges.remove(storeKey);
+      }
 
+      // Indicate that chainedChanges has changed.
+      if (successfulChanges.length > 0) { this.notifyPropertyChange('chainedChanges'); }
     }
 
     return this;
@@ -234,7 +276,6 @@ SC.NestedStore = SC.Store.extend(
     Resets a store's data hash contents to match its parent.
   */
   reset: function() {
-    var nRecords, nr, sk;
     // requires a pstore to reset
     var parentStore = this.get('parentStore');
     if (!parentStore) throw SC.Store.NO_PARENT_STORE_ERROR;
@@ -249,12 +290,11 @@ SC.NestedStore = SC.Store.extend(
     this.parentRecords = parentStore.parentRecords ? SC.beget(parentStore.parentRecords) : {};
 
     // also, reset private temporary objects
+    this.set('hasChanges', false);
     this.chainedChanges = this.locks = this.editables = null;
     this.changelog = null ;
 
     // TODO: Notify record instances
-
-    this.set('hasChanges', NO);
   },
 
   /** @private
@@ -435,6 +475,9 @@ SC.NestedStore = SC.Store.extend(
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support
 
+    // propagate the data to the child records
+    this._updateChildRecordHashes(storeKey, hash, status);
+
     return this ;
   },
 
@@ -465,18 +508,36 @@ SC.NestedStore = SC.Store.extend(
       storeKey = storeKeys;
     }
 
-    var changes = this.chainedChanges;
+    var changes = this.get('chainedChanges');
     if (!changes) changes = this.chainedChanges = SC.Set.create();
 
-    for(idx=0;idx<len;idx++) {
+    var that = this,
+        didAddChainedChanges = false;
+
+    for (idx = 0; idx < len; idx++) {
       if (isArray) storeKey = storeKeys[idx];
+
       this._lock(storeKey);
       this.revisions[storeKey] = rev;
-      changes.add(storeKey);
+
+      if (!changes.contains(storeKey)) {
+        changes.add(storeKey);
+        didAddChainedChanges = true;
+      }
+
       this._notifyRecordPropertyChange(storeKey, statusOnly, key);
+
+      // notify also the child records
+      this._propagateToChildren(storeKey, function(storeKey){
+        that.dataHashDidChange(storeKey, null, statusOnly, key);
+      });
     }
 
     this.setIfChanged('hasChanges', YES);
+    if (didAddChainedChanges) {
+      this.notifyPropertyChange('chainedChanges');
+    }
+
     return this ;
   },
 
@@ -492,7 +553,11 @@ SC.NestedStore = SC.Store.extend(
     // save a lock for each store key if it does not have one already
     // also add each storeKey to my own changes set.
     var pstore = this.get('parentStore'), psRevisions = pstore.revisions, i;
-    var myLocks = this.locks, myChanges = this.chainedChanges,len,storeKey;
+    var myLocks = this.locks,
+        myChanges = this.get('chainedChanges'),
+        len,
+        storeKey;
+
     if (!myLocks) myLocks = this.locks = [];
     if (!myChanges) myChanges = this.chainedChanges = SC.Set.create();
 
@@ -504,7 +569,9 @@ SC.NestedStore = SC.Store.extend(
     }
 
     // Finally, mark store as dirty if we have changes
-    this.setIfChanged('hasChanges', myChanges.get('length')>0);
+    this.setIfChanged('hasChanges', myChanges.get('length') > 0);
+    this.notifyPropertyChange('chainedChanges');
+
     this.flush();
 
     return this ;
@@ -533,7 +600,7 @@ SC.NestedStore = SC.Store.extend(
     because that can disconnect us from upper and/or lower stores.
   */
   retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh, callbacks) {
-    var pstore = this.get('parentStore'), idx, storeKey, newStatus,
+    var pstore = this.get('parentStore'), idx, storeKey,
       len = (!storeKeys) ? ids.length : storeKeys.length,
       K = SC.Record, status;
 

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

@@ -11,51 +11,114 @@ sc_require('models/record');
 /**
   @class
 
-  This class permits you to perform queries on your data store or a remote
-  data store. Here is a simple example of a local query:
+  This class permits you to perform queries on your data store or a remote data store. Here is a
+  simple example of a *local* (see below) query,
 
       query = SC.Query.create({
-        conditions: "firstName = 'Jonny' AND lastName = 'Cash'"
+        conditions: "firstName = 'Johnny' AND lastName = 'Cash'"
       });
 
-  To find all records of your store, that match the query, use find with
-  the query as an argument:
+  This query, when used with the store, will return all records which have record attributes of
+  `firstName` equal to 'Johnny' and `lastName` equal to 'Cash'. To use the query with the store
+  simple pass it to `find` like so,
 
       records = MyApp.store.find(query);
 
-  `records` will be a record array containing all matching records.
-  To limit the query to a record type of `MyApp.MyModel`,
-  you can specify the type as a property of the query like this:
+  In this example, `records` will be an `SC.RecordArray` array containing all matching records. The
+  amazing feature of record arrays backed by *local* queries is that they update automatically
+  whenever the records in the store change. This means that once we've run the query once, any time
+  data is loaded or unloaded from the store, the results of the query (i.e. `records`) will
+  update automatically. This allows for truly powerful and dynamic uses, such as having a list of
+  filtered results that continually updates instantly as data pages in or out in the background.
+
+  To limit the query to a record type of `MyApp.MyModel`, you can specify the type as a property of
+  the query like this,
 
       query = SC.Query.create({
-        conditions: "firstName = 'Jonny' AND lastName = 'Cash'",
+        conditions: "firstName = 'Johnny' AND lastName = 'Cash'",
         recordType: MyApp.MyModel
       });
 
-  Calling `find()` like above will now return only records of type MyApp.MyModel.
-  It is recommended to limit your query to a record type, since the query will
-  have to look for matching records in the whole store if no record type
-  is given.
+  Calling `find()` like above will now return only records of type MyApp.MyModel. It is recommended
+  to limit your query to a record type, since the query will have to look for matching records in
+  the whole store if no record type is given.
 
-  You can give an order, which the resulting records should follow, like this:
+  You can also give an order for *local* queries, which the resulting records will use,
 
       query = SC.Query.create({
-        conditions: "firstName = 'Jonny' AND lastName = 'Cash'",
+        conditions: "firstName = 'Johnny' AND lastName = 'Cash'",
         recordType: MyApp.MyModel,
         orderBy: "lastName, year DESC"
       });
 
-  The default order direction is ascending. You can change it to descending
-  by writing `'DESC'` behind the property name like in the example above.
-  If no order is given, or records are equal in respect to a given order,
-  records will be ordered by their storeKey.
-
-  You can check if a certain record matches the query by calling
-
-      query.contains(record);
-
-  SproutCore Query Language
-  =====
+  The default order direction is ascending. You can change it to descending by writing `'DESC'`
+  behind the property name as was done in the example above. If no order is given, or records are
+  equal in respect to a given order, records will be ordered by their storeKeys which increment
+  depending on load order.
+
+  Note, you can check if a certain record matches the query by calling `query.contains(record)`.
+
+  ## Local vs. Remote Queries
+
+  The default type for queries is 'local', but there is another type we can use called 'remote'.
+  The distinction between local and remote queries is a common tripping point for new SproutCore
+  developers, but hopefully the following description helps keep it clear. The terms local and
+  remote refer to the *location of the data where the query is performed and by whom*. A local query
+  will be run by the client against the store of data within the client, while a remote query will
+  be run on by the server against some remote store of data. This seems simple enough, but it can
+  lead to a few misconceptions.
+
+  The first misconception is that local queries don't ever result in a call to a server. This is
+  not the case; when a local query is first used with the store it will generally result in a call
+  to the server, but whether or not it does depends on your store's data source. Keep this in mind,
+  local queries *only run against the data loaded in the client's store*. If the client store is
+  empty, the results of the query will be empty even though there may be thousands of matching
+  records on a server somewhere. That's why when a query is first used, the store will look for a
+  data source that implements the `fetch(store, query)` method. Your data source can then decide
+  whether additional data should be loaded into the store first in order to better fulfill the
+  query.
+
+  This is entirely up to your client/server implementation, but a common use case is to have a
+  general query trigger the load of a large set of data and then any more specific queries will only
+  run against what was already loaded. For more details, @see SC.DataSource.prototype.fetch. So to
+  recap, local queries are passed to the data source fetch method the first time they are used so
+  that the data source has a chance to load additional data that the query may need.
+
+  Once we get past the first misconception; local queries are actually pretty easy to understand and
+  to work with. We run the queries, get the resulting record array and watch as the results almost
+  magically update as the data in the client changes. Local queries are the default type, and
+  typically we will use local queries almost exclusively in SproutCore apps. So why do we have a
+  remote type?
+
+  In a previous paragraph, we considered how a local query would be empty if the local store was
+  empty even though there may be thousands of matching records on a server. Well what if there were
+  millions of records on the server? When dealing with extremely large datasets, it's not feasible
+  to load all of the records into the client so that the client can run a query against them. This
+  is the role of the 'remote' type. Remote queries are not actually "run" by the client at all,
+  which is the next misconception; you cannot run a remote query.
+
+  This misconception is another way of saying that you can't set conditions or order on a remote
+  query. The 'remote' SC.Query type is simply a reflection of some database query that was run
+  against a data store somewhere outside of the client. For example, say we want to still find all
+  the records on the server with `firstName` equal to 'Johnny' and `lastName` equal to 'Cash', but
+  now there are millions of records. This type of query is best left to a MySQL or other database on
+  a server and thus the server will have exposed an API endpoint that will return the results of
+  such a search when passed some search terms.
+
+  Again, this is entirely up to your client/server configuration, but the way it is handled by the
+  data source is nearly identical to how local queries will be handled. In both situations, the
+  data source is passed the query the first time it is run and when the data source is done it calls
+  the same method on the store, `dataSourceDidFetchQuery`. In both situations too, any data that the
+  data source receives should be loaded into the client store using `loadRecords`. However, because
+  there may be lots of other data in the client store, the 'remote' query must also be told which
+  records pertain to it and in what order, which is done by passing the store keys of the new data
+  also to `dataSourceDidFetchQuery`.
+
+  So to recap, use 'local' queries to filter the data currently in the client store and use 'remote'
+  queries to represent results filtered by a remote server. Both may be used by a data source to
+  load data from a server.
+
+  ## SproutCore Query Language
 
   Features of the query language:
 
@@ -86,7 +149,7 @@ sc_require('models/record');
 
   You cannot use both types of parameters in a single query!
 
-  Operators:
+  ### Operators:
 
    - `=`
    - `!=`
@@ -107,7 +170,7 @@ sc_require('models/record');
                       of a Model class on its right side, only records of this
                       type will match)
 
-  Boolean Operators:
+  ### Boolean Operators:
 
    - `AND`
    - `OR`
@@ -118,8 +181,7 @@ sc_require('models/record');
    - `(` and `)`
 
 
-  Adding Your Own Query Handlers
-  ---
+  ## Adding Your Own Query Handlers
 
   You can extend the query language with your own operators by calling:
 
@@ -135,7 +197,7 @@ sc_require('models/record');
   @extends SC.Freezable
   @since SproutCore 1.0
 */
-
+// TODO: Rename local vs. remote to avoid confusion.
 SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
   /** @scope SC.Query.prototype */ {
 
@@ -184,7 +246,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
 
     @type String | Function
   */
-  orderBy:     null,
+  orderBy: null,
 
   /**
     The base record type or types for the query.  This must be specified to
@@ -681,7 +743,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 SC.compare(left, right) == -1; //left < right;
+                          return SC.compare(left, right) === -1; //left < right;
                         }
     },
 
@@ -695,7 +757,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 SC.compare(left, right) != 1; //left <= right;
+                          return SC.compare(left, right) !== 1; //left <= right;
                         }
     },
 
@@ -709,7 +771,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 SC.compare(left, right) == 1; //left > right;
+                          return SC.compare(left, right) === 1; //left > right;
                         }
     },
 
@@ -723,7 +785,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 SC.compare(left, right) != -1; //left >= right;
+                          return SC.compare(left, right) !== -1; //left >= right;
                         }
     },
 
@@ -773,7 +835,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
                             if (allType !== SC.T_ARRAY) all = all.toArray();
                             var found  = false;
                             var i      = 0;
-                            while ( found===false && i<all.length ) {
+                            while ( found === false && i < all.length ) {
                               if ( value == all[i] ) found = true;
                               i++;
                             }
@@ -901,14 +963,12 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
         c                   = null,
         t                   = null,
         token               = null,
-        tokenType           = null,
         currentToken        = null,
         currentTokenType    = null,
         currentTokenValue   = null,
         currentDelimiter    = null,
         endOfString         = false,
         endOfToken          = false,
-        belongsToToken      = false,
         skipThisCharacter   = false,
         rememberCount       = {};
 
@@ -928,8 +988,8 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       // reserved words
       if ( !t.delimited ) {
         for ( var anotherToken in grammar ) {
-          if ( grammar[anotherToken].reservedWord
-               && anotherToken == tokenValue ) {
+          if (grammar[anotherToken].reservedWord &&
+              anotherToken == tokenValue ) {
             tokenType = anotherToken;
           }
         }
@@ -1085,8 +1145,8 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       var p = position;
       var tl = tokenLogic(p);
       if ( !tl )            return false;
-      if (side == 'left')   return tl.leftType;
-      if (side == 'right')  return tl.rightType;
+      if (side === 'left')   return tl.leftType;
+      if (side === 'right')  return tl.rightType;
     }
 
     function evalType (position) {
@@ -1110,8 +1170,8 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     function tokenIsMissingChilds (position) {
       var p = position;
       if ( p < 0 )  return true;
-      return (expectedType('left',p) && !l[p].leftSide)
-          || (expectedType('right',p) && !l[p].rightSide);
+      return (expectedType('left',p) && !l[p].leftSide) ||
+             (expectedType('right',p) && !l[p].rightSide);
     }
 
     function typesAreMatching (parent, child) {
@@ -1161,15 +1221,15 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
 
     // step through the tokenList
 
-    for (i=0; i < l.length; i++) {
+    for (i = 0; i < l.length; i++) {
       shouldCheckAgain = false;
 
-      if ( l[i].tokenType == 'UNKNOWN' ) {
+      if ( l[i].tokenType === 'UNKNOWN' ) {
         error.push('found unknown token: '+l[i].tokenValue);
       }
 
-      if ( l[i].tokenType == 'OPEN_PAREN' ) openParenthesisStack.push(i);
-      if ( l[i].tokenType == 'CLOSE_PAREN' ) removeParenthesesPair(i);
+      if ( l[i].tokenType === 'OPEN_PAREN' ) openParenthesisStack.push(i);
+      if ( l[i].tokenType === 'CLOSE_PAREN' ) removeParenthesesPair(i);
 
       if ( preceedingTokenCanBeMadeChild(i) ) makeChild(i);
 
@@ -1183,7 +1243,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     }
 
     // error if tokenList l is not a single token now
-    if (l.length == 1) l = l[0];
+    if (l.length === 1) l = l[0];
     else error.push('string did not resolve to a single tree');
 
     // If we have errors, return an error object.
@@ -1193,7 +1253,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
         tree: l,
         // Conform to SC.Error.
         isError: YES,
-        errorVal: function() { return this.error }
+        errorVal: function() { return this.error; }
       };
     }
     // Otherwise the token list is now a tree and can be returned.
@@ -1224,6 +1284,26 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
       return orderOp;
     }
     else {
+      // @if(debug)
+      // debug mode syntax checks.
+      // first check is position of ASC or DESC
+      var ASCpos = orderOp.indexOf("ASC");
+      var DESCpos = orderOp.indexOf("DESC");
+      if (ASCpos > -1 || DESCpos > -1) { // if they exist
+        if (ASCpos > -1 && (ASCpos + 3) !== orderOp.length) {
+          SC.warn("Developer Warning: You have an orderBy syntax error in a Query, %@: ASC should be in the last position.".fmt(orderOp));
+        }
+        if (DESCpos > -1 && (DESCpos + 4) !== orderOp.length) {
+          SC.warn("Developer Warning: You have an orderBy syntax error in a Query, %@: DESC should be in the last position.".fmt(orderOp));
+        }
+      }
+      
+      // check for improper separation chars
+      if (orderOp.indexOf(":") > -1 || orderOp.indexOf(":") > -1) {
+        SC.warn("Developer Warning: You have an orderBy syntax error in a Query, %@: Colons or semicolons should not be used as a separation character.".fmt(orderOp));
+      }
+      // @endif
+
       var o = orderOp.split(',');
       for (var i=0; i < o.length; i++) {
         var p = o[i];
@@ -1231,7 +1311,7 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
         p = p.replace(/\s+/,',');
         p = p.split(',');
         o[i] = {propertyName: p[0]};
-        if (p[1] && p[1] == 'DESC') o[i].descending = true;
+        if (p[1] && p[1] === 'DESC') o[i].descending = true;
       }
 
       return o;
@@ -1305,7 +1385,7 @@ SC.Query.mixin( /** @scope SC.Query */ {
   orderStoreKeys: function(storeKeys, query, store) {
     // apply the sort if there is one
     if (storeKeys) {
-      var res = storeKeys.sort(function(a, b) {
+      storeKeys.sort(function(a, b) {
         return SC.Query.compareStoreKeys(query, store, a, b);
       });
     }