sproutcore 0.9.14 → 0.9.15

data/frameworks/sproutcore/server/rest_server.js

@@ -0,0 +1,178 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2008 Sprout Systems, Inc.
+// ========================================================================
+
+require('core') ;
+require('server') ;
+
+/** 
+  @class
+  
+  Usually you wouldn't need to call any of the methods on this class or it's 
+  superclass, except for calling the +listFor+ method. The other methods are 
+  called for you when you work with your model objects. For example, calling 
+  myObject.commit(); will call the commitRecords method on this server if you 
+  had defined this server to be to the +dataSource+ of myObject.
+
+  To have an SC model reflect data on a backend server attach an instance of 
+  this class to your application. For example:
+
+  {{{
+    Contacts = SC.Object.create({
+      server: SC.RestServer.create({ prefix: ['Contacts'] })
+    }) ;
+  }}}
+
+  Then attach that server as the +dataSource+ to each model class that you 
+  want to have reflected. Also define a +resourceURL+ which defines the URL 
+  where the collection of your model can be queried. For example:
+
+  {{{
+    Contacts.Contact = SC.Record.extend(
+      dataSource: Contacts.server,
+      resourceURL: 'sc/contacts',
+      properties: ['guid','firstName','lastName'],
+      primaryKey: 'guid'
+    }) ;
+  }}}
+
+  When you work with your models, behind the scenes SC will use 5 main methods 
+  on this server. Each is listed below, together with the HTTP method used in 
+  the call to the backend server and the URL that is being called. The URL is 
+  based on the example given above.
+
+      listFor             GET    /sc/contacts
+
+      createRecords       POST   /sc/contacts
+
+      refreshRecords
+      for one record      GET    /sc/contacts/12345
+
+      refreshRecords
+      for many records    GET    /sc/contacts?ids=1,2,3,4,5,6
+
+      commitRecords
+      for one record      PUT    /sc/contacts/12345
+
+      commitRecords
+      for many records    PUT    /sc/contacts?ids=1,2,3,4,5
+
+      destroyRecords
+      for one record      DELETE /sc/contacts/12345
+
+      destroyRecords
+      for many records    DELETE /sc/contacts?ids=1,2,3,4,5
+
+  The above is the default behaviour of this server. If you want different 
+  URLs to be generated then extend this class and override the +urlFor+ 
+  method.
+
+  Another way to override the above is to tell SC where member resources can
+  be refreshed, committed and destroyed. For example, when SC calls
+  
+  {{{
+    GET /sc/contacts
+  }}}
+  
+  you could reply as follows:
+
+  {{{
+    records: [
+      {  guid: '123',
+        type: "Contact",
+        refreshURL: "/contacts?refresh=123",
+        updateURL: "/contacts/123?update=Y",
+        destroyURL: "/contacts/123",
+        firstName: "Charles",
+        ...
+      }],
+      ...
+    }
+  }}}
+
+  Then when contact 123 needs to be refreshed later on by SC, it will call:
+
+  {{{
+    GET /contacts?refresh=123
+  }}}
+
+  instead of GET /contacts/123. Note that this only works for members on your
+  resource. If a collection of contacts needed to be refreshed it would still
+  call for example GET /contacts?id=123,456,789 instead of making 3 separate
+  calls.
+
+  Because some browsers cannot actually perform an HTTP PUT or HTTP DELETE it
+  will actually perform an HTTP POST but will put an additional key,value pair
+  in the post data packet. For HTTP PUT it will add _method='put' and for
+  HTTP DELETE it will add _method='delete' in the post data.
+
+  Via the SC.Server#request method you can also call collection and member
+  functions on your resource. Use the +action+ parameter for this. For
+  example, server.request('contacts', 'archive', null, params, 'delete')
+  would call:
+
+  {{{
+    DELETE /contacts/archive
+  }}}
+
+  And server.request('contacts', 'give', [12345], {'amount': 1000}, 'put')
+  would call:
+
+  {{{
+   PUT /contacts/12345/give
+  }}}
+  
+  with post data amount=1000.
+
+  Alternatively explicitely define the URL to use by setting the +url+
+  property in the +params+ argument that is passed to the server.request 
+  method. For example:
+
+  {{{
+    Contacts.server.request(null,null,null, {url: '/sc/archive'}, 'delete')
+  }}}
+
+  would call:
+
+  {{{
+    DELETE /sc/archive
+  }}}
+
+
+  @extends SC.Server
+  @author Lawrence Pit
+  @copyright 2006-2008, Sprout Systems, Inc. and contributors.
+  @since SproutCore 1.0
+*/
+SC.RestServer = SC.Server.extend({
+
+  /**
+    @see SC.Server.urlFor
+  **/
+  urlFor: function(resource, action, ids, params, method) {
+    url = resource;
+    if (ids && ids.length == 1) url = url + '/' + ids[0];
+    if (action && action != '') url = url + '/' + action;
+    return url;
+  },
+
+
+  /* privates, overrides the values in SC.Server */
+
+  _listForAction: '',
+  _listForMethod: 'get',
+
+  _createAction: '',
+  _createMethod: 'post',
+
+  _refreshAction: '',
+  _refreshMethod: 'get',
+
+  _commitAction: '',
+  _commitMethod: 'put',
+
+  _destroyAction: '',
+  _destroyMethod: 'delete'
+
+}) ;

