sproutcore 1.9.2 → 1.10.0.rc.1

data/lib/frameworks/sproutcore/frameworks/core_tools/models/test.js

@@ -4,7 +4,7 @@
 // ==========================================================================
 /*globals CoreTools */
 
-/** @class
+/**
 
   (Document your Model here)
 
@@ -15,12 +15,12 @@ CoreTools.Test = SC.Record.extend(
 /** @scope CoreTools.Test.prototype */ {
 
   primaryKey: "url",
-  
+
   /**
     The filename for this test.
   */
   filename: SC.Record.attr(String),
-  
+
   /**
     The test URL.
   */
@@ -44,5 +44,5 @@ CoreTools.Test = SC.Record.extend(
     computed based on whether the test is a summary of other tests or not.
   */
   isRunnable: YES
-  
-}) ;
+
+});

data/lib/frameworks/sproutcore/frameworks/core_tools/resources/icons.css

@@ -0,0 +1,5 @@
+.sc-icon-sproutcore-16 {
+  width: 16px;
+  height: 16px;
+  @include slice("sc-icon-sproutcore-16.png");
+}

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

@@ -9,35 +9,35 @@ sc_require('data_sources/data_source');
 
 /** @class
 
-  A cascading data source will actually forward requests onto an array of 
+  A cascading data source will actually forward requests onto an array of
   additional data sources, stopping when one of the data sources returns YES,
-  indicating that it handled the request.  
-  
+  indicating that it handled the request.
+
   You can use a cascading data source to tie together multiple data sources,
   treating them as a single namespace.
-  
+
   ## Configuring a Cascade Data Source
-  
+
   You will usually define your cascading data source in your main method after
   all the classes you have are loaded.
-  
+
       MyApp.dataSource = SC.CascadeDataSource.create({
         dataSources: "prefs youtube photos".w(),
-        
+
         prefs:   MyApp.PrefsDataSource.create({ root: "/prefs" }),
         youtube: YouTube.YouTubeDataSource.create({ apiKey: "123456" }),
         photos:  MyApp.PhotosDataSource.create({ root: "photos" })
-        
+
       });
-      
+
       MyApp.store.set('dataSource', MyApp.dataSource);
-  
+
   Note that the order you define your dataSources property will determine the
   order in which requests will cascade from the store.
-  
+
   Alternatively, you can use a more jQuery-like API for defining your data
   sources:
-  
+
       MyApp.dataSource = SC.CascadeDataSource.create()
         .from(MyApp.PrefsDataSource.create({ root: "/prefs" }))
         .from(YouTube.YouTubeDataSource.create({ apiKey: "123456" }))
@@ -47,19 +47,19 @@ sc_require('data_sources/data_source');
 
   In this case, the order you call from() will determine the order the request
   will cascade.
-  
+
   @extends SC.DataSource
   @since SproutCore 1.0
 */
