sproutcore 1.5.0.rc.2 → 1.5.0

data/lib/frameworks/sproutcore/frameworks/datastore/models/child_record.js

@@ -0,0 +1,21 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('models/record');
+
+/**
+  @class
+  @deprecated
+*/
+SC.ChildRecord = SC.Record.extend({});
+
+SC.ChildRecord.extend = function() {
+  //@ if (debug)
+  console.log("SC.ChildRecord is deprecated. Please extend SC.Record instead.");
+  //@ endif
+  return SC.Record.extend.apply(this, arguments);
+};

data/lib/frameworks/sproutcore/frameworks/datastore/models/record.js

@@ -5,6 +5,8 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
+sc_require('system/query');
+
 /**
   @class
 

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

@@ -486,10 +486,10 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
   /** @private
     Properties that need to be copied when cloning the query.
   */
-  copyKeys: 'conditions orderBy recordType recordTypes parameters location scope'.w(),
+  copyKeys: ['conditions', 'orderBy', 'recordType', 'recordTypes', 'parameters', 'location', 'scope'],
   
   /** @private */
-  concatenatedProperties: 'copyKeys'.w(),
+  concatenatedProperties: ['copyKeys'],
 
   /** @private 
     Implement the Copyable API to clone a query object once it has been 
@@ -525,16 +525,32 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     
     'UNKNOWN': {
       firstCharacter:   /[^\s'"\w\d\(\)\{\}]/,
-      notAllowed:       /[\s'"\w\d\(\)\{\}]/
+      notAllowed:       /[\-\s'"\w\d\(\)\{\}]/
     },
 
     'PROPERTY': {
       firstCharacter:   /[a-zA-Z_]/,
-      notAllowed:       /[^a-zA-Z_0-9]/,
+      notAllowed:       /[^a-zA-Z_0-9\.]/,
       evalType:         'PRIMITIVE',
       
       /** @ignore */
