sproutcore 1.9.0 → 1.9.1

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
 :major: 1
 :minor: 9
-:patch: 0
+:patch: 1

data/lib/frameworks/sproutcore/CHANGELOG.md

@@ -1,11 +1,133 @@
 CHANGE LOG
 ==========
 
-1.9.0
+Edge
 ----------
 
 ### CHANGES & FEATURES
 
+* Improves and adds documentation.
+* Adds SC.appCache and SC.platform.supportsApplicationCache.
+  Working with the application cache is a confusing and time-consuming task. 
+  This simple object abstracts out the most important properties for developers 
+  to use: hasNewVersion, isNewVersionValid, progress and isReadyForOffline all 
+  the while using the minimum number of event listeners which are properly 
+  cleaned up when unneeded. It also has a property shouldPoll that will lazily 
+  look for updates in the background at a fixed interval. This could be 
+  especially useful in a test environment, where you want to ensure that the 
+  testers aren't running the old version (which happens frequently when using 
+  the application cache).
+* Improves the center calculation for view layouts. Previously you could not use
+  a % width or height with a center value, but there is no technical reason for 
+  this limitation. For example, a view with width: 0.3% and centerX: 0, should 
+  get the layout style: "width: 30%; left: 50%; margin-left: -15%". Previously 
+  it would show a warning and give the view a non-functioning style: 
+  "width: 30%; left: 50%; margin-left: 50%".
+* Removes a lot of legacy default CSS attached to SC.SegmentedView. Also makes 
+  default SproutCore theme more easily allow for sprited button images (requires 
+  a width and height on the icon). After some consideration, the icon sizes are 
+  set by default to: 12x12px for small, 14x14px for regular, 16x16px for large 
+  and 24x24px for huge. These sizes fit well with the theme and although odd 
+  numbered heights would position a bit more nicely, even numbered height icons 
+  are much more common.
+* Allows SC.State to represent the empty ("") route. Previously, there was no 
+  way for a state to represent the empty route using representRoute:. Now a 
+  state can set representRoute: "" to be triggered when the empty route is 
+  fired.
+* Improves SC.request.deparam so that it can accept a full URL, not just the
+  params section only. 
+* Adds SC.platform.supportsWebSQL and SC.platform.supportsIndexedDB.
+* Improves the Welcome apps slightly:
+  - sorts the apps by name alphabetically
+  - groups SproutCore apps after project apps
+  - adds a new icon for app targets to further differentiate between the 
+    developer's apps and the SproutCore apps (Used in the TestRunner app too)
+
+### DEPRECATIONS & REMOVALS
+
+* The default value of SC.SelectView:itemSeparatorKey has been changed from 
+  'separator' to 'isSeparator' to match the documentation.  If a property 
+  'separator' is found on the item, it will still be used and a developer 
+  warning will appear in debug mode.
+* The 'owner' property that is assigned to child views is deprecated and may
+  be removed in a future release.  This property is assigned to a view's 
+  childViews when the view is created.  However, it is a duplication of the 
+  property 'parentView' and it is not maintained properly and not assigned if a 
+  childView is added later using appendChild() or replaceChild().
+
+
+### BUG FIXES
+
+* Fixes minor memory leak in SC.Set.  The way that SC.Set removes objects is 
+  to "untrack" the internal index of the object by shrinking its length, but it 
+  never actually removed the object at the last index. The only way that the 
+  object could be freed is if a new object is inserted at the same internal 
+  index, thus replacing it. If the objects were removed in the reverse order 
+  that they were added, every object would still be in the set (until they were 
+  possibly overwritten).
+* Fixes moderate memory leak with bindings and observers.  Previously, SC.Binding 
+  objects and observers were never cleaned up even as views and objects were 
+  destroyed which could prevent the views and objects from being garbage collected
+  and prevented the binding objects from being garbage collected.
+* Fixes minor memory leak in SC.ObserverSet. Each time that a new observer is 
+  added to an object the ObserverSet for the object will add a tracking hash for 
+  the target and the method. As more methods are tracked for the target, they 
+  are added and as methods are no longer tracked for the target, they are 
+  removed. However, even when no methods are tracked for the target, an empty 
+  tracking hash for the target still exists. This creates a small leak of memory, 
+  because the target may have been destroyed and freed, but we are still 
+  maintaining an empty tracking hash for it.
+
+1.9.1 - BUG FIX RELEASE
+----------
+
+* Unit tests verifying ALL fixes are included.
+* Fixes a bug that left childView elements in the DOM when they were rendered as 
+  part of their parent's layer and the child was later removed.
+
+  If childView layers are rendered when the parentView's layer is created, the 
+  `layer` property on the childView will not be cached.  What occurs is that if 
+  the childView is then removed from the parent view without ever having its 
+  `layer` requested, when it comes time to destroy the DOM layer of the 
+  childView, it will try to find it with a `get('layer')`. The bug was that it 
+  only returned a layer if the view has a parent view. However, since the child 
+  was removed from the parent first and then destroyed, it no longer has a 
+  parent view and would not try to find its leftover DOM layer.
+* Fixes improper implementation of SC.SelectionSet:constrain (fixes #870).  It 
+  was naively using forEach to iterate through the objects while mutating the 
+  array so that the last object could never be constrained.
+* Fixes implicit globals in SC.MenuPane, creating a possible memory leak.
+* Fixes memory leak with child views of SC.View.  The 'owner' property prevented
+  views from being able to be garbage collected when they are destroyed.
+* Fixes SC.stringFromLayout() to include all the layout properties.
+* Fixes the excess calling of parentViewDidResize on child views when the view's 
+  position changes, but it's size doesn't. Previously, views that had fixed 
+  sizes (i.e. width + height), but not fixed positions (i.e. not left + top) 
+  would still call parentViewDidResize on their own child views each time that 
+  the view's parent view resized. However, this isn't necessary, because changes 
+  to the view's parent view will effect the view's frame, but if the view has a 
+  fixed size, it will not effect the child view's frames.
+  - This fixes a strange issue that occurs with SC.ImageView's viewDidResize 
+    implementation, where it fails to resize appropriately.
+  - This separates isFixedLayout into isFixedPosition + isFixedSize, allowing us 
+    more options to decide what to do when the layout is a fixed position vs. a 
+    fixed size vs. both vs. neither.
+  - Note: A similar optimization already exists in layoutDidChange.
+* Fixes bug in SC.Locale that caused localizations to be overwritten by the 
+  last language localized.
+* Fixes SC.Request's application of the Content-Type header.  It was incorrectly
+  adding the header for requests that don't have a body which would cause some
+  servers to reject GET or DELETE requests.
+* Fixes a bug where SC.Record relationships modified within a nested store, would
+  fail to propagate the changes to the parent store if isMaster was NO in the
+  toOne or toMany attribute.  This also fixes possible instances of the same bug
+  if using writeAttribute() and passing YES for the ignoreDidChange param inside
+  a nested store.
+
+1.9.0
+----------
+
+### CHANGES & FEATURES
 
 * Improves and adds much documentation.
 * Adds the Showcase app used on http://showcase.sproutcore.com.  This app contains

data/lib/frameworks/sproutcore/frameworks/ajax/system/request.js

@@ -267,7 +267,7 @@ SC.Request = SC.Object.extend(SC.Copyable, SC.Freezable,
     @returns {SC.Request|Object} receiver
   */
   header: function(key, value) {
-    var headers;
+    var header, headers;
 
     if (SC.typeOf(key) === SC.T_STRING) {
       headers = this._headers;
@@ -285,9 +285,9 @@ SC.Request = SC.Object.extend(SC.Copyable, SC.Freezable,
     } else if (value === undefined) {
       headers = key;
       this.beginPropertyChanges();
-      for(key in headers) {
-        if (!headers.hasOwnProperty(key)) { continue; }
-        this.header(key, headers[key]);
+      for(header in headers) {
+        if (!headers.hasOwnProperty(header)) { continue; }
+        this.header(header, headers[header]);
       }
       this.endPropertyChanges();
       return this;
@@ -359,15 +359,19 @@ SC.Request = SC.Object.extend(SC.Copyable, SC.Freezable,
   _prep: function() {
     var hasContentType = !!this.header('Content-Type');
 
-    if(this.get('attachIdentifyingHeaders')) {
+    if (this.get('attachIdentifyingHeaders')) {
       this.header('X-Requested-With', 'XMLHttpRequest');
       this.header('X-SproutCore-Version', SC.VERSION);
     }
 
-    if (this.get('isJSON') && !hasContentType) {
-      this.header('Content-Type', 'application/json');
-    } else if (this.get('isXML') && !hasContentType) {
-      this.header('Content-Type', 'text/xml');
+    // Set the Content-Type header only if not specified and the request
+    // includes a body.
+    if (!hasContentType && !!this.get('body')) {
+      if (this.get('isJSON')) {
+        this.header('Content-Type', 'application/json');
+      } else if (this.get('isXML')) {
+        this.header('Content-Type', 'text/xml');
+      }
     }
     return this;
   },

data/lib/frameworks/sproutcore/frameworks/ajax/tests/system/request.js

@@ -32,6 +32,74 @@ test("Basic Requirements", function() {
   ok(contents === null, "contents is null" ) ;
 });
 
+test("Default properties are correct for different types of requests.", function() {
+  var formBody,
+    headers,
+    jsonBody,
+    xmlBody,
+    req1, req2, req3, req4, req5;
+
+    // use this document for creating XML
+    xmlBody = document.implementation.createDocument(null, null, null);
+
+    // function that creates the XML structure
+    function o() {
+      var i, node = xmlBody.createElement(arguments[0]), text, child;
+
+      for(i = 1; i < arguments.length; i++) {
+          child = arguments[i];
+          if(typeof child == 'string') {
+              child = xmlBody.createTextNode(child);
+          }
+          node.appendChild(child);
+      }
+
+      return node;
+    }
+
+    // create the XML structure recursively
+    o('report',
+        o('submitter',
+            o('name', 'John Doe')
+        ),
+        o('students',
+            o('student',
+                o('name', 'Alice'),
+                o('grade', '80')
+            ),
+            o('student',
+                o('name', 'Bob'),
+                o('grade', '90')
+            )
+        )
+    );
+
+
+  jsonBody = { a: 1, b: 2 };
+  formBody = "fname=Henry&lname=Ford";
+  req1 = SC.Request.getUrl(url).json()._prep();
+  req2 = SC.Request.postUrl(url, formBody).header('Content-Type', 'application/x-www-form-urlencoded')._prep();
+  req3 = SC.Request.putUrl(url, xmlBody).xml()._prep();
+  req4 = SC.Request.patchUrl(url, jsonBody).json()._prep();
+  req5 = SC.Request.deleteUrl(url)._prep();
+
+  ok(req1.get('isJSON'), 'req1 should have isJSON true');
+  ok(!req1.get('isXML'), 'req1 should have isXML false');
+  equals(req1.header('Content-Type'), undefined, 'req1 should have Content-Type header as');
+  ok(!req2.get('isJSON'), 'req2 should have isJSON false');
+  ok(!req2.get('isXML'), 'req2 should have isXML false');
+  equals(req2.header('Content-Type'), 'application/x-www-form-urlencoded', 'req2 should have Content-Type header as');
+  ok(!req3.get('isJSON'), 'req3 should have isJSON false');
+  ok(req3.get('isXML'), 'req3 should have isXML true');
+  equals(req3.header('Content-Type'), 'text/xml', 'req3 should have Content-Type header as');
+  ok(req4.get('isJSON'), 'req4 should have isJSON true');
+  ok(!req4.get('isXML'), 'req4 should have isXML false');
+  equals(req4.header('Content-Type'), 'application/json', 'req4 should have Content-Type header as');
+  ok(!req5.get('isJSON'), 'req5 should have isJSON false');
+  ok(!req5.get('isXML'), 'req5 should have isXML false');
+  equals(req5.header('Content-Type'), undefined, 'req5 should have Content-Type header as');
+});
+
 test("Test Asynchronous GET Request", function() {
 
   var response, timer;

data/lib/frameworks/sproutcore/frameworks/core_foundation/system/locale.js

@@ -10,41 +10,41 @@
   number formatting conventions, and localization strings.  You can define
   various locales by adding them to the SC.locales hash, keyed by language
   and/or country code.
-  
-  On page load, the default locale will be chosen based on the current 
-  languages and saved at SC.Locale.current.  This locale is used for 
+
+  On page load, the default locale will be chosen based on the current
+  languages and saved at SC.Locale.current.  This locale is used for
   localization, etc.
-  
+
   ## Creating a new locale
-  
+
   You can create a locale by simply extending the SC.Locale class and adding
   it to the locales hash:
-  
+
       SC.Locale.locales['en'] = SC.Locale.extend({ .. config .. }) ;
-  
+
   Alternatively, you could choose to base your locale on another locale by
   extending that locale:
-  
+
       SC.Locale.locales['en-US'] = SC.Locale.locales['en'].extend({ ... }) ;
-  
+
   Note that if you do not define your own strings property, then your locale
   will inherit any strings added to the parent locale.  Otherwise you must
   implement your own strings instead.
-  
+
   @extends SC.Object
   @since SproutCore 1.0
 */
 SC.Locale = SC.Object.extend({
-  
+
   init: function() {
     // make sure we know the name of our own locale.
     if (!this.language) SC.Locale._assignLocales();
-    
+
     // Make sure we have strings that were set using the new API.  To do this
-    // we check to a bool that is set by one of the string helpers.  This 
+    // we check to a bool that is set by one of the string helpers.  This
     // indicates that the new API was used. If the new API was not used, we
-    // check to see if the old API was used (which places strings on the 
-    // String class). 
+    // check to see if the old API was used (which places strings on the
+    // String class).
     if (!this.hasStrings) {
       var langs = this._deprecatedLanguageCodes || [] ;
       langs.push(this.language);
@@ -54,18 +54,18 @@ SC.Locale = SC.Object.extend({
         strings = String[langs[idx]];
       }
       if (strings) {
-        this.hasStrings = YES; 
+        this.hasStrings = YES;
         this.strings = strings ;
       }
     }
   },
-  
+
   /** Set to YES when strings have been added to this locale. */
   hasStrings: NO,
-  
+
   /** The strings hash for this locale. */
   strings: {},
-  
+
   /**
     The metrics for this locale.  A metric is a singular value that is usually
     used in a user interface layout, such as "width of the OK button".
@@ -76,18 +76,18 @@ SC.Locale = SC.Object.extend({
     if (!this.language) SC.Locale._assignLocales() ;
     return "SC.Locale["+this.language+"]"+SC.guidFor(this) ;
   },
-  
-  /** 
+
+  /**
     Returns the localized version of the string or the string if no match
     was found.
-    
+
     @param {String} string
     @param {String} optional default string to return instead
     @returns {String}
   */
   locWithDefault: function(string, def) {
     var ret = this.strings[string];
-    
+
     // strings may be blank, so test with typeOf.
     if (SC.typeOf(ret) === SC.T_STRING) return ret;
     else if (SC.typeOf(def) === SC.T_STRING) return def;
@@ -215,16 +215,15 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
   layoutKeys: ['left', 'top', 'right', 'bottom', 'width', 'height',
                'minWidth', 'minHeight', 'centerX', 'centerY'],
 
-  /** 
-    Invoked at the start of SproutCore's document onready handler to setup 
+  /**
+    Invoked at the start of SproutCore's document onready handler to setup
     the currentLocale.  This will use the language properties you have set on
     the locale to make a decision.
   */
   createCurrentLocale: function() {
-
-    // get values from String if defined for compatibility with < 1.0 build 
+    // get values from String if defined for compatibility with < 1.0 build
     // tools.
-    var autodetect = (String.useAutodetectedLanguage !== undefined) ? String.useAutodetectedLanguage : this.useAutodetectedLanguage; 
+    var autodetect = (String.useAutodetectedLanguage !== undefined) ? String.useAutodetectedLanguage : this.useAutodetectedLanguage;
     var preferred = (String.preferredLanguage !== undefined) ? String.preferredLanguage : this.preferredLanguage ;
 
     // determine the language
@@ -251,33 +250,33 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
   localeClassFor: function(lang) {
     lang = SC.Locale.normalizeLanguage(lang) ;
     var parent, klass = this.locales[lang];
-    
+
     // if locale class was not found and there is a broader-based locale
     // present, create a new locale based on that.
     if (!klass && ((parent = lang.split('-')[0]) !== lang) && (klass = this.locales[parent])) {
-      klass = this.locales[lang] = klass.extend() ;      
+      klass = this.locales[lang] = klass.extend() ;
     }
-    
+
     // otherwise, try to create a new locale based on english.
     if (!klass) klass = this.locales[lang] = this.locales.en.extend();
-    
+
     return klass;
   },
 
-  /** 
+  /**
     Shorthand method to define the settings for a particular locale.
     The settings you pass here will be applied directly to the locale you
-    designate.  
+    designate.
 
     If you are already holding a reference to a locale definition, you can
     also use this method to operate on the receiver.
-    
-    If the locale you name does not exist yet, this method will create the 
-    locale for you, based on the most closely related locale or english.  For 
+
+    If the locale you name does not exist yet, this method will create the
+    locale for you, based on the most closely related locale or english.  For
     example, if you name the locale 'fr-CA', you will be creating a locale for
     French as it is used in Canada.  This will be based on the general French
     locale (fr), since that is more generic.  On the other hand, if you create
-    a locale for mandarin (cn), it will be based on generic english (en) 
+    a locale for mandarin (cn), it will be based on generic english (en)
     since there is no broader language code to match against.
 
     @param {String} localeName
@@ -292,20 +291,20 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     SC.mixin(locale.prototype, options) ;
     return locale ;
   },
-  
+
   /**
-    Gets the current options for the receiver locale.  This is useful for 
+    Gets the current options for the receiver locale.  This is useful for
     inspecting registered locales that have not been instantiated.
-    
+
     @returns {Hash} options + instance methods
   */
   options: function() { return this.prototype; },
-  
+
   /**
     Adds the passed hash of strings to the locale's strings table.  Note that
-    if the receiver locale inherits its strings from its parent, then the 
+    if the receiver locale inherits its strings from its parent, then the
     strings table will be cloned first.
-    
+
     @returns {Object} receiver
   */
   addStrings: function(stringsHash) {
@@ -313,10 +312,10 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     var strings = this.prototype.strings ;
     if (strings) {
       if (!this.prototype.hasOwnProperty('strings')) {
-        this.prototype.strings = SC.clone(strings) ;
+        strings = this.prototype.strings = SC.clone(strings) ;
       }
     } else strings = this.prototype.strings = {} ;
-    
+
     // add strings hash
     if (stringsHash)  this.prototype.strings = SC.mixin(strings, stringsHash) ;
     this.prototype.hasStrings = YES ;
@@ -336,7 +335,7 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     var metrics = this.prototype.metrics;
     if (metrics) {
       if (!this.prototype.hasOwnProperty(metrics)) {
-        this.prototype.metrics = SC.clone(metrics) ;
+        metrics = this.prototype.metrics = SC.clone(metrics) ;
       }
     }
     else {
@@ -354,13 +353,13 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
   },
 
   _map: { english: 'en', french: 'fr', german: 'de', japanese: 'ja', jp: 'ja', spanish: 'es' },
-  
+
   /**
     Normalizes the passed language into a two-character language code.
     This method allows you to specify common languages in their full english
     name (i.e. English, French, etc). and it will be treated like their two
     letter code equivalent.
-    
+
     @param {String} languageCode
     @returns {String} normalized code
   */
@@ -368,19 +367,19 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     if (!languageCode) return 'en' ;
     return SC.Locale._map[languageCode.toLowerCase()] || languageCode ;
   },
-  
-  // this method is called once during init to walk the installed locales 
+
+  // this method is called once during init to walk the installed locales
   // and make sure they know their own names.
   _assignLocales: function() {
     for(var key in this.locales) this.locales[key].prototype.language = key;
   },
-  
+
   toString: function() {
     if (!this.prototype.language) SC.Locale._assignLocales() ;
     return "SC.Locale["+this.prototype.language+"]" ;
   },
-  
-  // make sure important properties are copied to new class. 
+
+  // make sure important properties are copied to new class.
   extend: function() {
     var ret= SC.Object.extend.apply(this, arguments) ;
     ret.addStrings= SC.Locale.addStrings;
@@ -389,14 +388,14 @@ SC.Locale.mixin(/** @scope SC.Locale */ {
     ret.toString = SC.Locale.toString ;
     return ret ;
   }
-    
+
 }) ;
 
-/** 
+/**
   This locales hash contains all of the locales defined by SproutCore and
   by your own application.  See the SC.Locale class definition for the
   various properties you can set on your own locales.
-  
+
   @property {Hash}
 */
 SC.Locale.locales = {
@@ -413,12 +412,12 @@ SC.Locale.locales = {
 /**
   This special helper will store the strings you pass in the locale matching
   the language code.  If a locale is not defined from the language code you
-  specify, then one will be created for you with the english locale as the 
+  specify, then one will be created for you with the english locale as the
   parent.
-  
+
   @param {String} languageCode
   @param {Hash} strings
-  @returns {Object} receiver 
+  @returns {Object} receiver
 */
 SC.stringsFor = function(languageCode, strings) {
   // get the locale, creating one if needed.