data/frameworks/sproutcore/{foundation → server}/server.js

@@ -62,8 +62,9 @@ SC.Server = SC.Object.extend({
   // onFailure -- function invoked when request fails. Same format.
   // requestContext -- simply passed back.
   // cacheCode -- String indicating the time of the last refresh.
+  // url -- override the default url building with this url.
   //
-  request: function(resource, verb, ids, params, method) {
+  request: function(resource, action, ids, params, method) {
 
     // Get Settings and Options
     if (!params) params = {} ;
@@ -72,24 +73,29 @@ SC.Server = SC.Object.extend({
     var onNotModified = params.onNotModified; delete params.onNotModified ;
     var onFailure = params.onFailure ; delete params.onFailure ;
     var context = params.requestContext ; delete params.requestContext ;
+    var accept = params.accept ; delete params.accept ;
     var cacheCode = params.cacheCode; delete params.cacheCode ;
+    var url = params.url; delete params.url;
+
+    opts.requestHeaders = {'Accept': 'application/json, text/javascript, application/xml, text/xml, text/html, */*'}
+    if (accept) opts.requestHeaders['Accept'] = accept ;
+    if (cacheCode) opts.requestHeaders['Sproutit-Cache'] = cacheCode ;
+    opts.method = method || 'get' ;
+
+    if (!url) url = this.urlFor(resource, action, ids, params, opts.method) ;
 
     // handle ids
-    var idPart = '' ;
-    if (ids) if (ids.length > 1) {
+    if (ids && ids.length > 1) {
       params.ids = [ids].flatten().join(',') ;
-    } else if (ids.length == 1) {
-      idPart = '/' + ids[0] ;
-    }
+    }    
     
+    // adds a custom HTTP header for remote requests
+    opts.requestHeaders = {'X-SproutCore-Version' : '1.0'}
+
     // convert parameters.
     var parameters = this._toQueryString(params) ;
     if (parameters && parameters.length > 0) opts.parameters = parameters ;
     
-    // prepare request headers and options
-    if (cacheCode) opts.requestHeaders = ['Sproutit-Cache',cacheCode] ;
-    opts.method = method || 'get' ;
-    var url = this.urlFormat.format(resource,verb) + idPart;
     var request = null ; //will container the ajax request
     
     // Save callback functions.
@@ -107,10 +113,27 @@ SC.Server = SC.Object.extend({
       if (onFailure) onFailure(transport.status, transport, cacheCode,context);
     } ; 
     
-    console.log('REQUEST: %@'.fmt(url)) ;
+    console.log('REQUEST: %@ %@'.fmt(opts.method, url)) ;
+    
     request = new Ajax.Request(url,opts) ;
   },
 
+  /**
+    Generates the URL that is going to be called by this server. Note that you
+    should only return relative URLs. You can only call resources that are on
+    the same domain as where this script was downloaded from.
+
+    @param {String} resource  the URL where the collection of the resource can be queried
+    @param {String} action    the action that should be performed on the resource
+    @param {Array} ids        array of identifiers of your model instances
+    @param {Array} params     parameters that were passed to the SC.Server#request method
+    @param {String} method    the HTTP method that will be used
+    @returns {String} the URL to use in the request to the backend server
+  **/
+  urlFor: function(resource, action, ids, params, method) {
+    var idPart = (ids && ids.length == 1) ? ids[0] : '';
+    return this.urlFormat.format(resource, action) + idPart;
+  },
 
   // RECORD METHODS
   // These methods do the basic record changes.
@@ -123,6 +146,7 @@ SC.Server = SC.Object.extend({
   listFor: function(opts) {
     var recordType = opts.recordType ;
     var resource = recordType.resourceURL() ;
+
     if (!resource) return false ;
     
     var order = opts.order || 'id' ;
@@ -147,10 +171,12 @@ SC.Server = SC.Object.extend({
     if (opts.offset) params.offset = opts.offset;
     if (opts.limit) params.limit = opts.limit ;
     if (order) params.order = order ;
-    
-    this.request(resource,'list',null,params) ;
+    this.request(resource, this._listForAction, null, params, this._listMethod) ;
   },
   
+  _listForAction: 'list',
+  _listMethod: 'get',
+  
   _listSuccess: function(status, transport, cacheCode, context) {
     var json = eval('json='+transport.responseText) ;
     if (!json) { console.log('invalid json!'); return; }
@@ -202,14 +228,17 @@ SC.Server = SC.Object.extend({
       }) ;
 
       // issue request
-      this.request(resource,'create',null,{
+      this.request(resource, this._createAction, null, {
         requestContext: context, 
         onSuccess: this._createSuccess.bind(this),
         onFailure: this._createFailure.bind(this),
         records: data
-      },'post') ;
+      }, this._createMethod) ;
     }
   },
+  
+  _createAction: 'create',
+  _createMethod: 'post',
 
   // This method is called when a create is successful.  It first goes through
   // and assigns the primaryKey to each record.
@@ -261,16 +290,23 @@ SC.Server = SC.Object.extend({
       });
       context._recordType = curRecords[0].recordType ; // default rec type.
       
-      // issue request
-      this.request(resource,'show',ids,{
+      params = {
         requestContext: context, 
         cacheCode: ((cacheCode=='') ? null : cacheCode),
         onSuccess: this._refreshSuccess.bind(this),
         onFailure: this._refreshFailure.bind(this)
-      }) ;
+      };
+      
+      if (ids.length == 1 && curRecords[0].refreshURL) params['url'] = curRecords[0].refreshURL;
+      
+      // issue request
+      this.request(resource, this._refreshAction, ids, params, this._refreshMethod) ;
     }
   },
   
+  _refreshAction: 'show',
+  _refreshMethod: 'get',
+  
   // This method is called when a refresh is successful.  It expects an array
   // of hashes, which it will convert to records.
   _refreshSuccess: function(status, transport, cacheCode, context) {
@@ -299,50 +335,58 @@ SC.Server = SC.Object.extend({
       var server = this ;
 
       // start format differences
+      var data = null;
       switch(this.get('postFormat')){
         case SC.URL_ENCODED_FORMAT:     				
-          var data = curRecords.map(function(rec) {
+          data = curRecords.map(function(rec) {
             return server._decamelizeData(rec.getPropertyData()) ;
           }) ;
-
-          // issue request
-          this.request(resource,'update',null,{
-            requestContext: records, 
-            onSuccess: this._commitSuccess.bind(this),
-            onFailure: this._commitFailure.bind(this),
-            records: data
-            },'post') ;
-            break;
-
+          break;
         case SC.JSON_FORMAT:
           // get all records and put them into an array
           var objects = [];
           for(rec in curRecords){
             if (!curRecords.hasOwnProperty(rec)) continue ;
-            objects.push(curRecords[rec].get('attributes'));
+            objects.push(curRecords[rec].get('attributes') || {});
           }
           
           // convert to JSON and escape if this.escapeJSON is true
           if(this.get('escapeJSON')){
-            var data = escape(objects.toJSONString());
+            data = escape(objects.toJSONString());
           } else {
-            var data = objects.toJSONString();
+            data = objects.toJSONString();
           }
-          
-          // issue request			
-          this.request(resource,'update',null,{
-            requestContext: records, 
-            onSuccess: this._commitSuccess.bind(this),
-            onFailure: this._commitFailure.bind(this),
-            records: data
-            },'post') ;
-            break;
+          break;
         default: 
           break;
       }
-	    // end format differences
+      // end format differences
+
+      if (data) {
+        var ids = [];
+        if (curRecords.length == 1) {
+          var primaryKey = curRecords[0].get('primaryKey') ;
+          var key = curRecords[0].get(primaryKey);
+          if (key) ids.push(key);
+        }
+
+        params = {
+          requestContext: records,
+          onSuccess: this._commitSuccess.bind(this),
+          onFailure: this._commitFailure.bind(this),
+          records: data
+        };
+
+        if (ids.length == 1 && curRecords[0].updateURL) params['url'] = curRecords[0].updateURL;
+
+        // issue request
+        this.request(resource, this._commitAction, ids, params, this._commitMethod) ;
+      }
     }
   },
+  
+  _commitAction: 'update',
+  _commitMethod: 'post',
     
   // This method is called when a refresh is successful.  It expects an array
   // of hashes, which it will convert to records.
@@ -388,13 +432,22 @@ SC.Server = SC.Object.extend({
 
       // issue request -- we may not have ids to send tho (for ex, if all
       // records were newRecords.)
-      if (ids && ids.length > 0) this.request(resource,'destroy',ids,{
-        requestContext: records,
-        onSuccess: this._destroySuccess.bind(this),
-        onFailure: this._destroyFailure.bind(this)
-      },'post') ;
+      if (ids && ids.length > 0) {
+        params = {
+          requestContext: records,
+          onSuccess: this._destroySuccess.bind(this),
+          onFailure: this._destroyFailure.bind(this)
+        };
+
+        if (ids.length == 1 && curRecords[0].destroyURL) params['url'] = curRecords[0].destroyURL;
+
+        this.request(resource, this._destroyAction, ids, params, this._destroyMethod) ;
+      }
     }
   },
+  
+  _destroyAction: 'destroy',
+  _destroyMethod: 'post',
 
   _destroySuccess: function(status, transport, cacheCode, records) {
     console.log('destroySuccess!') ;
@@ -420,7 +473,7 @@ SC.Server = SC.Object.extend({
 
       // convert the 'id' property to 'guid'
       if (data.id) { data.guid = data.id; delete data.id; }
-
+      
       // find the recordType
       if (data.type) {
         var recordName = data.type.capitalize() ;

data/frameworks/sproutcore/tests/core/guidFor.rhtml

@@ -0,0 +1,114 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("Object", {
+  
+  setup: function() {
+    
+    objectA = {} ;
+    objectB = {} ;
+  },
+
+  "should return same guid for same instance every time": function() {
+    assertEqual(SC.guidFor(objectA), SC.guidFor(objectA)) ;
+  },
+  
+  "should return different guid for different instances": function() {
+    assertNotEqual(SC.guidFor(objectA), SC.guidFor(objectB)) ;
+  },
+  
+  "guid should not parse to a number": function() {
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(objectA), 0)));
+  }
+  
+});
+
+Test.context("String", {
+  
+  setup: function() {
+    stringA = "string A" ;
+    stringACopy = "string A" ;
+    
+    stringB = "string B" ;
+  },
+
+  "same string instance should have same guide every time": function() {
+    assertEqual(SC.guidFor(stringA), SC.guidFor(stringA)) ;  
+  },
+  
+  "two string instances with same value should have same guid": function() {
+    assertEqual(SC.guidFor(stringA), SC.guidFor(stringACopy)) ;  
+  },
+  
+  "two instances with different value should have different guid": function(){
+    assertNotEqual(SC.guidFor(stringA), SC.guidFor(stringB)) ;
+  },
+
+  "guid should not parse to a number": function() {
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(stringA), 0)));
+  }
+  
+});
+
+Test.context("Number", {
+  
+  setup: function() {
+    numberA = 23 ;
+    numberACopy = 23 ;
+    
+    numberB = 34 ;
+  },
+
+  "same number instance should have same guide every time": function() {
+    assertEqual(SC.guidFor(numberA), SC.guidFor(numberA)) ;  
+  },
+  
+  "two number instances with same value should have same guid": function() {
+    assertEqual(SC.guidFor(numberA), SC.guidFor(numberACopy)) ;  
+  },
+  
+  "two instances with different value should have different guid": function(){
+    assertNotEqual(SC.guidFor(numberA), SC.guidFor(numberB)) ;
+  },
+
+  "guid should not parse to a number": function() {
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(numberA), 0)));
+  }  
+});
+
+Test.context("Boolean", {
+  
+  "should always have same guid": function() {
+    assertEqual(SC.guidFor(true), SC.guidFor(true)) ;
+    assertEqual(SC.guidFor(false), SC.guidFor(false)) ;
+  },
+
+  "true should have different guid than false": function() {
+    assertNotEqual(SC.guidFor(true), SC.guidFor(false)) ;
+  },
+
+  "guid should not parse to a number": function() {
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(true), 0)));
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(false), 0)));
+  }  
+});
+
+Test.context("Null and Undefined", {
+  
+  "should always have same guid": function() {
+    assertEqual(SC.guidFor(null), SC.guidFor(null)) ;
+    assertEqual(SC.guidFor(undefined), SC.guidFor(undefined)) ;
+  },
+
+  "null should have different guid than undefined": function() {
+    assertNotEqual(SC.guidFor(null), SC.guidFor(undefined)) ;
+  },
+
+  "guid should not parse to a number": function() {
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(null), 0)));
+    assertEqual(YES, isNaN(parseInt(SC.guidFor(undefined), 0)));
+  }  
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/tests/foundation/array.rhtml

