ember-source 1.7.0.beta.2 → 1.7.0.beta.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0734bda9158778ba3f4a5cf4f152fb67ad244cc7
-  data.tar.gz: 1a0866dd50e5dbefadc602a69dc17f8d66f2f296
+  metadata.gz: f3a23b3e472e7ae1d208a987594fc5f5d7278e4c
+  data.tar.gz: 8536332708a96be3ceeaa9b81f5e3eaa2fb917db
 SHA512:
-  metadata.gz: 5605198d3801765d0c0e9a71266422c8fc182df558f3f801406635b200716537db4ee3aa5a461a57bde4fe5fead3b3e908f934edb2c0dee42bdb15c069f7f883
-  data.tar.gz: 2c7795fdf9280d563f1f8aa668dc8b45c7485762dccb6ec3d62f63729b0aa297e90241d5101459fb83876696f64ef67b1e6e4fa022af2a922f0d10a1ad964001
+  metadata.gz: d44ad2c29be490838c32a017ac2a71cbe77cb5ed8607c63a67d488cd370f0700eba93b306565cf86c1c353c4a8546a90dcef3c843cd8647ca4fc81190aad5037
+  data.tar.gz: 4b5289fab17a393f9e1dfb39f3ca82559d7173b0e68ca91c981b662ff855e06ca5aee0d4e876b00fee7234154b3663a6b190cf65b5eac039c2b66b468de6bd93

data/VERSION

@@ -1 +1 @@
-1.7.0-beta.2
+1.7.0-beta.3

