ember-source 1.0.0.rc3.4 → 1.0.0.rc3.5

data/dist/ember-runtime.js

@@ -1,5 +1,5 @@
-// Version: v1.0.0-rc.3-251-gcd5dfe3
-// Last commit: cd5dfe3 (2013-05-18 11:06:43 -0700)
+// Version: v1.0.0-rc.3-2-g85bfdbf
+// Last commit: 85bfdbf (2013-07-25 20:16:20 -0400)
 
 
 (function() {
@@ -151,8 +151,8 @@ Ember.deprecateFunc = function(message, func) {
 
 })();
 
-// Version: v1.0.0-rc.3-251-gcd5dfe3
-// Last commit: cd5dfe3 (2013-05-18 11:06:43 -0700)
+// Version: v1.0.0-rc.3-2-g85bfdbf
+// Last commit: 85bfdbf (2013-07-25 20:16:20 -0400)
 
 
 (function() {
@@ -467,7 +467,7 @@ Ember.none = Ember.deprecateFunc("Ember.none is deprecated. Please use Ember.isN
   @return {Boolean}
 */
 Ember.isEmpty = function(obj) {
-  return Ember.isNone(obj) || (obj.length === 0 && typeof obj !== 'function') || (typeof obj === 'object' && Ember.get(obj, 'length') === 0);
+  return obj === null || obj === undefined || (obj.length === 0 && typeof obj !== 'function') || (typeof obj === 'object' && Ember.get(obj, 'length') === 0);
 };
 Ember.empty = Ember.deprecateFunc("Ember.empty is deprecated. Please use Ember.isEmpty instead.", Ember.isEmpty) ;
 
@@ -500,13 +500,6 @@ var platform = Ember.platform = {};
 */
 Ember.create = Object.create;
 
-// IE8 has Object.create but it couldn't treat property descripters.
-if (Ember.create) {
-  if (Ember.create({a: 1}, {a: {value: 2}}).a !== 2) {
-    Ember.create = null;
-  }
-}
-
 // STUB_OBJECT_CREATE allows us to override other libraries that stub
 // Object.create different than we would prefer
 if (!Ember.create || Ember.ENV.STUB_OBJECT_CREATE) {
@@ -827,7 +820,7 @@ Ember.guidFor = function guidFor(obj) {
   if (obj === undefined) return "(undefined)";
   if (obj === null) return "(null)";
 
-  var ret;
+  var cache, ret;
   var type = typeof obj;
 
   // Don't allow prototype changes to String etc. to change the guidFor
@@ -1228,7 +1221,7 @@ if (needsFinallyFix) {
 */
 if (needsFinallyFix) {
   Ember.tryCatchFinally = function(tryable, catchable, finalizer, binding) {
-    var result, finalResult, finalError;
+    var result, finalResult, finalError, finalReturn;
 
     binding = binding || this;
 
@@ -1999,12 +1992,13 @@ get = function get(obj, keyName) {
     obj = null;
   }
 
-  Ember.assert("Cannot call get with '"+ keyName +"' on an undefined object.", obj !== undefined);
-
-  if (obj === null || keyName.indexOf('.') !== -1) {
+  if (!obj || keyName.indexOf('.') !== -1) {
+    Ember.assert("Cannot call get with '"+ keyName +"' on an undefined object.", obj !== undefined);
     return getPath(obj, keyName);
   }
 
+  Ember.assert("You need to provide an object and key to `get`.", !!obj && keyName);
+
   var meta = obj[META_KEY], desc = meta && meta.descs[keyName], ret;
   if (desc) {
     return desc.get(obj, keyName);
@@ -2076,7 +2070,7 @@ var getPath = Ember._getPath = function(root, path) {
 
   parts = path.split(".");
   len = parts.length;
-  for (idx=0; root !== undefined && root !== null && idx<len; idx++) {
+  for (idx=0; root && idx<len; idx++) {
     root = get(root, parts[idx], true);
     if (root && root.isDestroyed) { return undefined; }
   }
@@ -2122,9 +2116,7 @@ Ember.getPath = Ember.deprecateFunc('getPath is deprecated since get now support
 
 var o_create = Ember.create,
     metaFor = Ember.meta,
-    META_KEY = Ember.META_KEY,
-    /* listener flags */
-    ONCE = 1, SUSPENDED = 2;
+    META_KEY = Ember.META_KEY;
 
 /*
   The event system uses a series of nested hashes to store listeners on an
@@ -2137,7 +2129,7 @@ var o_create = Ember.create,
       {
         listeners: {       // variable name: `listenerSet`
           "foo:changed": [ // variable name: `actions`
-            [target, method, flags]
+            [target, method, onceFlag, suspendedFlag]
           ]
         }
       }
@@ -2183,11 +2175,12 @@ function actionsUnion(obj, eventName, otherActions) {
   for (var i = actions.length - 1; i >= 0; i--) {
     var target = actions[i][0],
         method = actions[i][1],
-        flags = actions[i][2],
+        once = actions[i][2],
+        suspended = actions[i][3],
         actionIndex = indexOf(otherActions, target, method);
 
     if (actionIndex === -1) {
-      otherActions.push([target, method, flags]);
+      otherActions.push([target, method, once, suspended]);
     }
   }
 }
@@ -2201,13 +2194,14 @@ function actionsDiff(obj, eventName, otherActions) {
   for (var i = actions.length - 1; i >= 0; i--) {
     var target = actions[i][0],
         method = actions[i][1],
-        flags = actions[i][2],
+        once = actions[i][2],
+        suspended = actions[i][3],
         actionIndex = indexOf(otherActions, target, method);
 
     if (actionIndex !== -1) { continue; }
 
-    otherActions.push([target, method, flags]);
-    diffActions.push([target, method, flags]);
+    otherActions.push([target, method, once, suspended]);
+    diffActions.push([target, method, once, suspended]);
   }
 
   return diffActions;
@@ -2233,14 +2227,11 @@ function addListener(obj, eventName, target, method, once) {
   }
 
   var actions = actionsFor(obj, eventName),
-      actionIndex = indexOf(actions, target, method),
-      flags = 0;
-
-  if (once) flags |= ONCE;
+      actionIndex = indexOf(actions, target, method);
 
   if (actionIndex !== -1) { return; }
 
-  actions.push([target, method, flags]);
+  actions.push([target, method, once, undefined]);
 
   if ('function' === typeof obj.didAddListener) {
     obj.didAddListener(eventName, target, method);
@@ -2267,7 +2258,7 @@ function removeListener(obj, eventName, target, method) {
     target = null;
   }
 
-  function _removeListener(target, method) {
+  function _removeListener(target, method, once) {
     var actions = actionsFor(obj, eventName),
         actionIndex = indexOf(actions, target, method);
 
@@ -2324,12 +2315,12 @@ function suspendListener(obj, eventName, target, method, callback) {
 
   if (actionIndex !== -1) {
     action = actions[actionIndex].slice(); // copy it, otherwise we're modifying a shared object
-    action[2] |= SUSPENDED; // mark the action as suspended
+    action[3] = true; // mark the action as suspended
     actions[actionIndex] = action; // replace the shared object with our copy
   }
 
   function tryable()   { return callback.call(target); }
-  function finalizer() { if (action) { action[2] &= ~SUSPENDED; } }
+  function finalizer() { if (action) { action[3] = undefined; } }
 
   return Ember.tryFinally(tryable, finalizer);
 }
@@ -2368,7 +2359,7 @@ function suspendListeners(obj, eventNames, target, method, callback) {
 
     if (actionIndex !== -1) {
       action = actions[actionIndex].slice();
-      action[2] |= SUSPENDED;
+      action[3] = true;
       actions[actionIndex] = action;
       suspendedActions.push(action);
     }
@@ -2378,7 +2369,7 @@ function suspendListeners(obj, eventNames, target, method, callback) {
 
   function finalizer() {
     for (i = 0, l = suspendedActions.length; i < l; i++) {
-      suspendedActions[i][2] &= ~SUSPENDED;
+      suspendedActions[i][3] = undefined;
     }
   }
 
@@ -2428,11 +2419,13 @@ function sendEvent(obj, eventName, params, actions) {
   if (!actions) { return; }
 
   for (var i = actions.length - 1; i >= 0; i--) { // looping in reverse for once listeners
-    var action = actions[i];
-    if (!action) { continue; }
-    var target = action[0], method = action[1], flags = action[2];
-    if (flags & SUSPENDED) { continue; }
-    if (flags & ONCE) { removeListener(obj, eventName, target, method); }
+    if (!actions[i] || actions[i][3] === true) { continue; }
+
+    var target = actions[i][0],
+        method = actions[i][1],
+        once = actions[i][2];
+
+    if (once) { removeListener(obj, eventName, target, method); }
     if (!target) { target = obj; }
     if ('string' === typeof method) { method = target[method]; }
     if (params) {
@@ -2512,7 +2505,7 @@ var guidFor = Ember.guidFor,
       keyName: keyName,
       eventName: eventName,
       listeners: [
-        [target, method, flags]
+        [target, method, onceFlag, suspendedFlag]
       ]
     },
     ...
@@ -2741,11 +2734,11 @@ var endPropertyChanges = Ember.endPropertyChanges = function() {
   });
   ```
 
-  @method changeProperties
+  @method changePropertiess
   @param {Function} callback
   @param [binding]
 */
-Ember.changeProperties = function(cb, binding){
+var changeProperties = Ember.changeProperties = function(cb, binding){
   beginPropertyChanges();
   tryFinally(cb, endPropertyChanges, binding);
 };
@@ -2950,7 +2943,7 @@ var MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER;
   @private
   @constructor
 */
-Ember.Descriptor = function() {};
+var Descriptor = Ember.Descriptor = function() {};
 
 // ..........................................................
 // DEFINING PROPERTIES API
@@ -3511,7 +3504,7 @@ Ember.watchPath = function(obj, keyPath) {
 };
 
 Ember.unwatchPath = function(obj, keyPath) {
-  var m = metaFor(obj), watching = m.watching;
+  var m = metaFor(obj), watching = m.watching, desc;
 
   if (watching[keyPath] === 1) {
     watching[keyPath] = 0;
@@ -4057,6 +4050,7 @@ ComputedPropertyPrototype.teardown = function(obj, keyName) {
   The function should accept two parameters, key and value. If value is not
   undefined you should set the value first. In either case return the
   current value of the property.
+
   @method computed
   @for Ember
   @param {Function} func The computed property function.
@@ -4298,7 +4292,7 @@ registerComputedWithProperties('or', function(properties) {
   @for Ember
   @param {String} dependentKey, [dependentKey...]
   @return {Ember.ComputedProperty} computed property which returns
-  the first truthy value of given list of properties.
+  the first trouthy value of given list of properties.
 */
 registerComputedWithProperties('any', function(properties) {
   for (var key in properties) {
@@ -4348,48 +4342,6 @@ Ember.computed.alias = function(dependentKey) {
   });
 };
 
-/**
-  @method computed.oneWay
-  @for Ember
-  @param {String} dependentKey
-  @return {Ember.ComputedProperty} computed property which creates an
-  one way computed property to the original value for property.
-
-  Where `computed.alias` aliases `get` and `set`, and allows for bidirectional 
-  data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
-  not mutate the upstream property, rather causes the current property to
-  become the value set. This causes the downstream property to permentantly
-  diverge from the upstream property.
-
-  ```javascript
-  User = Ember.Object.extend({
-    firstName: null,
-    lastName: null,
-    nickName: Ember.computed.oneWay('firstName')
-  });
-
-  user = User.create({
-    firstName: 'Teddy',
-    lastName:  'Zeenny'
-  });
-
-  user.get('nickName');
-  # 'Teddy'
-
-  user.set('nickName', 'TeddyBear');
-  # 'TeddyBear'
-
-  user.get('firstName');
-  # 'Teddy'
-  ```
-*/
-Ember.computed.oneWay = function(dependentKey) {
-  return Ember.computed(dependentKey, function() {
-    return get(this, dependentKey);
-  });
-};
-
-
 /**
   @method computed.defaultTo
   @for Ember
@@ -4419,6 +4371,8 @@ Ember.computed.defaultTo = function(defaultPath) {
 var AFTER_OBSERVERS = ':change';
 var BEFORE_OBSERVERS = ':before';
 
+var guidFor = Ember.guidFor;
+
 function changeEvent(keyName) {
   return keyName+AFTER_OBSERVERS;
 }
@@ -4910,44 +4864,27 @@ Ember.run.sync = function() {
 
 var timers = {}; // active timers...
 
-function sortByExpires(timerA, timerB) {
-  var a = timerA.expires,
-      b = timerB.expires;
-
-  if (a > b) { return  1; }
-  if (a < b) { return -1; }
-  return 0;
-}
-
 var scheduledLater, scheduledLaterExpires;
 function invokeLaterTimers() {
   scheduledLater = null;
   run(function() {
     var now = (+ new Date()), earliest = -1;
-    var timersToBeInvoked = [];
     for (var key in timers) {
       if (!timers.hasOwnProperty(key)) { continue; }
       var timer = timers[key];
       if (timer && timer.expires) {
         if (now >= timer.expires) {
           delete timers[key];
-          timersToBeInvoked.push(timer);
+          invoke(timer.target, timer.method, timer.args, 2);
         } else {
           if (earliest < 0 || (timer.expires < earliest)) { earliest = timer.expires; }
         }
       }
     }
 
-    forEach.call(timersToBeInvoked.sort(sortByExpires), function(timer) {
-      invoke(timer.target, timer.method, timer.args, 2);
-    });
-
     // schedule next timeout to fire when the earliest timer expires
     if (earliest > 0) {
-      // To allow overwrite `setTimeout` as stub from test code.
-      // The assignment to `window.setTimeout` doesn't equal to `setTimeout` in older IE.
-      // So `window` is required.
-      scheduledLater = window.setTimeout(invokeLaterTimers, earliest - now);
+      scheduledLater = setTimeout(invokeLaterTimers, earliest - now);
       scheduledLaterExpires = earliest;
     }
   });
@@ -5577,7 +5514,7 @@ mixinProperties(Binding, {
 
   You should consider using one way bindings anytime you have an object that
   may be created frequently and you do not intend to change a property; only
-  to monitor it for changes (such as in the example above).
+  to monitor it for changes. (such as in the example above).
 
   ## Adding Bindings Manually
 
@@ -5878,6 +5815,14 @@ function mergeMixins(mixins, m, descs, values, base, keys) {
   }
 }
 
+function writableReq(obj) {
+  var m = Ember.meta(obj), req = m.required;
+  if (!req || !m.hasOwnProperty('required')) {
+    req = m.required = req ? o_create(req) : {};
+  }
+  return req;
+}
+
 var IS_BINDING = Ember.IS_BINDING = /^.+Binding$/;
 
 function detectBinding(obj, key, value, m) {
@@ -6363,57 +6308,14 @@ Ember Metal
 })();
 
 (function() {
-define("rsvp/all",
-  ["rsvp/defer","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var defer = __dependency1__.defer;
-
-    function all(promises) {
-      var results = [], deferred = defer(), remaining = promises.length;
-
-      if (remaining === 0) {
-        deferred.resolve([]);
-      }
-
-      var resolver = function(index) {
-        return function(value) {
-          resolveAll(index, value);
-        };
-      };
-
-      var resolveAll = function(index, value) {
-        results[index] = value;
-        if (--remaining === 0) {
-          deferred.resolve(results);
-        }
-      };
-
-      var rejectAll = function(error) {
-        deferred.reject(error);
-      };
-
-      for (var i = 0; i < promises.length; i++) {
-        if (promises[i] && typeof promises[i].then === 'function') {
-          promises[i].then(resolver(i), rejectAll);
-        } else {
-          resolveAll(i, promises[i]);
-        }
-      }
-      return deferred.promise;
-    }
-
-    __exports__.all = all;
-  });
-
-define("rsvp/async",
-  ["exports"],
-  function(__exports__) {
+define("rsvp",
+  [],
+  function() {
     "use strict";
     var browserGlobal = (typeof window !== 'undefined') ? window : {};
 
-    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-    var async;
+    var MutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var RSVP, async;
 
     if (typeof process !== 'undefined' &&
       {}.toString.call(process) === '[object process]') {
@@ -6422,10 +6324,10 @@ define("rsvp/async",
           callback.call(binding);
         });
       };
-    } else if (BrowserMutationObserver) {
+    } else if (MutationObserver) {
       var queue = [];
 
-      var observer = new BrowserMutationObserver(function() {
+      var observer = new MutationObserver(function() {
         var toProcess = queue.slice();
         queue = [];
 
@@ -6456,47 +6358,6 @@ define("rsvp/async",
       };
     }
 
-
-    __exports__.async = async;
-  });
-
-define("rsvp/config",
-  ["rsvp/async","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var async = __dependency1__.async;
-
-    var config = {};
-    config.async = async;
-
-    __exports__.config = config;
-  });
-
-define("rsvp/defer",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function defer() {
-      var deferred = {};
-
-      var promise = new Promise(function(resolve, reject) {
-        deferred.resolve = resolve;
-        deferred.reject = reject;
-      });
-
-      deferred.promise = promise;
-      return deferred;
-    }
-
-    __exports__.defer = defer;
-  });
-
-define("rsvp/events",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
     var Event = function(type, options) {
       this.type = type;
 
@@ -6591,148 +6452,7 @@ define("rsvp/events",
       }
     };
 
-
-    __exports__.EventTarget = EventTarget;
-  });
-
-define("rsvp/hash",
-  ["rsvp/defer","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var defer = __dependency1__.defer;
-
-    function size(object) {
-      var size = 0;
-
-      for (var prop in object) {
-        size++;
-      }
-
-      return size;
-    }
-
-    function hash(promises) {
-      var results = {}, deferred = defer(), remaining = size(promises);
-
-      if (remaining === 0) {
-        deferred.resolve({});
-      }
-
-      var resolver = function(prop) {
-        return function(value) {
-          resolveAll(prop, value);
-        };
-      };
-
-      var resolveAll = function(prop, value) {
-        results[prop] = value;
-        if (--remaining === 0) {
-          deferred.resolve(results);
-        }
-      };
-
-      var rejectAll = function(error) {
-        deferred.reject(error);
-      };
-
-      for (var prop in promises) {
-        if (promises[prop] && typeof promises[prop].then === 'function') {
-          promises[prop].then(resolver(prop), rejectAll);
-        } else {
-          resolveAll(prop, promises[prop]);
-        }
-      }
-
-      return deferred.promise;
-    }
-
-    __exports__.hash = hash;
-  });
-
-define("rsvp/node",
-  ["rsvp/promise","rsvp/all","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    var all = __dependency2__.all;
-
-    function makeNodeCallbackFor(resolve, reject) {
-      return function (error, value) {
-        if (error) {
-          reject(error);
-        } else if (arguments.length > 2) {
-          resolve(Array.prototype.slice.call(arguments, 1));
-        } else {
-          resolve(value);
-        }
-      };
-    }
-
-    function denodeify(nodeFunc) {
-      return function()  {
-        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
-
-        var promise = new Promise(function(nodeResolve, nodeReject) {
-          resolve = nodeResolve;
-          reject = nodeReject;
-        });
-
-        all(nodeArgs).then(function(nodeArgs) {
-          nodeArgs.push(makeNodeCallbackFor(resolve, reject));
-
-          try {
-            nodeFunc.apply(this, nodeArgs);
-          } catch(e) {
-            reject(e);
-          }
-        });
-
-        return promise;
-      };
-    }
-
-    __exports__.denodeify = denodeify;
-  });
-
-define("rsvp/promise",
-  ["rsvp/config","rsvp/events","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var config = __dependency1__.config;
-    var EventTarget = __dependency2__.EventTarget;
-
-    function objectOrFunction(x) {
-      return isFunction(x) || (typeof x === "object" && x !== null);
-    }
-
-    function isFunction(x){
-      return typeof x === "function";
-    }
-
-    var Promise = function(resolver) {
-      var promise = this,
-      resolved = false;
-
-      if (typeof resolver !== 'function') {
-        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
-      }
-
-      if (!(promise instanceof Promise)) {
-        return new Promise(resolver);
-      }
-
-      var resolvePromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        resolve(promise, value);
-      };
-
-      var rejectPromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        reject(promise, value);
-      };
-
+    var Promise = function() {
       this.on('promise:resolved', function(event) {
         this.trigger('success', { detail: event.detail });
       }, this);
@@ -6740,16 +6460,12 @@ define("rsvp/promise",
       this.on('promise:failed', function(event) {
         this.trigger('error', { detail: event.detail });
       }, this);
-
-      try {
-        resolver(resolvePromise, rejectPromise);
-      } catch(e) {
-        rejectPromise(e);
-      }
     };
 
+    var noop = function() {};
+
     var invokeCallback = function(type, promise, callback, event) {
-      var hasCallback = isFunction(callback),
+      var hasCallback = typeof callback === 'function',
           value, error, succeeded, failed;
 
       if (hasCallback) {
@@ -6765,34 +6481,34 @@ define("rsvp/promise",
         succeeded = true;
       }
 
-      if (handleThenable(promise, value)) {
-        return;
+      if (value && typeof value.then === 'function') {
+        value.then(function(value) {
+          promise.resolve(value);
+        }, function(error) {
+          promise.reject(error);
+        });
       } else if (hasCallback && succeeded) {
-        resolve(promise, value);
+        promise.resolve(value);
       } else if (failed) {
-        reject(promise, error);
-      } else if (type === 'resolve') {
-        resolve(promise, value);
-      } else if (type === 'reject') {
-        reject(promise, value);
+        promise.reject(error);
+      } else {
+        promise[type](value);
       }
     };
 
     Promise.prototype = {
-      constructor: Promise,
-
       then: function(done, fail) {
-        var thenPromise = new Promise(function() {});
+        var thenPromise = new Promise();
 
-        if (this.isFulfilled) {
-          config.async(function() {
-            invokeCallback('resolve', thenPromise, done, { detail: this.fulfillmentValue });
+        if (this.isResolved) {
+          RSVP.async(function() {
+            invokeCallback('resolve', thenPromise, done, { detail: this.resolvedValue });
           }, this);
         }
 
         if (this.isRejected) {
-          config.async(function() {
-            invokeCallback('reject', thenPromise, fail, { detail: this.rejectedReason });
+          RSVP.async(function() {
+            invokeCallback('reject', thenPromise, fail, { detail: this.rejectedValue });
           }, this);
         }
 
@@ -6805,162 +6521,75 @@ define("rsvp/promise",
         });
 
         return thenPromise;
-      }
-    };
+      },
 
-    EventTarget.mixin(Promise.prototype);
+      resolve: function(value) {
+        resolve(this, value);
 
-    function resolve(promise, value) {
-      if (promise === value) {
-        fulfill(promise, value);
-      } else if (!handleThenable(promise, value)) {
-        fulfill(promise, value);
-      }
-    }
+        this.resolve = noop;
+        this.reject = noop;
+      },
 
-    function handleThenable(promise, value) {
-      var then = null;
+      reject: function(value) {
+        reject(this, value);
 
-      if (objectOrFunction(value)) {
-        try {
-          then = value.then;
-        } catch(e) {
-          reject(promise, e);
-          return true;
-        }
-
-        if (isFunction(then)) {
-          try {
-            then.call(value, function(val) {
-              if (value !== val) {
-                resolve(promise, val);
-              } else {
-                fulfill(promise, val);
-              }
-            }, function(val) {
-              reject(promise, val);
-            });
-          } catch (e) {
-            reject(promise, e);
-          }
-          return true;
-        }
+        this.resolve = noop;
+        this.reject = noop;
       }
+    };
 
-      return false;
-    }
-
-    function fulfill(promise, value) {
-      config.async(function() {
+    function resolve(promise, value) {
+      RSVP.async(function() {
         promise.trigger('promise:resolved', { detail: value });
-        promise.isFulfilled = true;
-        promise.fulfillmentValue = value;
+        promise.isResolved = true;
+        promise.resolvedValue = value;
       });
     }
 
     function reject(promise, value) {
-      config.async(function() {
+      RSVP.async(function() {
         promise.trigger('promise:failed', { detail: value });
         promise.isRejected = true;
-        promise.rejectedReason = value;
+        promise.rejectedValue = value;
       });
     }
 
+    function all(promises) {
+      var i, results = [];
+      var allPromise = new Promise();
+      var remaining = promises.length;
 
-    __exports__.Promise = Promise;
-  });
-
-define("rsvp/reject",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-
-    function objectOrFunction(x) {
-      return typeof x === "function" || (typeof x === "object" && x !== null);
-    }
-
-
-    function reject(reason) {
-      return new Promise(function (resolve, reject) {
-        reject(reason);
-      });
-    }
-
-
-    __exports__.reject = reject;
-  });
-
-define("rsvp/resolve",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-
-    function objectOrFunction(x) {
-      return typeof x === "function" || (typeof x === "object" && x !== null);
-    }
-
-    function resolve(thenable){
-      var promise = new Promise(function(resolve, reject){
-        var then;
-
-        try {
-          if ( objectOrFunction(thenable) ) {
-            then = thenable.then;
-
-            if (typeof then === "function") {
-              then.call(thenable, resolve, reject);
-            } else {
-              resolve(thenable);
-            }
+      if (remaining === 0) {
+        allPromise.resolve([]);
+      }
 
-          } else {
-            resolve(thenable);
-          }
+      var resolver = function(index) {
+        return function(value) {
+          resolve(index, value);
+        };
+      };
 
-        } catch(error) {
-          reject(error);
+      var resolve = function(index, value) {
+        results[index] = value;
+        if (--remaining === 0) {
+          allPromise.resolve(results);
         }
-      });
+      };
 
-      return promise;
-    }
+      var reject = function(error) {
+        allPromise.reject(error);
+      };
 
+      for (i = 0; i < remaining; i++) {
+        promises[i].then(resolver(i), reject);
+      }
+      return allPromise;
+    }
 
-    __exports__.resolve = resolve;
-  });
+    EventTarget.mixin(Promise.prototype);
 
-define("rsvp",
-  ["rsvp/events","rsvp/promise","rsvp/node","rsvp/all","rsvp/hash","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __exports__) {
-    "use strict";
-    var EventTarget = __dependency1__.EventTarget;
-    var Promise = __dependency2__.Promise;
-    var denodeify = __dependency3__.denodeify;
-    var all = __dependency4__.all;
-    var hash = __dependency5__.hash;
-    var defer = __dependency6__.defer;
-    var config = __dependency7__.config;
-    var resolve = __dependency8__.resolve;
-    var reject = __dependency9__.reject;
-
-    function configure(name, value) {
-      config[name] = value;
-    }
-
-
-    __exports__.Promise = Promise;
-    __exports__.EventTarget = EventTarget;
-    __exports__.all = all;
-    __exports__.hash = hash;
-    __exports__.defer = defer;
-    __exports__.denodeify = denodeify;
-    __exports__.configure = configure;
-    __exports__.resolve = resolve;
-    __exports__.reject = reject;
+    RSVP = { async: async, Promise: Promise, Event: Event, EventTarget: EventTarget, all: all, raiseOnUncaughtExceptions: true };
+    return RSVP;
   });
 
 })();
@@ -7536,7 +7165,7 @@ var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'n
   @constructor
 */
 Ember.Error = function() {
-  var tmp = Error.apply(this, arguments);
+  var tmp = Error.prototype.constructor.apply(this, arguments);
 
   // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
   for (var idx = 0; idx < errorProps.length; idx++) {
@@ -7798,12 +7427,10 @@ Ember.String = {
   /**
     Returns the Capitalized form of a string
 
-    ```javascript
-    'innerHTML'.capitalize()         // 'InnerHTML'
-    'action_name'.capitalize()       // 'Action_name'
-    'css-class-name'.capitalize()    // 'Css-class-name'
-    'my favorite items'.capitalize() // 'My favorite items'
-    ```
+       'innerHTML'.capitalize()         // 'InnerHTML'
+       'action_name'.capitalize()       // 'Action_name'
+       'css-class-name'.capitalize()    // 'Css-class-name'
+       'my favorite items'.capitalize() // 'My favorite items'
 
     @method capitalize
     @param {String} str
@@ -8948,7 +8575,9 @@ Ember.Enumerable = Ember.Mixin.create({
 // HELPERS
 //
 
-var get = Ember.get, set = Ember.set, isNone = Ember.isNone, map = Ember.EnumerableUtils.map, cacheFor = Ember.cacheFor;
+var get = Ember.get, set = Ember.set, map = Ember.EnumerableUtils.map, cacheFor = Ember.cacheFor;
+
+function none(obj) { return obj===null || obj===undefined; }
 
 // ..........................................................
 // ARRAY
@@ -8971,7 +8600,7 @@ var get = Ember.get, set = Ember.set, isNone = Ember.isNone, map = Ember.Enumera
 
   You can use the methods defined in this module to access and modify array
   contents in a KVO-friendly way. You can also be notified whenever the
-  membership of an array changes by changing the syntax of the property to
+  membership if an array changes by changing the syntax of the property to
   `.observes('*myProperty.[]')`.
 
   To support `Ember.Array` in your own class, you must override two
@@ -8988,6 +8617,9 @@ var get = Ember.get, set = Ember.set, isNone = Ember.isNone, map = Ember.Enumera
 */
 Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.prototype */ {
 
+  // compatibility
+  isSCArray: true,
+
   /**
     Your array must support the `length` property. Your replace methods should
     set this property whenever it changes.
@@ -9095,8 +8727,8 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
   slice: function(beginIndex, endIndex) {
     var ret = Ember.A([]);
     var length = get(this, 'length') ;
-    if (isNone(beginIndex)) beginIndex = 0 ;
-    if (isNone(endIndex) || (endIndex > length)) endIndex = length ;
+    if (none(beginIndex)) beginIndex = 0 ;
+    if (none(endIndex) || (endIndex > length)) endIndex = length ;
 
     if (beginIndex < 0) beginIndex = length + beginIndex;
     if (endIndex < 0) endIndex = length + endIndex;
@@ -9256,7 +8888,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
     @param {Number} startIdx The starting index in the array that will change.
     @param {Number} removeAmt The number of items that will be removed. If you
       pass `null` assumes 0
-    @param {Number} addAmt The number of items that will be added. If you
+    @param {Number} addAmt The number of items that will be added  If you
       pass `null` assumes 0.
     @return {Ember.Array} receiver
   */
@@ -9290,20 +8922,6 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot
     return this;
   },
 
-  /**
-    If you are implementing an object that supports `Ember.Array`, call this
-    method just after the array content changes to notify any observers and
-    invalidate any related properties. Pass the starting index of the change
-    as well as a delta of the amounts to change.
-
-    @method arrayContentDidChange
-    @param {Number} startIdx The starting index in the array that did change.
-    @param {Number} removeAmt The number of items that were removed. If you
-      pass `null` assumes 0
-    @param {Number} addAmt The number of items that were added. If you
-      pass `null` assumes 0.
-    @return {Ember.Array} receiver
-  */
   arrayContentDidChange: function(startIdx, removeAmt, addAmt) {
 
     // if no args are passed assume everything changes
@@ -9444,7 +9062,8 @@ var get = Ember.get, set = Ember.set;
   @extends Ember.Mixin
   @since Ember 0.9
 */
-Ember.Copyable = Ember.Mixin.create(/** @scope Ember.Copyable.prototype */ {
+Ember.Copyable = Ember.Mixin.create(
+/** @scope Ember.Copyable.prototype */ {
 
   /**
     Override to return a copy of the receiver. Default implementation raises
@@ -9549,7 +9168,8 @@ var get = Ember.get, set = Ember.set;
   @extends Ember.Mixin
   @since Ember 0.9
 */
-Ember.Freezable = Ember.Mixin.create(/** @scope Ember.Freezable.prototype */ {
+Ember.Freezable = Ember.Mixin.create(
+/** @scope Ember.Freezable.prototype */ {
 
   /**
     Set to `true` when the object is frozen. Use this property to detect
@@ -9730,7 +9350,8 @@ var get = Ember.get, set = Ember.set;
   @uses Ember.Array
   @uses Ember.MutableEnumerable
 */
-Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/** @scope Ember.MutableArray.prototype */ {
+Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,
+  /** @scope Ember.MutableArray.prototype */ {
 
   /**
     __Required.__ You must implement this method to apply this mixin.
@@ -10001,6 +9622,7 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/**
 
 });
 
+
 })();
 
 
@@ -10048,7 +9670,7 @@ var get = Ember.get, set = Ember.set;
   For example:
 
   ```javascript
-  Ember.Object.extend({
+  Ember.Object.create({
     valueObserver: function() {
       // Executes whenever the "value" property changes
     }.observes('value')
@@ -10067,8 +9689,8 @@ var get = Ember.get, set = Ember.set;
   object.addObserver('propertyKey', targetObject, targetAction)
   ```
 
-  This will call the `targetAction` method on the `targetObject` whenever
-  the value of the `propertyKey` changes.
+  This will call the `targetAction` method on the `targetObject` to be called
+  whenever the value of the `propertyKey` changes.
 
   Note that if `propertyKey` is a computed property, the observer will be
   called when any of the property dependencies are changed, even if the
@@ -10328,8 +9950,8 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
 
     This is the core method used to register an observer for a property.
 
-    Once you call this method, any time the key's value is set, your observer
-    will be notified. Note that the observers are triggered any time the
+    Once you call this method, anytime the key's value is set, your observer
+    will be notified. Note that the observers are triggered anytime the
     value is set, regardless of whether it has actually changed. Your
     observer should be prepared to handle that.
 
@@ -10454,11 +10076,11 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
 
     @method incrementProperty
     @param {String} keyName The name of the property to increment
-    @param {Number} increment The amount to increment by. Defaults to 1
-    @return {Number} The new property value
+    @param {Object} increment The amount to increment by. Defaults to 1
+    @return {Object} The new property value
   */
   incrementProperty: function(keyName, increment) {
-    if (Ember.isNone(increment)) { increment = 1; }
+    if (!increment) { increment = 1; }
     set(this, keyName, (get(this, keyName) || 0)+increment);
     return get(this, keyName);
   },
@@ -10473,12 +10095,12 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
 
     @method decrementProperty
     @param {String} keyName The name of the property to decrement
-    @param {Number} decrement The amount to decrement by. Defaults to 1
-    @return {Number} The new property value
+    @param {Object} increment The amount to decrement by. Defaults to 1
+    @return {Object} The new property value
   */
-  decrementProperty: function(keyName, decrement) {
-    if (Ember.isNone(decrement)) { decrement = 1; }
-    set(this, keyName, (get(this, keyName) || 0)-decrement);
+  decrementProperty: function(keyName, increment) {
+    if (!increment) { increment = 1; }
+    set(this, keyName, (get(this, keyName) || 0)-increment);
     return get(this, keyName);
   },
 
@@ -10487,7 +10109,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
     current value.
 
     ```javascript
-    starship.toggleProperty('warpDriveEngaged');
+    starship.toggleProperty('warpDriveEnaged');
     ```
 
     @method toggleProperty
@@ -10519,6 +10141,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ {
   }
 });
 
+
 })();
 
 
@@ -10813,9 +10436,9 @@ Ember.Evented = Ember.Mixin.create({
 (function() {
 var RSVP = requireModule("rsvp");
 
-RSVP.configure('async', function(callback, binding) {
+RSVP.async = function(callback, binding) {
   Ember.run.schedule('actions', binding, callback);
-});
+};
 
 /**
 @module ember
@@ -10837,22 +10460,9 @@ Ember.DeferredMixin = Ember.Mixin.create({
     @param {Function} doneCallback a callback function to be called when done
     @param {Function} failCallback a callback function to be called when failed
   */
-  then: function(resolve, reject) {
-    var deferred, promise, entity;
-
-    entity = this;
-    deferred = get(this, '_deferred');
-    promise = deferred.promise;
-
-    function fulfillmentHandler(fulfillment) {
-      if (fulfillment === promise) {
-        return resolve(entity);
-      } else {
-        return resolve(fulfillment);
-      }
-    }
-
-    return promise.then(resolve && fulfillmentHandler, reject);
+  then: function(doneCallback, failCallback) {
+    var promise = get(this, 'promise');
+    return promise.then.apply(promise, arguments);
   },
 
   /**
@@ -10861,16 +10471,7 @@ Ember.DeferredMixin = Ember.Mixin.create({
     @method resolve
   */
   resolve: function(value) {
-    var deferred, promise;
-
-    deferred = get(this, '_deferred');
-    promise = deferred.promise;
-
-    if (value === this){
-      deferred.resolve(promise);
-    } else {
-      deferred.resolve(value);
-    }
+    get(this, 'promise').resolve(value);
   },
 
   /**
@@ -10879,11 +10480,11 @@ Ember.DeferredMixin = Ember.Mixin.create({
     @method reject
   */
   reject: function(value) {
-    get(this, '_deferred').reject(value);
+    get(this, 'promise').reject(value);
   },
 
-  _deferred: Ember.computed(function() {
-    return RSVP.defer();
+  promise: Ember.computed(function() {
+    return new RSVP.Promise();
   })
 });
 
@@ -11716,7 +11317,8 @@ var get = Ember.get, set = Ember.set;
   @extends Ember.Object
   @uses Ember.MutableArray
 */
-Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,/** @scope Ember.ArrayProxy.prototype */ {
+Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,
+/** @scope Ember.ArrayProxy.prototype */ {
 
   /**
     The content array. Must be an object that implements `Ember.Array` and/or
@@ -11992,6 +11594,7 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,/** @scope Ember.Array
   }
 });
 
+
 })();
 
 
@@ -12091,7 +11694,8 @@ function contentPropertyDidChange(content, contentKey) {
   @namespace Ember
   @extends Ember.Object
 */
-Ember.ObjectProxy = Ember.Object.extend(/** @scope Ember.ObjectProxy.prototype */ {
+Ember.ObjectProxy = Ember.Object.extend(
+/** @scope Ember.ObjectProxy.prototype */ {
   /**
     The object whose properties will be forwarded.
 
@@ -12529,7 +12133,7 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
 @submodule ember-runtime
 */
 
-var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, isNone = Ember.isNone, fmt = Ember.String.fmt;
+var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.isNone, fmt = Ember.String.fmt;
 
 /**
   An unordered collection of objects.
@@ -12887,7 +12491,7 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
   // implements Ember.MutableEnumerable
   addObject: function(obj) {
     if (get(this, 'isFrozen')) throw new Error(Ember.FROZEN_ERROR);
-    if (isNone(obj)) return this; // nothing to do
+    if (none(obj)) return this; // nothing to do
 
     var guid = guidFor(obj),
         idx  = this[guid],
@@ -12915,7 +12519,7 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb
   // implements Ember.MutableEnumerable
   removeObject: function(obj) {
     if (get(this, 'isFrozen')) throw new Error(Ember.FROZEN_ERROR);
-    if (isNone(obj)) return this; // nothing to do
+    if (none(obj)) return this; // nothing to do
 
     var guid = guidFor(obj),
         idx  = this[guid],
@@ -12990,7 +12594,7 @@ Deferred.reopenClass({
   promise: function(callback, binding) {
     var deferred = Deferred.create();
     callback.call(binding, deferred);
-    return deferred;
+    return get(deferred, 'promise');
   }
 });
 
@@ -13001,8 +12605,6 @@ Ember.Deferred = Deferred;
 
 
 (function() {
-var forEach = Ember.ArrayPolyfills.forEach;
-
 /**
 @module ember
 @submodule ember-runtime
@@ -13035,10 +12637,12 @@ Ember.onLoad = function(name, callback) {
 @param object {Object} object to pass to callbacks
 */
 Ember.runLoadHooks = function(name, object) {
+  var hooks;
+
   loaded[name] = object;
 
-  if (loadHooks[name]) {
-    forEach.call(loadHooks[name], function(callback) {
+  if (hooks = loadHooks[name]) {
+    loadHooks[name].forEach(function(callback) {
       callback(object);
     });
   }
@@ -13112,8 +12716,6 @@ Ember.ControllerMixin = Ember.Mixin.create({
 
   container: null,
 
-  parentController: null,
-
   store: null,
 
   model: Ember.computed.alias('content'),
@@ -13456,10 +13058,6 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach,
   });
   ```
 
-  The itemController instances will have a `parentController` property set to
-  either the the `parentController` property of the `ArrayController`
-  or to the `ArrayController` instance itself.
-
   @class ArrayController
   @namespace Ember
   @extends Ember.ArrayProxy
@@ -13570,7 +13168,6 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin,
     }
 
     subController.set('target', this);
-    subController.set('parentController', get(this, 'parentController') || this);
     subController.set('content', object);
 
     return subController;