@@ -27,7 +27,7 @@ ArrayTests = function(factoryFunc) {
       } ;
       
       this.observe = function() {
-        var keys = $A(arguments) ;
+        var keys = SC.$A(arguments) ;
         var loc = keys.length ;
         while(--loc >= 0) {
           this.a.addObserver(keys[loc], this.observer) ;
@@ -157,15 +157,14 @@ ArrayTests = function(factoryFunc) {
       
       var cnt = 0 ;
       var items = [] ;
-      this.a.each(function( item, idx ) {
+      this.a.forEach(function( item, idx ) {
         items.push(item) ;
         cnt++ ;
       }) ;
-      
-      items[0].shouldEqual('A') ;
-      items[1].shouldEqual('B') ;
-      items[2].shouldEqual('C') ;
       cnt.shouldEqual(this.a.get('length')) ;
+      assertEqual('A', items[0]) ;
+      assertEqual('B', items[1]) ;
+      assertEqual('C',items[2]) ;
     },
     
     "ary.isEqual() should return true when array contents match": function() {
@@ -202,7 +201,7 @@ DummyArray = SC.Object.extend(SC.Array, {
     this.content.replace(idx,amt,objects) ;
     
     this.set('length', this.content.length) ;
-    this.arrayContentDidChange() ;
+    this.enumerableContentDidChange() ;
     this.endPropertyChanges() ;
   },