data/dist/ember-runtime.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.7.0-beta.2
+ * @version   1.7.0-beta.3
  */
 
 (function() {
@@ -2155,19 +2155,20 @@ define("ember-metal",
     __exports__["default"] = Ember;
   });
 define("ember-metal/alias",
-  ["ember-metal/property_get","ember-metal/property_set","ember-metal/error","ember-metal/properties","ember-metal/platform","ember-metal/utils","ember-metal/dependent_keys","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+  ["ember-metal/property_get","ember-metal/property_set","ember-metal/error","ember-metal/properties","ember-metal/computed","ember-metal/platform","ember-metal/utils","ember-metal/dependent_keys","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
     "use strict";
     var get = __dependency1__.get;
     var set = __dependency2__.set;
     var EmberError = __dependency3__["default"];
     var Descriptor = __dependency4__.Descriptor;
     var defineProperty = __dependency4__.defineProperty;
-    var create = __dependency5__.create;
-    var meta = __dependency6__.meta;
-    var inspect = __dependency6__.inspect;
-    var addDependentKeys = __dependency7__.addDependentKeys;
-    var removeDependentKeys = __dependency7__.removeDependentKeys;
+    var ComputedProperty = __dependency5__.ComputedProperty;
+    var create = __dependency6__.create;
+    var meta = __dependency7__.meta;
+    var inspect = __dependency7__.inspect;
+    var addDependentKeys = __dependency8__.addDependentKeys;
+    var removeDependentKeys = __dependency8__.removeDependentKeys;
 
     function alias(altKey) {
       return new AliasedProperty(altKey);
@@ -2228,6 +2229,10 @@ define("ember-metal/alias",
       defineProperty(obj, keyName, null);
       return set(obj, keyName, value);
     }
+
+    // Backwards compatibility with Ember Data
+    AliasedProperty.prototype._meta = undefined;
+    AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
   });
 define("ember-metal/array",
   ["exports"],
@@ -2410,12 +2415,14 @@ define("ember-metal/binding",
     // BINDING
     //
 
-    var Binding = function(toPath, fromPath) {
+    function Binding(toPath, fromPath) {
       this._direction = 'fwd';
       this._from = fromPath;
       this._to   = toPath;
       this._directionMap = Map.create();
-    };
+      this._readyToSync = undefined;
+      this._oneWay = undefined;
+    }
 
     /**
     @class Binding
@@ -2679,7 +2686,6 @@ define("ember-metal/binding",
       }
 
     });
-
     /**
       An `Ember.Binding` connects the properties of two objects so that whenever
       the value of one property changes, the other property will be changed also.
@@ -3558,7 +3564,10 @@ define("ember-metal/computed",
       try {
 
         if (cacheable && cache[keyName] !== undefined) {
-          cachedValue = cache[keyName];
+          if(cache[keyName] !== UNDEFINED) {
+            cachedValue = cache[keyName];
+          }
+
           hadCachedValue = true;
         }
 
@@ -4436,7 +4445,7 @@ define("ember-metal/core",
 
       @class Ember
       @static
-      @version 1.7.0-beta.2
+      @version 1.7.0-beta.3
     */
 
     if ('undefined' === typeof Ember) {
@@ -4463,10 +4472,10 @@ define("ember-metal/core",
     /**
       @property VERSION
       @type String
-      @default '1.7.0-beta.2'
+      @default '1.7.0-beta.3'
       @static
     */
-    Ember.VERSION = '1.7.0-beta.2';
+    Ember.VERSION = '1.7.0-beta.3';
 
     /**
       Standard environmental variables. You can define these in a global `EmberENV`
@@ -8511,7 +8520,7 @@ define("ember-metal/run_loop",
       ```
 
       @method bind
-      @namespace run
+      @namespace Ember
       @param {Object} [target] target of method to call
       @param {Function|String} method Method to invoke.
         May be a function or a string. If you pass a string
@@ -9378,10 +9387,10 @@ define("ember-metal/utils",
     */
     function wrap(func, superFunc) {
       function superWrapper() {
-        var ret, sup = this.__nextSuper;
-        this.__nextSuper = superFunc;
+        var ret, sup = this && this.__nextSuper;
+        if(this) { this.__nextSuper = superFunc; }
         ret = apply(this, func, arguments);
-        this.__nextSuper = sup;
+        if(this) { this.__nextSuper = sup; }
         return ret;
       }
 
@@ -13477,7 +13486,7 @@ define("ember-runtime/mixins/array",
 
       /**
         This is the handler for the special array content property. If you get
-        this property, it will return this. If you set this property it a new
+        this property, it will return this. If you set this property to a new
         array, it will replace the current content.
 
         This property overrides the default property defined in `Ember.Enumerable`.
@@ -14137,6 +14146,8 @@ define("ember-runtime/mixins/deferred",
       },
 
       _deferred: computed(function() {
+        Ember.deprecate('Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.', this._suppressDeferredDeprecation);
+
         return RSVP.defer('Ember: DeferredMixin - ' + this);
       })
     });
@@ -15119,7 +15130,7 @@ define("ember-runtime/mixins/enumerable",
 
       /**
         Invoke this method when the contents of your enumerable has changed.
-        This will notify any observers watching for content changes. If your are
+        This will notify any observers watching for content changes. If you are
         implementing an ordered enumerable (such as an array), also pass the
         start and end values where the content changed so that it can be used to
         notify range observers.
@@ -16057,13 +16068,15 @@ define("ember-runtime/mixins/observable",
         with a list of strings or an array:
 
         ```javascript
-        record.getProperties('firstName', 'lastName', 'zipCode');  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+        record.getProperties('firstName', 'lastName', 'zipCode');
+        // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
         ```
 
         is equivalent to:
 
         ```javascript
-        record.getProperties(['firstName', 'lastName', 'zipCode']);  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+        record.getProperties(['firstName', 'lastName', 'zipCode']);
+        // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
         ```
 
         @method getProperties
@@ -17506,6 +17519,7 @@ define("ember-runtime/system/core_object",
     var finishPartial = Mixin.finishPartial;
     var reopen = Mixin.prototype.reopen;
     var MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER;
+    var hasCachedComputedProperties = false;
 
     var undefinedDescriptor = {
       configurable: true,
@@ -18201,6 +18215,26 @@ define("ember-runtime/system/core_object",
         return desc._meta || {};
       },
 
+      _computedProperties: Ember.computed(function() {
+        hasCachedComputedProperties = true;
+        var proto = this.proto();
+        var descs = meta(proto).descs;
+        var property;
+        var properties = [];
+
+        for (var name in descs) {
+          property = descs[name];
+
+          if (property instanceof ComputedProperty) {
+            properties.push({
+              name: name,
+              meta: property._meta
+            });
+          }
+        }
+        return properties;
+      }).readOnly(),
+
       /**
         Iterate over each computed property for the class, passing its name
         and any associated metadata (see `metaForProperty`) to the callback.
@@ -18210,17 +18244,15 @@ define("ember-runtime/system/core_object",
         @param {Object} binding
       */
       eachComputedProperty: function(callback, binding) {
-        var proto = this.proto(),
-            descs = meta(proto).descs,
-            empty = {},
-            property;
+        var property, name;
+        var empty = {};
 
-        for (var name in descs) {
-          property = descs[name];
+        var properties = get(this, '_computedProperties');
 
-          if (property instanceof ComputedProperty) {
-            callback.call(binding || this, name, property._meta || empty);
-          }
+        for (var i = 0, length = properties.length; i < length; i++) {
+          property = properties[i];
+          name = property.name;
+          callback.call(binding || this, property.name, property.meta || empty);
         }
       }
     });
@@ -18232,19 +18264,42 @@ define("ember-runtime/system/core_object",
     }
 
     CoreObject.ClassMixin = ClassMixin;
+
     ClassMixin.apply(CoreObject);
 
+    CoreObject.reopen({
+      didDefineProperty: function(proto, key, value) {
+        if (hasCachedComputedProperties === false) { return; }
+        if (value instanceof Ember.ComputedProperty) {
+          var cache = Ember.meta(this.constructor).cache;
+
+          if (cache._computedProperties !== undefined) {
+            cache._computedProperties = undefined;
+          }
+        }
+
+        this._super();
+      }
+    });
+
+
     __exports__["default"] = CoreObject;
   });
 define("ember-runtime/system/deferred",
-  ["ember-runtime/mixins/deferred","ember-metal/property_get","ember-runtime/system/object","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+  ["ember-metal/core","ember-runtime/mixins/deferred","ember-metal/property_get","ember-runtime/system/object","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
     "use strict";
-    var DeferredMixin = __dependency1__["default"];
-    var get = __dependency2__.get;
-    var EmberObject = __dependency3__["default"];
+    var Ember = __dependency1__["default"];
+    var DeferredMixin = __dependency2__["default"];
+    var get = __dependency3__.get;
+    var EmberObject = __dependency4__["default"];
 
-    var Deferred = EmberObject.extend(DeferredMixin);
+    var Deferred = EmberObject.extend(DeferredMixin, {
+      init: function() {
+        Ember.deprecate('Usage of Ember.Deferred is deprecated.');
+        this._super();
+      }
+    });
 
     Deferred.reopenClass({
       promise: function(callback, binding) {
@@ -18685,6 +18740,15 @@ define("ember-runtime/system/namespace",
 
     var STARTS_WITH_UPPERCASE = /^[A-Z]/;
 
+    function tryIsNamespace(lookup, prop) {
+      try {
+        var obj = lookup[prop];
+        return obj && obj.isNamespace && obj;
+      } catch (e) {
+        // continue
+      }
+    }
+
     function findNamespaces() {
       var lookup = Ember.lookup, obj, isNamespace;
 
@@ -18699,14 +18763,8 @@ define("ember-runtime/system/namespace",
 
         // At times we are not allowed to access certain properties for security reasons.
         // There are also times where even if we can access them, we are not allowed to access their properties.
-        try {
-          obj = lookup[prop];
-          isNamespace = obj && obj.isNamespace;
-        } catch (e) {
-          continue;
-        }
-
-        if (isNamespace) {
+        obj = tryIsNamespace(lookup, prop);
+        if (obj) {
           obj[NAME_KEY] = prop;
         }
       }

data/dist/ember-tests.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   1.7.0-beta.2
+ * @version   1.7.0-beta.3
  */
 
 (function() {
@@ -1255,6 +1255,18 @@ define("ember-application/tests/system/application_test",
 
       ok(app.__container__.lookup('router:main') instanceof CustomRouter, 'application resolved the correct router');
     });
+
+    test("throws helpful error if `app.then` is used", function() {
+      run(function() {
+        app = Application.create({
+          rootElement: '#qunit-fixture'
+        });
+      });
+
+      expectDeprecation(function() {
+        run(app, 'then', Ember.K);
+      }, /Do not use `.then` on an instance of Ember.Application.  Please use the `.ready` hook instead./);
+    });
   });
 define("ember-application/tests/system/application_test.jshint",
   [],
@@ -2209,9 +2221,8 @@ define("ember-application/tests/system/logging_test",
       run(App, 'advanceReadiness');
 
       visit('/posts').then(function() {
-        
-          equal(Ember.keys(logs).length, 8, 'expected logs');
-              });
+        equal(Ember.keys(logs).length, 6, 'expected logs');
+      });
     });
 
     test("do NOT log class generation if logging disabled", function() {
@@ -2433,57 +2444,37 @@ define("ember-application/tests/system/readiness_test",
     // it was triggered after initialization.
 
     test("Ember.Application's ready event is called right away if jQuery is already ready", function() {
-      var wasResolved = 0;
       jQuery.isReady = true;
 
       run(function() {
         application = Application.create({ router: false });
-        application.then(function() {
-          wasResolved++;
-        });
 
         equal(readyWasCalled, 0, "ready is not called until later");
-        equal(wasResolved, 0);
       });
 
-      equal(wasResolved, 1);
       equal(readyWasCalled, 1, "ready was called");
 
       domReady();
 
-      equal(wasResolved, 1);
       equal(readyWasCalled, 1, "application's ready was not called again");
     });
 
     test("Ember.Application's ready event is called after the document becomes ready", function() {
-      var wasResolved = 0;
       run(function() {
         application = Application.create({ router: false });
-        application.then(function() {
-          wasResolved++;
-        });
-        equal(wasResolved, 0);
       });
 
       equal(readyWasCalled, 0, "ready wasn't called yet");
-      equal(wasResolved, 0);
 
       domReady();
 
-      equal(wasResolved, 1);
       equal(readyWasCalled, 1, "ready was called now that DOM is ready");
     });
 
     test("Ember.Application's ready event can be deferred by other components", function() {
-      var wasResolved = 0;
-
       run(function() {
         application = Application.create({ router: false });
-        application.then(function() {
-          wasResolved++;
-        });
         application.deferReadiness();
-        equal(wasResolved, 0);
       });
 
       equal(readyWasCalled, 0, "ready wasn't called yet");
@@ -2491,29 +2482,22 @@ define("ember-application/tests/system/readiness_test",
       domReady();
 
       equal(readyWasCalled, 0, "ready wasn't called yet");
-      equal(wasResolved, 0);
 
       run(function() {
         application.advanceReadiness();
         equal(readyWasCalled, 0);
-        equal(wasResolved, 0);
       });
 
-      equal(wasResolved, 1);
       equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
     });
 
     test("Ember.Application's ready event can be deferred by other components", function() {
-      var wasResolved = 0;
       jQuery.isReady = false;
 
       run(function() {
         application = Application.create({ router: false });
         application.deferReadiness();
-        application.then(function() {
-          wasResolved++;
-        });
-        equal(wasResolved, 0);
+        equal(readyWasCalled, 0, "ready wasn't called yet");
       });
 
       domReady();
@@ -2522,10 +2506,8 @@ define("ember-application/tests/system/readiness_test",
 
       run(function() {
         application.advanceReadiness();
-        equal(wasResolved, 0);
       });
 
-      equal(wasResolved, 1);
       equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
 
       expectAssertion(function() {
@@ -2577,12 +2559,13 @@ define("ember-application/tests/system/reset_test",
 
     test("Brings it's own run-loop if not provided", function() {
       application = run(Application, 'create');
+      application.ready = function() {
+        QUnit.start();
+        ok(true, 'app booted');
+      };
 
+      QUnit.stop();
       application.reset();
-
-      run(application,'then', function() {
-        ok(true, 'app booted');
-      });
     });
 
     test("does not bring it's own run loop if one is already provided", function() {
@@ -4921,8 +4904,8 @@ define("ember-handlebars/tests/controls/text_area_test.jshint",
     });
   });
 define("ember-handlebars/tests/controls/text_field_test",
-  ["ember-metal/core","ember-metal/run_loop","ember-metal/property_get","ember-metal/property_set","ember-handlebars","ember-runtime/system/object","ember-views/views/view","ember-handlebars/controls/text_field"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
+  ["ember-metal/core","ember-metal/run_loop","ember-metal/property_get","ember-metal/property_set","ember-handlebars","ember-runtime/system/object","ember-views/views/view","ember-handlebars/controls/text_field","ember-views/system/event_dispatcher","ember-views/system/jquery"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__) {
     "use strict";
     /*globals TestObject:true */
 
@@ -4936,6 +4919,8 @@ define("ember-handlebars/tests/controls/text_field_test",
     var EmberObject = __dependency6__["default"];
     var View = __dependency7__["default"];
     var TextField = __dependency8__["default"];
+    var EventDispatcher = __dependency9__["default"];
+    var jQuery = __dependency10__["default"];
 
     var textField;
     var K = Ember.K;
@@ -5400,6 +5385,139 @@ define("ember-handlebars/tests/controls/text_field_test",
       textField.trigger('keyUp', event);
       equal(stopPropagationCount, 1, "propagation was prevented if bubbles is false");
     });
+
+
+    var dispatcher, StubController;
+    QUnit.module("Ember.TextField - Action events", {
+      setup: function() {
+
+        dispatcher = EventDispatcher.create();
+        dispatcher.setup();
+
+        StubController = EmberObject.extend({
+          send: function(actionName, value, sender) {
+            equal(actionName, 'doSomething', "text field sent correct action name");
+          }
+        });
+     
+      },
+     
+      teardown: function() {
+        run(function() {
+          dispatcher.destroy();
+
+          if (textField) {
+            textField.destroy();
+          }
+        });
+      }
+    });
+     
+    test("when the text field is blurred, the `focus-out` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'focus-out': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+
+      run(function() { 
+        textField.$().blur();
+      });
+
+    });
+
+    test("when the text field is focused, the `focus-in` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'focus-in': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+
+      run(function() { 
+        textField.$().focusin();
+      });
+
+
+    });
+
+    test("when the user presses a key, the `key-press` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'key-press': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+      
+      run(function() { 
+        var event = jQuery.Event("keypress");
+        event.keyCode = event.which = 13;
+        textField.$().trigger(event);
+      });
+
+    });
+
+    test("when the user inserts a new line, the `insert-newline` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'insert-newline': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+      
+      run(function() { 
+        var event = jQuery.Event("keyup");
+        event.keyCode = event.which = 13;
+        textField.$().trigger(event);
+      });
+
+    });
+
+
+    test("when the user presses the `enter` key, the `enter` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'enter': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+      
+      run(function() { 
+        var event = jQuery.Event("keyup");
+        event.keyCode = event.which = 13;
+        textField.$().trigger(event);
+      });
+
+    });
+
+    test("when the user hits escape, the `escape-press` action is sent to the controller", function() {
+      expect(1);
+
+      textField = TextField.create({
+        'escape-press': 'doSomething',
+        targetObject: StubController.create({})
+      });
+
+      append();
+      
+      run(function() { 
+        var event = jQuery.Event("keyup");
+        event.keyCode = event.which = 27;
+        textField.$().trigger(event);
+      });
+
+    });
   });
 define("ember-handlebars/tests/controls/text_field_test.jshint",
   [],
@@ -12428,6 +12546,53 @@ define("ember-handlebars/tests/views/collection_view_test.jshint",
       ok(true, 'ember-handlebars/tests/views/collection_view_test.js should pass jshint.'); 
     });
   });
+define("ember-handlebars/tests/views/handlebars_bound_view_test",
+  ["ember-handlebars/views/handlebars_bound_view"],
+  function(__dependency1__) {
+    "use strict";
+    var SimpleHandlebarsView = __dependency1__.SimpleHandlebarsView;
+
+    QUnit.module('SimpleHandlebarsView');
+
+    test('does not render if update is triggured by normalizedValue is the same as the previous normalizedValue', function(){
+      var html = null;
+      var path = 'foo';
+      var pathRoot = { 'foo': 'bar' };
+      var isEscaped = false;
+      var templateData;
+      var view = new SimpleHandlebarsView(path, pathRoot, isEscaped, templateData);
+
+      view.morph.html = function(newHTML) {
+        html = newHTML;
+      };
+
+      equal(html, null);
+
+      view.update();
+
+      equal(html, 'bar', 'expected call to morph.html with "bar"');
+      html = null;
+
+      view.update();
+
+      equal(html, null, 'expected no call to morph.html');
+
+      pathRoot.foo = 'baz'; // change property
+
+      view.update();
+
+      equal(html, 'baz', 'expected call to morph.html with "baz"');
+    });
+  });
+define("ember-handlebars/tests/views/handlebars_bound_view_test.jshint",
+  [],
+  function() {
+    "use strict";
+    module('JSHint - ember-handlebars/tests/views');
+    test('ember-handlebars/tests/views/handlebars_bound_view_test.js should pass jshint', function() { 
+      ok(true, 'ember-handlebars/tests/views/handlebars_bound_view_test.js should pass jshint.'); 
+    });
+  });
 define("ember-handlebars/tests/views/metamorph_view_test",
   ["ember-views/system/jquery","ember-metal/run_loop","ember-views/views/view","ember-metal/property_get","ember-metal/property_set","ember-metal/mixin","ember-handlebars-compiler","ember-handlebars/views/metamorph_view"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
@@ -14769,6 +14934,22 @@ define("ember-metal/tests/computed_test",
       ok('foo' in obj, 'foo in obj should pass');
     });
 
+    testBoth("when setting a value after it had been retrieved empty don't pass function UNDEFINED as oldValue", function(get, set) {
+        var obj = {}, oldValueIsNoFunction = true;
+
+        defineProperty(obj, 'foo', computed(function(key, value, oldValue) {
+            if(typeof oldValue === 'function') {
+                oldValueIsNoFunction = false;
+            }
+
+            return undefined;
+        }));
+
+        get(obj, 'foo');
+        set(obj, 'foo', undefined);
+
+        ok(oldValueIsNoFunction);
+    });
 
     QUnit.module('computed - setter');
 
@@ -24216,6 +24397,34 @@ define("ember-routing/tests/system/dsl_test",
         });
       }, "'basic' cannot be used as a resource name.");
     });
+
+    test("should reset namespace if nested with resource", function(){
+      var router = Router.map(function(){
+        this.resource('bleep', function(){
+          this.resource('bloop', function() {
+            this.resource('blork');
+          });
+        });
+      });
+
+      ok(router.recognizer.names['bleep'], 'nested resources do not contain parent name');
+      ok(router.recognizer.names['bloop'], 'nested resources do not contain parent name');
+      ok(router.recognizer.names['blork'], 'nested resources do not contain parent name');
+    });
+
+    test("should retain resource namespace if nested with routes", function(){
+      var router = Router.map(function(){
+        this.route('bleep', function(){
+          this.route('bloop', function() {
+            this.route('blork');
+          });
+        });
+      });
+
+      ok(router.recognizer.names['bleep'], 'parent name was used as base of nested routes');
+      ok(router.recognizer.names['bleep.bloop'], 'parent name was used as base of nested routes');
+      ok(router.recognizer.names['bleep.bloop.blork'], 'parent name was used as base of nested routes');
+    });
   });
 define("ember-routing/tests/system/dsl_test.jshint",
   [],
@@ -28750,6 +28959,8 @@ define("ember-runtime/tests/ext/rsvp_test",
   ["ember-metal/run_loop","ember-runtime/ext/rsvp"],
   function(__dependency1__, __dependency2__) {
     "use strict";
+    /* global Promise:true */
+
     var run = __dependency1__["default"];
     var RSVP = __dependency2__["default"];
 
@@ -28769,6 +28980,95 @@ define("ember-runtime/tests/ext/rsvp_test",
         equal(e, error, "error was re-thrown");
       }
     });
+
+    var asyncStarted = 0;
+    var asyncEnded = 0;
+    var Promise = RSVP.Promise;
+
+    var EmberTest;
+    var EmberTesting;
+
+    QUnit.module("Deferred RSVP's async + Testing", {
+      setup: function() {
+        EmberTest = Ember.Test;
+        EmberTesting = Ember.testing;
+
+        Ember.Test = {
+          adapter: {
+            asyncStart: function() {
+              asyncStarted++;
+              QUnit.stop();
+            },
+            asyncEnd: function() {
+              asyncEnded++;
+              QUnit.start();
+            }
+          }
+        };
+      },
+      teardown: function() {
+        asyncStarted = 0;
+        asyncEnded = 0;
+
+        Ember.testing = EmberTesting;
+        Ember.Test =  EmberTest;
+      }
+    });
+
+    test("given `Ember.testing = true`, correctly informs the test suite about async steps", function() {
+      expect(19);
+
+      ok(!run.currentRunLoop, 'expect no run-loop');
+
+      Ember.testing = true;
+
+      equal(asyncStarted, 0);
+      equal(asyncEnded, 0);
+
+      var user = Promise.resolve({
+        name: 'tomster'
+      });
+
+      equal(asyncStarted, 0);
+      equal(asyncEnded, 0);
+
+      user.then(function(user){
+        equal(asyncStarted, 1);
+        equal(asyncEnded, 1);
+
+        equal(user.name, 'tomster');
+
+        return Promise.resolve(1).then(function(){
+          equal(asyncStarted, 1);
+          equal(asyncEnded, 1);
+        });
+
+      }).then(function(){
+        equal(asyncStarted, 1);
+        equal(asyncEnded, 1);
+
+        return new Promise(function(resolve){
+          QUnit.stop(); // raw async, we must inform the test framework manually
+          setTimeout(function(){
+            QUnit.start(); // raw async, we must inform the test framework manually
+
+            equal(asyncStarted, 1);
+            equal(asyncEnded, 1);
+
+            resolve({
+              name: 'async tomster'
+            });
+
+            equal(asyncStarted, 2);
+            equal(asyncEnded, 1);
+          }, 0);
+        });
+      }).then(function(user){
+        equal(user.name, 'async tomster');
+        equal(asyncStarted, 2);
+        equal(asyncEnded, 2);
+      });
+    });
   });
 define("ember-runtime/tests/ext/rsvp_test.jshint",
   [],
@@ -31905,7 +32205,7 @@ define("ember-runtime/tests/mixins/deferred_test",
   ["ember-metal/core","ember-metal/run_loop","ember-runtime/system/object","ember-runtime/mixins/deferred","ember-runtime/ext/rsvp"],
   function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
     "use strict";
-    /* global Promise:true */
+    /* global Promise:true,EmberDev */
 
     var Ember = __dependency1__["default"];
     var run = __dependency2__["default"];
@@ -31913,7 +32213,18 @@ define("ember-runtime/tests/mixins/deferred_test",
     var Deferred = __dependency4__["default"];
     var RSVP = __dependency5__["default"];
 
-    QUnit.module("Deferred");
+    var originalDeprecate;
+
+    QUnit.module("Deferred", {
+      setup: function() {
+        originalDeprecate = Ember.deprecate;
+        Ember.deprecate = function() { };
+      },
+
+      teardown: function() {
+        Ember.deprecate = originalDeprecate;
+      }
+    });
 
     test("can resolve deferred", function() {
       var deferred, count = 0;
@@ -32227,94 +32538,25 @@ define("ember-runtime/tests/mixins/deferred_test",
       run(deferred, 'resolve', fulfillment);
     });
 
-    var asyncStarted = 0;
-    var asyncEnded = 0;
-    var Promise = RSVP.Promise;
-
-    var EmberTest;
-    var EmberTesting;
-
-    QUnit.module("Deferred RSVP's async + Testing", {
-      setup: function() {
-        EmberTest = Ember.Test;
-        EmberTesting = Ember.testing;
+    if (!EmberDev.runningProdBuild){
+      test("causes a deprecation warning when used", function() {
+        var deferred, deprecationMade, obj = {};
 
-        Ember.Test = {
-          adapter: {
-            asyncStart: function() {
-              asyncStarted++;
-              QUnit.stop();
-            },
-            asyncEnd: function() {
-              asyncEnded++;
-              QUnit.start();
-            }
-          }
+        Ember.deprecate = function(message) {
+          deprecationMade = message;
         };
-      },
-      teardown: function() {
-        asyncStarted = 0;
-        asyncEnded = 0;
-
-        Ember.testing = EmberTesting;
-        Ember.Test =  EmberTest;
-      }
-    });
 
-    test("given `Ember.testing = true`, correctly informs the test suite about async steps", function() {
-      expect(19);
-
-      ok(!run.currentRunLoop, 'expect no run-loop');
-
-      Ember.testing = true;
-
-      equal(asyncStarted, 0);
-      equal(asyncEnded, 0);
-
-      var user = Promise.resolve({
-        name: 'tomster'
-      });
-
-      equal(asyncStarted, 0);
-      equal(asyncEnded, 0);
-
-      user.then(function(user){
-        equal(asyncStarted, 1);
-        equal(asyncEnded, 1);
-
-        equal(user.name, 'tomster');
+        deferred = EmberObject.createWithMixins(Deferred);
+        equal(deprecationMade, undefined, 'no deprecation was made on init');
 
-        return Promise.resolve(1).then(function(){
-          equal(asyncStarted, 1);
-          equal(asyncEnded, 1);
+        deferred.then(function(value) {
+          equal(value, obj, "successfully resolved to given value");
         });
+        equal(deprecationMade, 'Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.');
 
-      }).then(function(){
-        equal(asyncStarted, 1);
-        equal(asyncEnded, 1);
-
-        return new Promise(function(resolve){
-          QUnit.stop(); // raw async, we must inform the test framework manually
-          setTimeout(function(){
-            QUnit.start(); // raw async, we must inform the test framework manually
-
-            equal(asyncStarted, 1);
-            equal(asyncEnded, 1);
-
-            resolve({
-              name: 'async tomster'
-            });
-
-            equal(asyncStarted, 2);
-            equal(asyncEnded, 1);
-          }, 0);
-        });
-      }).then(function(user){
-        equal(user.name, 'async tomster');
-        equal(asyncStarted, 2);
-        equal(asyncEnded, 2);
+        run(deferred, 'resolve', obj);
       });
-    });
+    }
   });
 define("ember-runtime/tests/mixins/deferred_test.jshint",
   [],
@@ -38246,30 +38488,34 @@ define("ember-runtime/tests/system/deferred_test",
     asyncTest("Can resolve a promise", function() {
       var value = { value: true };
 
-      var promise = Deferred.promise(function(deferred) {
-        setTimeout(function() {
-          run(function() { deferred.resolve(value); });
+      ignoreDeprecation(function() {
+        var promise = Deferred.promise(function(deferred) {
+          setTimeout(function() {
+            run(function() { deferred.resolve(value); });
+          });
         });
-      });
 
-      promise.then(function(resolveValue) {
-        QUnit.start();
-        equal(resolveValue, value, "The resolved value should be correct");
+        promise.then(function(resolveValue) {
+          QUnit.start();
+          equal(resolveValue, value, "The resolved value should be correct");
+        });
       });
     });
 
     asyncTest("Can reject a promise", function() {
       var rejected = { rejected: true };
 
-      var promise = Deferred.promise(function(deferred) {
-        setTimeout(function() {
-          run(function() { deferred.reject(rejected); });
+      ignoreDeprecation(function() {
+        var promise = Deferred.promise(function(deferred) {
+          setTimeout(function() {
+            run(function() { deferred.reject(rejected); });
+          });
         });
-      });
 
-      promise.then(null, function(rejectedValue) {
-        QUnit.start();
-        equal(rejectedValue, rejected, "The resolved value should be correct");
+        promise.then(null, function(rejectedValue) {
+          QUnit.start();
+          equal(rejectedValue, rejected, "The resolved value should be correct");
+        });
       });
     });
   });
@@ -38749,7 +38995,7 @@ define("ember-runtime/tests/system/object/computed_test",
       }, "metaForProperty() could not find a computed property with key 'staticProperty'.");
     });
 
-    testBoth("can iterate over a list of computed properties for a class", function(get, set) {
+    test("can iterate over a list of computed properties for a class", function() {
       var MyClass = EmberObject.extend({
         foo: computed(function() {
 
@@ -38798,6 +39044,40 @@ define("ember-runtime/tests/system/object/computed_test",
 
       deepEqual(list.sort(), ['bar', 'bat', 'baz', 'foo'], "all inherited properties are included");
     });
+
+    test("list of properties updates when an additional property is added (such cache busting)", function() {
+      var MyClass = EmberObject.extend({
+        foo: computed(Ember.K),
+
+        fooDidChange: observer('foo', function() {
+
+        }),
+
+        bar: computed(Ember.K)
+      });
+
+      var list = [];
+
+      MyClass.eachComputedProperty(function(name) {
+        list.push(name);
+      });
+
+      deepEqual(list.sort(), ['bar', 'foo'].sort(), 'expected two computed properties');
+
+      MyClass.reopen({
+        baz: computed(Ember.K)
+      });
+
+      MyClass.create(); // force apply mixins
+
+      list = [];
+
+      MyClass.eachComputedProperty(function(name) {
+        list.push(name);
+      });
+
+      deepEqual(list.sort(), ['bar', 'foo', 'baz'].sort(), 'expected three computed properties');
+    });
   });
 define("ember-runtime/tests/system/object/computed_test.jshint",
   [],
@@ -40014,6 +40294,50 @@ define("ember-runtime/tests/system/object/reopen_test.jshint",
       ok(true, 'ember-runtime/tests/system/object/reopen_test.js should pass jshint.'); 
     });
   });
+define("ember-runtime/tests/system/object/strict-mode-test",
+  ["ember-metal/core","ember-runtime/system/object"],
+  function(__dependency1__, __dependency2__) {
+    "use strict";
+    var Ember = __dependency1__["default"];
+    var EmberObject = __dependency2__["default"];
+
+    var originalLookup, lookup;
+
+    QUnit.module('strict mode tests');
+
+    test('__superWrapper does not throw errors in strict mode', function() {
+      var Foo = EmberObject.extend({
+        blah: function() {
+          return 'foo';
+        }
+      });
+
+      var Bar = Foo.extend({
+        blah: function() {
+          return 'bar';
+        },
+
+        callBlah: function() {
+          var blah = this.blah;
+
+          return blah();
+        }
+      });
+
+      var bar = Bar.create();
+
+      equal(bar.callBlah(), 'bar', 'can call local function without call/apply');
+    });
+  });
+define("ember-runtime/tests/system/object/strict-mode-test.jshint",
+  [],
+  function() {
+    "use strict";
+    module('JSHint - ember-runtime/tests/system/object');
+    test('ember-runtime/tests/system/object/strict-mode-test.js should pass jshint', function() { 
+      ok(true, 'ember-runtime/tests/system/object/strict-mode-test.js should pass jshint.'); 
+    });
+  });
 define("ember-runtime/tests/system/object/subclasses_test",
   ["ember-metal/run_loop","ember-metal/computed","ember-runtime/system/object"],
   function(__dependency1__, __dependency2__, __dependency3__) {
@@ -43371,9 +43695,11 @@ define("ember-views/tests/system/event_dispatcher_test",
       ok(!parentViewReceived, "parent view does not receive the event");
     });
 
-    test("should not interfere with event propagation", function() {
+    test('should not interfere with event propagation of virtualViews', function() {
       var receivedEvent;
-      view = View.create({
+
+      var view = View.create({
+        isVirtual: true,
         render: function(buffer) {
           buffer.push('<div id="propagate-test-div"></div>');
         }
@@ -43389,8 +43715,8 @@ define("ember-views/tests/system/event_dispatcher_test",
 
       jQuery('#propagate-test-div').click();
 
-      ok(receivedEvent, "allowed event to propagate outside Ember");
-      deepEqual(receivedEvent.target, jQuery('#propagate-test-div')[0], "target property is the element that was clicked");
+      ok(receivedEvent, 'allowed event to propagate');
+      deepEqual(receivedEvent && receivedEvent.target, jQuery('#propagate-test-div')[0], 'target property is the element that was clicked');
     });
 
     test("should dispatch events to nearest event manager", function() {
@@ -52737,16 +53063,16 @@ define("ember/tests/routing/basic_test",
         this.resource("special", { path: "/specials/:menu_item_id" });
       });
 
-      var menuItem;
+      var menuItem, resolve;
 
-      App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
+      App.MenuItem = Ember.Object.extend();
       App.MenuItem.reopenClass({
         find: function(id) {
-          menuItem = App.MenuItem.create({
-            id: id
-          });
+          menuItem = App.MenuItem.create({ id: id });
 
-          return menuItem;
+          return new Ember.RSVP.Promise(function(res) {
+            resolve = res;
+          });
         }
       });
 
@@ -52777,7 +53103,7 @@ define("ember/tests/routing/basic_test",
       equal(Ember.$('p', '#qunit-fixture').text(), "LOADING!", "The app is in the loading state");
 
       Ember.run(function() {
-        menuItem.resolve(menuItem);
+        resolve(menuItem);
       });
 
       equal(Ember.$('p', '#qunit-fixture').text(), "1", "The app is now in the specials state");
@@ -52867,13 +53193,17 @@ define("ember/tests/routing/basic_test",
         this.resource("special", { path: "/specials/:menu_item_id" });
       });
 
-      var menuItem;
+      var menuItem, promise, resolve;
 
-      App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
+      App.MenuItem = Ember.Object.extend();
       App.MenuItem.reopenClass({
         find: function(id) {
           menuItem = App.MenuItem.create({ id: id });
-          return menuItem;
+          promise = new Ember.RSVP.Promise(function(res) {
+            resolve = res;
+          });
+
+          return promise;
         }
       });
 
@@ -52892,7 +53222,9 @@ define("ember/tests/routing/basic_test",
 
       handleURLRejectsWith('/specials/1', 'Setup error');
 
-      Ember.run(menuItem, menuItem.resolve, menuItem);
+      Ember.run(function() {
+        resolve(menuItem);
+      });
     });
 
     function testOverridableErrorHandler(handlersName) {
@@ -52904,13 +53236,15 @@ define("ember/tests/routing/basic_test",
         this.resource("special", { path: "/specials/:menu_item_id" });
       });
 
-      var menuItem;
+      var menuItem, resolve;
 
-      App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
+      App.MenuItem = Ember.Object.extend();
       App.MenuItem.reopenClass({
         find: function(id) {
           menuItem = App.MenuItem.create({ id: id });
-          return menuItem;
+          return new Ember.RSVP.Promise(function(res) {
+            resolve = res;
+          });
         }
       });
 
@@ -52933,7 +53267,9 @@ define("ember/tests/routing/basic_test",
 
       handleURLRejectsWith("/specials/1", "Setup error");
 
-      Ember.run(menuItem, 'resolve', menuItem);
+      Ember.run(function() {
+        resolve(menuItem);
+      });
     }
 
     test("ApplicationRoute's default error handler can be overridden", function() {
@@ -52952,7 +53288,7 @@ define("ember/tests/routing/basic_test",
         this.resource("special", { path: "/specials/:menu_item_id" });
       });
 
-      App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
+      App.MenuItem = Ember.Object.extend();
 
       App.SpecialRoute = Ember.Route.extend({
         setupController: function(controller, model) {
@@ -52980,7 +53316,7 @@ define("ember/tests/routing/basic_test",
 
           var promiseContext = App.MenuItem.create({ id: 1 });
           Ember.run.later(function() {
-            promiseContext.resolve(promiseContext);
+            Ember.RSVP.resolve(promiseContext);
           }, 1);
 
           return router.transitionTo('special', promiseContext);
@@ -53006,9 +53342,9 @@ define("ember/tests/routing/basic_test",
         })
       });
 
-      var menuItem;
+      var menuItem, resolve;
 
-      App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
+      App.MenuItem = Ember.Object.extend();
       App.MenuItem.reopenClass({
         find: function(id) {
           menuItem = App.MenuItem.create({ id: id });
@@ -53078,7 +53414,9 @@ define("ember/tests/routing/basic_test",
 
       Ember.run(function() {
         var menuItem = App.MenuItem.create({ id: 1 });
-        Ember.run.later(function() { menuItem.resolve(menuItem); }, 1);
+        Ember.run.later(function() {
+          Ember.RSVP.resolve(menuItem);
+        }, 1);
 
         router.transitionTo('special', menuItem).then(function(result) {
           equal(rootSetup, 1, "The root setup was not triggered again");
@@ -53089,10 +53427,8 @@ define("ember/tests/routing/basic_test",
           equal(rootModel, 1, "The root model was called again");
 
           deepEqual(router.location.path, '/specials/1');
+          equal(currentPath, 'root.special');
 
-          
-            equal(currentPath, 'root.special.index');
-          
           QUnit.start();
         });
       });
@@ -55156,29 +55492,6 @@ define("ember/tests/routing/basic_test",
       });
     
 
-    
-      test("specifying no callback to `this.resources` still generates ", function() {
-        expect(1);
-
-        Router.map(function() {
-          this.resource("home");
-        });
-
-        var currentPath;
-
-        App.ApplicationController = Ember.Controller.extend({
-          currentPathDidChange: Ember.observer('currentPath', function() {
-            currentPath = get(this, 'currentPath');
-          })
-        });
-
-        bootApplication();
-
-        Ember.run(router, 'transitionTo', 'home');
-        equal(currentPath, 'home.index');
-      });
-    
-
     test("Errors in transitionTo within redirect hook are logged", function() {
       expect(2);
       var actual = [];