-SC.CascadeDataSource = SC.DataSource.extend( 
+SC.CascadeDataSource = SC.DataSource.extend(
   /** @scope SC.CascadeDataSource.prototype */ {
 
   /**
-    The data sources used by the cascade, in the order that they are to be 
+    The data sources used by the cascade, in the order that they are to be
     followed.  Usually when you define the cascade, you will define this
     array.
-    
-    @property {Array}
+
+    @type Array
   */
   dataSources: null,
 
@@ -76,85 +76,85 @@ SC.CascadeDataSource = SC.DataSource.extend(
     dataSources.push(dataSource);
     return this ;
   },
-    
+
   // ..........................................................
   // SC.STORE ENTRY POINTS
-  // 
-  
+  //
+
   /** @private - just cascades */
   fetch: function(store, query) {
-    var sources = this.get('dataSources'), 
+    var sources = this.get('dataSources'),
         len     = sources ? sources.length : 0,
         ret     = NO,
         cur, source, idx;
-    
+
     for(idx=0; (ret !== YES) && idx<len; idx++) {
       source = sources.objectAt(idx);
       cur = source.fetch ? source.fetch.apply(source, arguments) : NO;
       ret = this._handleResponse(ret, cur);
     }
-    
+
     return ret ;
   },
-  
-  
+
+
   /** @private - just cascades */
   retrieveRecords: function(store, storeKeys, ids) {
-    var sources = this.get('dataSources'), 
+    var sources = this.get('dataSources'),
         len     = sources ? sources.length : 0,
         ret     = NO,
         cur, source, idx;
-    
+
     for(idx=0; (ret !== YES) && idx<len; idx++) {
       source = sources.objectAt(idx);
       cur = source.retrieveRecords.apply(source, arguments);
       ret = this._handleResponse(ret, cur);
     }
-    
+
     return ret ;
   },
 
   /** @private - just cascades */
   commitRecords: function(store, createStoreKeys, updateStoreKeys, destroyStoreKeys, params) {
-    var sources = this.get('dataSources'), 
+    var sources = this.get('dataSources'),
         len     = sources ? sources.length : 0,
         ret     = NO,
         cur, source, idx;
-    
+
     for(idx=0; (ret !== YES) && idx<len; idx++) {
       source = sources.objectAt(idx);
       cur = source.commitRecords.apply(source, arguments);
       ret = this._handleResponse(ret, cur);
     }
-    
+
     return ret ;
   },
 
   /** @private - just cascades */
   cancel: function(store, storeKeys) {
-    var sources = this.get('dataSources'), 
+    var sources = this.get('dataSources'),
         len     = sources ? sources.length : 0,
         ret     = NO,
         cur, source, idx;
-    
+
     for(idx=0; (ret !== YES) && idx<len; idx++) {
       source = sources.objectAt(idx);
       cur = source.cancel.apply(source, arguments);
       ret = this._handleResponse(ret, cur);
     }
-    
+
     return ret ;
   },
-  
+
   // ..........................................................
   // INTERNAL SUPPORT
-  // 
-  
+  //
+
   /** @private */
   init: function() {
     sc_super();
-    
-    // if a dataSources array is defined, look for any strings and lookup 
+
+    // if a dataSources array is defined, look for any strings and lookup
     // the same on the data source.  Replace.
     var sources = this.get('dataSources'),
         idx     = sources ? sources.get('length') : 0,
@@ -163,7 +163,7 @@ SC.CascadeDataSource = SC.DataSource.extend(
       source = sources[idx];
       if (SC.typeOf(source) === SC.T_STRING) sources[idx] = this.get(source);
     }
-    
+
   },
 
   /** @private - Determine the proper return value. */
@@ -172,5 +172,5 @@ SC.CascadeDataSource = SC.DataSource.extend(
     else if (current === NO) return (response === NO) ? NO : SC.MIXED_STATE ;
     else return SC.MIXED_STATE ;
   }
-    
+
 });

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

@@ -8,7 +8,7 @@
 /**
   Indicates a value has a mixed state of both on and off.
 
-  @property {String}
+  @type String
 */
 SC.MIXED_STATE = '__MIXED__';
 

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

@@ -11,7 +11,7 @@ sc_require('models/record');
 /** @class
 
   TODO: Describe Class
-  
+
   @extends SC.DataSource
   @since SproutCore 1.0
 */
@@ -20,51 +20,51 @@ SC.FixturesDataSource = SC.DataSource.extend(
 
   /**
     If YES then the data source will asynchronously respond to data requests
-    from the server.  If you plan to replace the fixture data source with a 
+    from the server.  If you plan to replace the fixture data source with a
     data source that talks to a real remote server (using Ajax for example),
     you should leave this property set to YES so that Fixtures source will
     more accurately simulate your remote data source.
 
-    If you plan to replace this data source with something that works with 
-    local storage, for example, then you should set this property to NO to 
+    If you plan to replace this data source with something that works with
+    local storage, for example, then you should set this property to NO to
     accurately simulate the behavior of your actual data source.
-    
-    @property {Boolean}
+
+    @type Boolean
   */
   simulateRemoteResponse: NO,
-  
+
   /**
     If you set simulateRemoteResponse to YES, then the fixtures source will
     assume a response latency from your server equal to the msec specified
-    here.  You should tune this to simulate latency based on the expected 
+    here.  You should tune this to simulate latency based on the expected
     performance of your server network.  Here are some good guidelines:
-    
+
      - 500: Simulates a basic server written in PHP, Ruby, or Python (not twisted) without a CDN in front for caching.
      - 250: (Default) simulates the average latency needed to go back to your origin server from anywhere in the world.  assumes your servers itself will respond to requests < 50 msec
      - 100: simulates the latency to a "nearby" server (i.e. same part of the world).  Suitable for simulating locally hosted servers or servers with multiple data centers around the world.
      - 50: simulates the latency to an edge cache node when using a CDN.  Life is really good if you can afford this kind of setup.
-    
-    @property {Number}
+
+    @type Number
   */
   latency: 50,
-  
+
   // ..........................................................
   // CANCELLING
-  // 
-  
+  //
+
   /** @private */
   cancel: function(store, storeKeys) {
     return NO;
   },
-  
-  
+
+
   // ..........................................................
   // FETCHING
-  // 
-  
+  //
+
   /** @private */
   fetch: function(store, query) {
-    
+
     // can only handle local queries out of the box
     if (query.get('location') !== SC.Query.LOCAL) {
       throw SC.$error('SC.Fixture data source can only fetch local queries');
@@ -73,39 +73,39 @@ SC.FixturesDataSource = SC.DataSource.extend(
     if (!query.get('recordType') && !query.get('recordTypes')) {
       throw SC.$error('SC.Fixture data source can only fetch queries with one or more record types');
     }
-    
+
     if (this.get('simulateRemoteResponse')) {
       this.invokeLater(this._fetch, this.get('latency'), store, query);
-      
+
     } else this._fetch(store, query);
   },
-  
+
   /** @private
-    Actually performs the fetch.  
+    Actually performs the fetch.
   */
   _fetch: function(store, query) {
-    
+
     // NOTE: Assumes recordType or recordTypes is defined.  checked in fetch()
     var recordType = query.get('recordType'),
         recordTypes = query.get('recordTypes') || [recordType];
-        
+
     // load fixtures for each recordType
     recordTypes.forEach(function(recordType) {
       if (SC.typeOf(recordType) === SC.T_STRING) {
         recordType = SC.objectForPropertyPath(recordType);
       }
-      
+
       if (recordType) this.loadFixturesFor(store, recordType);
     }, this);
-    
+
     // notify that query has now loaded - puts it into a READY state
     store.dataSourceDidFetchQuery(query);
   },
-  
+
   // ..........................................................
   // RETRIEVING
-  // 
-  
+  //
+
   /** @private */
   retrieveRecords: function(store, storeKeys) {
     // first let's see if the fixture data source can handle any of the
@@ -113,18 +113,18 @@ SC.FixturesDataSource = SC.DataSource.extend(
     var latency = this.get('latency'),
         ret     = this.hasFixturesFor(storeKeys) ;
     if (!ret) return ret ;
-    
+
     if (this.get('simulateRemoteResponse')) {
       this.invokeLater(this._retrieveRecords, latency, store, storeKeys);
     } else this._retrieveRecords(store, storeKeys);
-    
+
     return ret ;
   },
-  
+
   _retrieveRecords: function(store, storeKeys) {
-    
+
     storeKeys.forEach(function(storeKey) {
-      var ret        = [], 
+      var ret        = [],
           recordType = SC.Store.recordTypeFor(storeKey),
           id         = store.idFor(storeKey),
           hash       = this.fixtureForStoreKey(store, storeKey);
@@ -132,11 +132,11 @@ SC.FixturesDataSource = SC.DataSource.extend(
       store.dataSourceDidComplete(storeKey, hash, id);
     }, this);
   },
-  
+
   // ..........................................................
   // UPDATE
-  // 
-  
+  //
+
   /** @private */
   updateRecords: function(store, storeKeys, params) {
     // first let's see if the fixture data source can handle any of the
@@ -144,37 +144,37 @@ SC.FixturesDataSource = SC.DataSource.extend(
     var latency = this.get('latency'),
         ret     = this.hasFixturesFor(storeKeys) ;
     if (!ret) return ret ;
-    
+
     if (this.get('simulateRemoteResponse')) {
       this.invokeLater(this._updateRecords, latency, store, storeKeys);
     } else this._updateRecords(store, storeKeys);
-    
+
     return ret ;
   },
-  
+
   _updateRecords: function(store, storeKeys) {
     storeKeys.forEach(function(storeKey) {
       var hash = store.readDataHash(storeKey);
       this.setFixtureForStoreKey(store, storeKey, hash);
-      store.dataSourceDidComplete(storeKey);  
+      store.dataSourceDidComplete(storeKey);
     }, this);
   },
 
 
   // ..........................................................
   // CREATE RECORDS
-  // 
-  
+  //
+
   /** @private */
   createRecords: function(store, storeKeys, params) {
     // first let's see if the fixture data source can handle any of the
     // storeKeys
     var latency = this.get('latency');
-    
+
     if (this.get('simulateRemoteResponse')) {
       this.invokeLater(this._createRecords, latency, store, storeKeys);
     } else this._createRecords(store, storeKeys);
-    
+
     return YES ;
   },
 
@@ -182,7 +182,7 @@ SC.FixturesDataSource = SC.DataSource.extend(
     storeKeys.forEach(function(storeKey) {
       var id         = store.idFor(storeKey),
           recordType = store.recordTypeFor(storeKey),
-          dataHash   = store.readDataHash(storeKey), 
+          dataHash   = store.readDataHash(storeKey),
           fixtures   = this.fixturesFor(recordType);
 
       if (!id) id = this.generateIdFor(recordType, dataHash, store, storeKey);
@@ -195,8 +195,8 @@ SC.FixturesDataSource = SC.DataSource.extend(
 
   // ..........................................................
   // DESTROY RECORDS
-  // 
-  
+  //
+
   /** @private */
   destroyRecords: function(store, storeKeys, params) {
     // first let's see if the fixture data source can handle any of the
@@ -204,14 +204,14 @@ SC.FixturesDataSource = SC.DataSource.extend(
     var latency = this.get('latency'),
         ret     = this.hasFixturesFor(storeKeys) ;
     if (!ret) return ret ;
-    
+
     if (this.get('simulateRemoteResponse')) {
       this.invokeLater(this._destroyRecords, latency, store, storeKeys);
     } else this._destroyRecords(store, storeKeys);
-    
+
     return ret ;
   },
-  
+
 
   _destroyRecords: function(store, storeKeys) {
     storeKeys.forEach(function(storeKey) {
@@ -221,18 +221,18 @@ SC.FixturesDataSource = SC.DataSource.extend(
 
       this._invalidateCachesFor(recordType, storeKey, id);
       if (id) delete fixtures[id];
-      store.dataSourceDidDestroy(storeKey);  
+      store.dataSourceDidDestroy(storeKey);
     }, this);
   },
-  
+
   // ..........................................................
   // INTERNAL METHODS/PRIMITIVES
-  // 
+  //
 
   /**
     Load fixtures for a given fetchKey into the store
     and push it to the ret array.
-    
+
     @param {SC.Store} store the store to load into
     @param {SC.Record} recordType the record type to load
     @param {SC.Array} ret is passed, array to add loaded storeKeys to.
@@ -241,9 +241,9 @@ SC.FixturesDataSource = SC.DataSource.extend(
   loadFixturesFor: function(store, recordType, ret) {
     var hashes   = [],
         dataHashes, i, storeKey ;
-    
+
     dataHashes = this.fixturesFor(recordType);
-    
+
     for(i in dataHashes){
       storeKey = recordType.storeKeyFor(i);
       if (store.peekStatus(storeKey) === SC.Record.EMPTY) {
@@ -254,29 +254,29 @@ SC.FixturesDataSource = SC.DataSource.extend(
 
     // only load records that were not already loaded to avoid infinite loops
     if (hashes && hashes.length>0) store.loadRecords(recordType, hashes);
-    
+
     return this ;
   },
-  
+
 
   /**
-    Generates an id for the passed record type.  You can override this if 
+    Generates an id for the passed record type.  You can override this if
     needed.  The default generates a storekey and formats it as a string.
-    
+
     @param {Class} recordType Subclass of SC.Record
     @param {Hash} dataHash the data hash for the record
-    @param {SC.Store} store the store 
+    @param {SC.Store} store the store
     @param {Number} storeKey store key for the item
     @returns {String}
   */
   generateIdFor: function(recordType, dataHash, store, storeKey) {
     return "@id%@".fmt(SC.Store.generateStoreKey());
   },
-  
+
   /**
     Based on the storeKey it returns the specified fixtures
-    
-    @param {SC.Store} store the store 
+
+    @param {SC.Store} store the store
     @param {Number} storeKey the storeKey
     @returns {Hash} data hash or null
   */
@@ -286,13 +286,13 @@ SC.FixturesDataSource = SC.DataSource.extend(
         fixtures   = this.fixturesFor(recordType);
     return fixtures ? fixtures[id] : null;
   },
-  
+
   /**
-    Update the data hash fixture for the named store key.  
-    
-    @param {SC.Store} store the store 
+    Update the data hash fixture for the named store key.
+
+    @param {SC.Store} store the store
     @param {Number} storeKey the storeKey
-    @param {Hash} dataHash 
+    @param {Hash} dataHash
     @returns {SC.FixturesDataSource} receiver
   */
   setFixtureForStoreKey: function(store, storeKey, dataHash) {
@@ -303,11 +303,11 @@ SC.FixturesDataSource = SC.DataSource.extend(
     fixtures[id] = dataHash;
     return this ;
   },
-  
-  /** 
+
+  /**
     Get the fixtures for the passed record type and prepare them if needed.
     Return cached value when complete.
-    
+
     @param {SC.Record} recordType
     @returns {Hash} data hashes
   */
@@ -315,27 +315,27 @@ SC.FixturesDataSource = SC.DataSource.extend(
     // get basic fixtures hash.
     if (!this._fixtures) this._fixtures = {};
     var fixtures = this._fixtures[SC.guidFor(recordType)];
-    if (fixtures) return fixtures ; 
-    
+    if (fixtures) return fixtures ;
+
     // need to load fixtures.
     var dataHashes = recordType ? recordType.FIXTURES : null,
         len        = dataHashes ? dataHashes.length : 0,
         primaryKey = recordType ? recordType.prototype.primaryKey : 'guid',
         idx, dataHash, id ;
 
-    this._fixtures[SC.guidFor(recordType)] = fixtures = {} ; 
-    for(idx=0;idx<len;idx++) {      
+    this._fixtures[SC.guidFor(recordType)] = fixtures = {} ;
+    for(idx=0;idx<len;idx++) {
       dataHash = dataHashes[idx];
       id = dataHash[primaryKey];
-      if (!id) id = this.generateIdFor(recordType, dataHash); 
+      if (!id) id = this.generateIdFor(recordType, dataHash);
       fixtures[id] = dataHash;
-    }  
+    }
     return fixtures;
   },
-  
+
   /**
     Returns YES if fixtures for a given recordType have already been loaded
-    
+
     @param {SC.Record} recordType
     @returns {Boolean} storeKeys
   */
@@ -356,9 +356,9 @@ SC.FixturesDataSource = SC.DataSource.extend(
   },
 
   /**
-    Returns YES or SC.MIXED_STATE if one or more of the storeKeys can be 
+    Returns YES or SC.MIXED_STATE if one or more of the storeKeys can be
     handled by the fixture data source.
-    
+
     @param {Array} storeKeys the store keys
     @returns {Boolean} YES if all handled, MIXED_STATE if some handled
   */
@@ -373,15 +373,15 @@ SC.FixturesDataSource = SC.DataSource.extend(
         } else if (ret === YES) ret = SC.MIXED_STATE ;
       }
     }, this);
-    
+
     return ret ;
   },
-  
+
   /** @private
-    Invalidates any internal caches based on the recordType and optional 
+    Invalidates any internal caches based on the recordType and optional
     other parameters.  Currently this only invalidates the storeKeyCache used
     for fetch, but it could invalidate others later as well.
-    
+
     @param {SC.Record} recordType the type of record modified
     @param {Number} storeKey optional store key
     @param {String} id optional record id
@@ -392,12 +392,12 @@ SC.FixturesDataSource = SC.DataSource.extend(
     if (cache) delete cache[SC.guidFor(recordType)];
     return this ;
   }
-  
+
 });
 
 /**
   Default fixtures instance for use in applications.
-  
+
   @property {SC.FixturesDataSource}
 */
 SC.Record.fixtures = SC.FixturesDataSource.create();