-      evaluate:         function (r,w) { return r.get(this.tokenValue); }
+      evaluate:         function (r,w) {
+                          var tokens = this.tokenValue.split('.');
+
+                          var len = tokens.length;
+                          if (len < 2) return r.get(this.tokenValue);
+
+                          var ret = r;
+                          for (var i = 0; i < len; i++) {
+                            if (!ret) return;
+                            if (ret.get) {
+                              ret = ret.get(tokens[i]);
+                            } else {
+                              ret = ret[tokens[i]];
+                            }
+                          }
+                          return ret;
+                        }
     },
 
     'NUMBER': {

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

@@ -6,7 +6,7 @@
 /*globals module ok equals same test MyApp */
 
 // test parsing of query string
-var store, storeKey, rec1, rec2, rec3, rec4, rec5, MyApp, q;
+var store, storeKey, rec1, rec2, rec3, rec4, rec5, rec6, rec7, MyApp, q;
 module("SC.Query evaluation of records", {
   setup: function() {
     
@@ -17,25 +17,31 @@ module("SC.Query evaluation of records", {
       store: SC.Store.create()
     });
     
-    // setup a dummy model
-    MyApp.Foo = SC.Record.extend({});
-    
+    // setup dummy models
+    MyApp.Animal = SC.Record.extend({});
+    MyApp.Person = SC.Record.extend({
+      pet: SC.Record.toOne(MyApp.Animal, { nested: true })
+    });
+
     // load some data
-    MyApp.store.loadRecords(MyApp.Foo, [
+    MyApp.store.loadRecords(MyApp.Person, [
       { guid: 1, firstName: "John", lastName: "Doe", married: true },
       { guid: 2, firstName: "Jane", lastName: "Doe", married: false },
       { guid: 3, firstName: "Emily", lastName: "Parker", bornIn: 1975, married: true },
       { guid: 4, firstName: "Johnny", lastName: "Cash", married: true },
-      { guid: 5, firstName: "Bert", lastName: "Berthold", married: true }
+      { guid: 5, firstName: "Bert", lastName: "Berthold", married: true },
+      { guid: 6, firstName: "Ronald", lastName: "Fitzgerald", parents: { father: "Frank", mother: "Nancy" }},
+      { guid: 7, firstName: "Jack", lastName: "Dimpleton", pet: { guid: 1, name: "Fido" } }
     ]);
     
-    rec1 = MyApp.store.find(MyApp.Foo,1);
-    rec2 = MyApp.store.find(MyApp.Foo,2);
-    rec3 = MyApp.store.find(MyApp.Foo,3);
-    rec4 = MyApp.store.find(MyApp.Foo,4);
-    rec5 = MyApp.store.find(MyApp.Foo,5);
+    rec1 = MyApp.store.find(MyApp.Person,1);
+    rec2 = MyApp.store.find(MyApp.Person,2);
+    rec3 = MyApp.store.find(MyApp.Person,3);
+    rec4 = MyApp.store.find(MyApp.Person,4);
+    rec5 = MyApp.store.find(MyApp.Person,5);
+    rec6 = MyApp.store.find(MyApp.Person,6);
+    rec7 = MyApp.store.find(MyApp.Person,7);
     
-
     SC.RunLoop.end();
     
     q = SC.Query.create();
@@ -48,12 +54,31 @@ module("SC.Query evaluation of records", {
 // 
 
 test("should get record properties correctly", function() {
+
+  q.conditions = "fakeProp = 'Foo'";
+  q.parse();
+  equals(q.contains(rec1), false, 'John should not match: fakeProp = "Foo"');
   
   q.conditions = "firstName = 'John'";
   q.parse();
   equals(q.contains(rec1), true, 'John should match: firstName = "John"');
   equals(q.contains(rec2), false, 'Jane should not match: firstName = "John"');
-  
+
+  q.conditions = "parents.father = 'Frank'";
+  q.parse();
+  equals(q.contains(rec6), true, "Ronald should match: parents.father = 'Frank'");
+  equals(q.contains(rec1), false, "John should not match: parents.father = 'Frank'");
+
+  q.conditions = "pet.name = 'Fido'";
+  q.parse();
+  equals(q.contains(rec7), true, "Jack should match: pet.name = 'Fido'");
+  equals(q.contains(rec6), false, "Ronald should not match: pet.name = 'Fido'");
+
+  q.conditions = "pet.parentRecord.firstName = 'Jack'";
+  q.parse();
+  equals(q.contains(rec7), true, "Jack should match: pet.parentRecord.firstName = 'Jack'");
+  equals(q.contains(rec6), false, "Ronald should not match: pet.parentRecord.firstName = 'Jack'");
+
   q.conditions = "lastName BEGINS_WITH firstName";
   q.parse();
   equals(q.contains(rec5), true, 'Bert Berthold should match: lastName BEGINS_WITH firstName');

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

@@ -195,12 +195,20 @@ test("should recognize all primitives", function() {
   equals(q._tokenList[2].tokenValue, 'NOT', 'value should be NOT');
   
 }); 
-  
-  
-  // ..........................................................
-  // TREE-BUILDING 
-  // 
 
+// ..........................................................
+// COMPOUND
+//
+
+test("negative numbers with equals", function(){
+  q.conditions = "-1=-1";
+  q.parse();
+  equals(q._tokenList.length, 3, "should have 3 tokens");
+});
+
+// ..........................................................
+// TREE-BUILDING
+//
 
 test("token tree should build", function() {  
   // Just some examples

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/store/loadRecords.js

@@ -0,0 +1,100 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+(function() {
+  var store, people, places, Person, Place;
+
+  module("SC.Store#loadRecords", {
+    setup: function() {
+      Person = SC.Record.extend({
+        first: SC.Record.attr(String, { isRequired: YES}),
+        last: SC.Record.attr(String),
+        age: SC.Record.attr(Number),
+        isAlive: SC.Record.attr(Boolean)
+      });
+
+      Place = SC.Record.extend({
+        name: SC.Record.attr(String)
+      });
+
+      SC.RunLoop.begin();
+
+      store = SC.Store.create();
+
+      people = [ 
+        Person.create({ 
+          guid: 1,
+          first: "John",
+          last: "Sproutish",
+          age: 35,
+          isAlive: YES
+        }),
+        Person.create({
+          guid: 2,
+          first: "Sarah",
+          last: "Coop",
+          age: 28,
+          isAlive: YES
+        })
+      ];
+
+      places = [
+        Place.create({
+          guid: 3,
+          name: "San Francisco"
+        }),
+        Place.create({
+          guid: 4,
+          name: "St. John's"
+        })
+      ];
+
+      SC.RunLoop.end();
+    },
+    teardown: function() {
+      store = people = places = Person = Place = null;
+    }
+  });
+
+  test("loadRecords with single Record type loads new records in store", function() {
+    var storeKeys = store.loadRecords(Person, people),
+        isStatusCorrect;
+
+    ok(SC.isArray(storeKeys), "An array of store keys is returned");
+
+    storeKeys.forEach(function(storeKey, index) {
+      equals(store.idFor(storeKeys[index]), people[index].get('guid'), "The storeKey resolves to the correct Primary Key for index %@".fmt(index));
+
+      ok(store.peekStatus(storeKey) & SC.Record.READY_CLEAN, "Record is in SC.Record.READY_CLEAN state after loading into store for index %@".fmt(index));
+    });
+  });
+
+  test("loadRecords with multiple Record types loads new records in store", function() {
+    var things = [],
+        types = [Person, Person, Place, Place],
+        storeKeys, record;
+
+    things.pushObjects(people);
+    things.pushObjects(places);
+
+    things.forEach(function(thing, index) {
+      ok(SC.kindOf(thing, types[index]), "precond - types array contains correct record type for index %@".fmt(index));
+    });
+
+    storeKeys = store.loadRecords(types, things);
+
+    ok(SC.isArray(storeKeys), "An array of store keys is returned");
+
+    storeKeys.forEach(function(storeKey, index) {
+      record = store.materializeRecord(storeKey);
+      
+      equals(store.idFor(storeKeys[index]), things[index].get('guid'), "The storeKey resolves to the correct Primary Key for index %@".fmt(index));
+      ok(SC.kindOf(record, types[index]), "store returns a record of the correct type for index %@".fmt(index));
+      ok(store.peekStatus(storeKey) & SC.Record.READY_CLEAN, "Record is in SC.Record.READY_CLEAN state after loading into store for index %@".fmt(index));
+    });
+  });
+})();

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/store/unloadRecord.js

@@ -0,0 +1,55 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+(function() {
+  var store, Person, Place;
+
+  module("SC.Store#unloadRecord", {
+    setup: function() {
+      Person = SC.Record.extend({
+        name: SC.Record.attr(String)
+      });
+
+      Place = SC.Record.extend({
+        name: SC.Record.attr(String)
+      });
+
+      SC.RunLoop.begin();
+
+      store = SC.Store.create();
+
+      store.loadRecords(Person, [
+        {guid: 1, name: 'Soups'},
+        {guid: 2, name: 'Palmdale'},
+        {guid: 3, name: 'Dubs'}
+      ]);
+
+      store.loadRecords(Place, [
+        {guid: 4, name: "San Francisco"},
+        {guid: 5, name: "St. John's"}
+      ]);
+
+      SC.RunLoop.end();
+    },
+    teardown: function() {
+      store = Person = Place = null;
+    }
+  });
+
+  test("Unload one record via storeKey", function() {
+    var people = store.find(Person),
+        record = store.find(Person, 1);
+
+    equals(people.get('length'), 3, "precond - there are 3 People records in the store");
+
+    store.unloadRecord(Person, 1);
+
+    people = store.find(Person);
+    equals(people.get('length'), 2, "there are 2 People records in the store after calling unloadRecord");
+    ok(store.peekStatus(record) & SC.Record.EMPTY, "Record now has status of SC.Record.EMPTY");
+  });
+
+})();

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/store/unloadRecords.js

@@ -4,38 +4,87 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-var store, TestRecord;
+(function() {
+  var store, Person, Place;
 
-module("SC.Store#unloadRecords", {
-  setup: function() {
-    TestRecord = SC.Record.extend({
-      name: SC.Record.attr(String)
-    });
+  module("SC.Store#unloadRecords", {
+    setup: function() {
+      Person = SC.Record.extend({
+        name: SC.Record.attr(String)
+      });
 
-    SC.RunLoop.begin();
+      Place = SC.Record.extend({
+        name: SC.Record.attr(String)
+      });
 
-    store = SC.Store.create();
+      SC.RunLoop.begin();
 
-    store.createRecord(TestRecord, {
-      name: 'Foo'
-    });
+      store = SC.Store.create();
 
-    store.createRecord(TestRecord, {
-      name: 'Bar'
-    });
+      store.loadRecords(Person, [
+        {guid: 1, name: 'Soups'},
+        {guid: 2, name: 'Palmdale'},
+        {guid: 3, name: 'Dubs'}
+      ]);
 
-    store.createRecord(TestRecord, {
-      name: 'Baz'
-    });
+      store.loadRecords(Place, [
+        {guid: 4, name: "San Francisco"},
+        {guid: 5, name: "St. John's"}
+      ]);
 
-    SC.RunLoop.end();
-  }
-});
+      SC.RunLoop.end();
+    },
+    teardown: function() {
+      store = Person = Place = null;
+    }
+  });
 
-test("Unload all records of a record type", function() {
-  var records = store.find(TestRecord);
-  equals(records.get('length'), 3, "Store starts with 3 records loaded");
-  store.unloadRecords(TestRecord);
-  records = store.find(TestRecord);
-  equals(records.get('length'), 0, "Number of TestRecord records left");
-});
+  test("Unload all records of a record type", function() {
+    var records = store.find(Person);
+    equals(records.get('length'), 3, "precond - store has 3 records loaded");
+    store.unloadRecords(Person);
+    records = store.find(Person);
+    equals(records.get('length'), 0, "Number of People records left");
+  });
+
+  test("Unload only certain records of a record type", function() {
+    var records = store.find(Person);
+    equals(records.get('length'), 3, "precond - store has 3 records loaded");
+    store.unloadRecords(Person, [1, 2]);
+    records = store.find(Person);
+    equals(records.get('length'), 1, "Number of People records left");
+  });
+
+  test("Unload all records of passed record types", function() {
+    var people = store.find(Person),
+        places = store.find(Place);
+
+    equals(people.get('length'), 3, "precond - store has 3 Person records loaded");
+    equals(places.get('length'), 2, "precond - store has 2 Place records loaded");
+
+    store.unloadRecords([Person, Place]);
+
+    people = store.find(Person);
+    places = store.find(Place);
+
+    equals(people.get('length'), 0, "Number of People records left");
+    equals(places.get('length'), 0, "Number of Place records left");
+  });
+
+  test("Unload certain records of passed record types", function() {
+    var people = store.find(Person),
+        places = store.find(Place);
+
+    equals(people.get('length'), 3, "precond - store has 3 Person records loaded");
+    equals(places.get('length'), 2, "precond - store has 2 Place records loaded");
+
+    store.unloadRecords([Person, Person, Place], [1, 2, 4]);
+
+    people = store.find(Person);
+    places = store.find(Place);
+
+    equals(people.get('length'), 1, "Number of People records left");
+    equals(places.get('length'), 1, "Number of Place records left");
+  });
+
+})();