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

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 0734bda9158778ba3f4a5cf4f152fb67ad244cc7
4
- data.tar.gz: 1a0866dd50e5dbefadc602a69dc17f8d66f2f296
3
+ metadata.gz: f3a23b3e472e7ae1d208a987594fc5f5d7278e4c
4
+ data.tar.gz: 8536332708a96be3ceeaa9b81f5e3eaa2fb917db
5
5
  SHA512:
6
- metadata.gz: 5605198d3801765d0c0e9a71266422c8fc182df558f3f801406635b200716537db4ee3aa5a461a57bde4fe5fead3b3e908f934edb2c0dee42bdb15c069f7f883
7
- data.tar.gz: 2c7795fdf9280d563f1f8aa668dc8b45c7485762dccb6ec3d62f63729b0aa297e90241d5101459fb83876696f64ef67b1e6e4fa022af2a922f0d10a1ad964001
6
+ metadata.gz: d44ad2c29be490838c32a017ac2a71cbe77cb5ed8607c63a67d488cd370f0700eba93b306565cf86c1c353c4a8546a90dcef3c843cd8647ca4fc81190aad5037
7
+ data.tar.gz: 4b5289fab17a393f9e1dfb39f3ca82559d7173b0e68ca91c981b662ff855e06ca5aee0d4e876b00fee7234154b3663a6b190cf65b5eac039c2b66b468de6bd93
data/VERSION CHANGED
@@ -1 +1 @@
1
- 1.7.0-beta.2
1
+ 1.7.0-beta.3
@@ -5,7 +5,7 @@
5
5
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
6
6
  * @license Licensed under MIT license
7
7
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
8
- * @version 1.7.0-beta.2
8
+ * @version 1.7.0-beta.3
9
9
  */
10
10
 
11
11
  (function() {
@@ -2155,19 +2155,20 @@ define("ember-metal",
2155
2155
  __exports__["default"] = Ember;
2156
2156
  });
2157
2157
  define("ember-metal/alias",
2158
- ["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"],
2159
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
2158
+ ["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"],
2159
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
2160
2160
  "use strict";
2161
2161
  var get = __dependency1__.get;
2162
2162
  var set = __dependency2__.set;
2163
2163
  var EmberError = __dependency3__["default"];
2164
2164
  var Descriptor = __dependency4__.Descriptor;
2165
2165
  var defineProperty = __dependency4__.defineProperty;
2166
- var create = __dependency5__.create;
2167
- var meta = __dependency6__.meta;
2168
- var inspect = __dependency6__.inspect;
2169
- var addDependentKeys = __dependency7__.addDependentKeys;
2170
- var removeDependentKeys = __dependency7__.removeDependentKeys;
2166
+ var ComputedProperty = __dependency5__.ComputedProperty;
2167
+ var create = __dependency6__.create;
2168
+ var meta = __dependency7__.meta;
2169
+ var inspect = __dependency7__.inspect;
2170
+ var addDependentKeys = __dependency8__.addDependentKeys;
2171
+ var removeDependentKeys = __dependency8__.removeDependentKeys;
2171
2172
 
2172
2173
  function alias(altKey) {
2173
2174
  return new AliasedProperty(altKey);
@@ -2228,6 +2229,10 @@ define("ember-metal/alias",
2228
2229
  defineProperty(obj, keyName, null);
2229
2230
  return set(obj, keyName, value);
2230
2231
  }
2232
+
2233
+ // Backwards compatibility with Ember Data
2234
+ AliasedProperty.prototype._meta = undefined;
2235
+ AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
2231
2236
  });
2232
2237
  define("ember-metal/array",
2233
2238
  ["exports"],
@@ -2410,12 +2415,14 @@ define("ember-metal/binding",
2410
2415
  // BINDING
2411
2416
  //
2412
2417
 
2413
- var Binding = function(toPath, fromPath) {
2418
+ function Binding(toPath, fromPath) {
2414
2419
  this._direction = 'fwd';
2415
2420
  this._from = fromPath;
2416
2421
  this._to = toPath;
2417
2422
  this._directionMap = Map.create();
2418
- };
2423
+ this._readyToSync = undefined;
2424
+ this._oneWay = undefined;
2425
+ }
2419
2426
 
2420
2427
  /**
2421
2428
  @class Binding
@@ -2679,7 +2686,6 @@ define("ember-metal/binding",
2679
2686
  }
2680
2687
 
2681
2688
  });
2682
-
2683
2689
  /**
2684
2690
  An `Ember.Binding` connects the properties of two objects so that whenever
2685
2691
  the value of one property changes, the other property will be changed also.
@@ -3558,7 +3564,10 @@ define("ember-metal/computed",
3558
3564
  try {
3559
3565
 
3560
3566
  if (cacheable && cache[keyName] !== undefined) {
3561
- cachedValue = cache[keyName];
3567
+ if(cache[keyName] !== UNDEFINED) {
3568
+ cachedValue = cache[keyName];
3569
+ }
3570
+
3562
3571
  hadCachedValue = true;
3563
3572
  }
3564
3573
 
@@ -4436,7 +4445,7 @@ define("ember-metal/core",
4436
4445
 
4437
4446
  @class Ember
4438
4447
  @static
4439
- @version 1.7.0-beta.2
4448
+ @version 1.7.0-beta.3
4440
4449
  */
4441
4450
 
4442
4451
  if ('undefined' === typeof Ember) {
@@ -4463,10 +4472,10 @@ define("ember-metal/core",
4463
4472
  /**
4464
4473
  @property VERSION
4465
4474
  @type String
4466
- @default '1.7.0-beta.2'
4475
+ @default '1.7.0-beta.3'
4467
4476
  @static
4468
4477
  */
4469
- Ember.VERSION = '1.7.0-beta.2';
4478
+ Ember.VERSION = '1.7.0-beta.3';
4470
4479
 
4471
4480
  /**
4472
4481
  Standard environmental variables. You can define these in a global `EmberENV`
@@ -8511,7 +8520,7 @@ define("ember-metal/run_loop",
8511
8520
  ```
8512
8521
 
8513
8522
  @method bind
8514
- @namespace run
8523
+ @namespace Ember
8515
8524
  @param {Object} [target] target of method to call
8516
8525
  @param {Function|String} method Method to invoke.
8517
8526
  May be a function or a string. If you pass a string
@@ -9378,10 +9387,10 @@ define("ember-metal/utils",
9378
9387
  */
9379
9388
  function wrap(func, superFunc) {
9380
9389
  function superWrapper() {
9381
- var ret, sup = this.__nextSuper;
9382
- this.__nextSuper = superFunc;
9390
+ var ret, sup = this && this.__nextSuper;
9391
+ if(this) { this.__nextSuper = superFunc; }
9383
9392
  ret = apply(this, func, arguments);
9384
- this.__nextSuper = sup;
9393
+ if(this) { this.__nextSuper = sup; }
9385
9394
  return ret;
9386
9395
  }
9387
9396
 
@@ -13477,7 +13486,7 @@ define("ember-runtime/mixins/array",
13477
13486
 
13478
13487
  /**
13479
13488
  This is the handler for the special array content property. If you get
13480
- this property, it will return this. If you set this property it a new
13489
+ this property, it will return this. If you set this property to a new
13481
13490
  array, it will replace the current content.
13482
13491
 
13483
13492
  This property overrides the default property defined in `Ember.Enumerable`.
@@ -14137,6 +14146,8 @@ define("ember-runtime/mixins/deferred",
14137
14146
  },
14138
14147
 
14139
14148
  _deferred: computed(function() {
14149
+ Ember.deprecate('Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.', this._suppressDeferredDeprecation);
14150
+
14140
14151
  return RSVP.defer('Ember: DeferredMixin - ' + this);
14141
14152
  })
14142
14153
  });
@@ -15119,7 +15130,7 @@ define("ember-runtime/mixins/enumerable",
15119
15130
 
15120
15131
  /**
15121
15132
  Invoke this method when the contents of your enumerable has changed.
15122
- This will notify any observers watching for content changes. If your are
15133
+ This will notify any observers watching for content changes. If you are
15123
15134
  implementing an ordered enumerable (such as an array), also pass the
15124
15135
  start and end values where the content changed so that it can be used to
15125
15136
  notify range observers.
@@ -16057,13 +16068,15 @@ define("ember-runtime/mixins/observable",
16057
16068
  with a list of strings or an array:
16058
16069
 
16059
16070
  ```javascript
16060
- record.getProperties('firstName', 'lastName', 'zipCode'); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
16071
+ record.getProperties('firstName', 'lastName', 'zipCode');
16072
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
16061
16073
  ```
16062
16074
 
16063
16075
  is equivalent to:
16064
16076
 
16065
16077
  ```javascript
16066
- record.getProperties(['firstName', 'lastName', 'zipCode']); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
16078
+ record.getProperties(['firstName', 'lastName', 'zipCode']);
16079
+ // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
16067
16080
  ```
16068
16081
 
16069
16082
  @method getProperties
@@ -17506,6 +17519,7 @@ define("ember-runtime/system/core_object",
17506
17519
  var finishPartial = Mixin.finishPartial;
17507
17520
  var reopen = Mixin.prototype.reopen;
17508
17521
  var MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER;
17522
+ var hasCachedComputedProperties = false;
17509
17523
 
17510
17524
  var undefinedDescriptor = {
17511
17525
  configurable: true,
@@ -18201,6 +18215,26 @@ define("ember-runtime/system/core_object",
18201
18215
  return desc._meta || {};
18202
18216
  },
18203
18217
 
18218
+ _computedProperties: Ember.computed(function() {
18219
+ hasCachedComputedProperties = true;
18220
+ var proto = this.proto();
18221
+ var descs = meta(proto).descs;
18222
+ var property;
18223
+ var properties = [];
18224
+
18225
+ for (var name in descs) {
18226
+ property = descs[name];
18227
+
18228
+ if (property instanceof ComputedProperty) {
18229
+ properties.push({
18230
+ name: name,
18231
+ meta: property._meta
18232
+ });
18233
+ }
18234
+ }
18235
+ return properties;
18236
+ }).readOnly(),
18237
+
18204
18238
  /**
18205
18239
  Iterate over each computed property for the class, passing its name
18206
18240
  and any associated metadata (see `metaForProperty`) to the callback.
@@ -18210,17 +18244,15 @@ define("ember-runtime/system/core_object",
18210
18244
  @param {Object} binding
18211
18245
  */
18212
18246
  eachComputedProperty: function(callback, binding) {
18213
- var proto = this.proto(),
18214
- descs = meta(proto).descs,
18215
- empty = {},
18216
- property;
18247
+ var property, name;
18248
+ var empty = {};
18217
18249
 
18218
- for (var name in descs) {
18219
- property = descs[name];
18250
+ var properties = get(this, '_computedProperties');
18220
18251
 
18221
- if (property instanceof ComputedProperty) {
18222
- callback.call(binding || this, name, property._meta || empty);
18223
- }
18252
+ for (var i = 0, length = properties.length; i < length; i++) {
18253
+ property = properties[i];
18254
+ name = property.name;
18255
+ callback.call(binding || this, property.name, property.meta || empty);
18224
18256
  }
18225
18257
  }
18226
18258
  });
@@ -18232,19 +18264,42 @@ define("ember-runtime/system/core_object",
18232
18264
  }
18233
18265
 
18234
18266
  CoreObject.ClassMixin = ClassMixin;
18267
+
18235
18268
  ClassMixin.apply(CoreObject);
18236
18269
 
18270
+ CoreObject.reopen({
18271
+ didDefineProperty: function(proto, key, value) {
18272
+ if (hasCachedComputedProperties === false) { return; }
18273
+ if (value instanceof Ember.ComputedProperty) {
18274
+ var cache = Ember.meta(this.constructor).cache;
18275
+
18276
+ if (cache._computedProperties !== undefined) {
18277
+ cache._computedProperties = undefined;
18278
+ }
18279
+ }
18280
+
18281
+ this._super();
18282
+ }
18283
+ });
18284
+
18285
+
18237
18286
  __exports__["default"] = CoreObject;
18238
18287
  });
18239
18288
  define("ember-runtime/system/deferred",
18240
- ["ember-runtime/mixins/deferred","ember-metal/property_get","ember-runtime/system/object","exports"],
18241
- function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
18289
+ ["ember-metal/core","ember-runtime/mixins/deferred","ember-metal/property_get","ember-runtime/system/object","exports"],
18290
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
18242
18291
  "use strict";
18243
- var DeferredMixin = __dependency1__["default"];
18244
- var get = __dependency2__.get;
18245
- var EmberObject = __dependency3__["default"];
18292
+ var Ember = __dependency1__["default"];
18293
+ var DeferredMixin = __dependency2__["default"];
18294
+ var get = __dependency3__.get;
18295
+ var EmberObject = __dependency4__["default"];
18246
18296
 
18247
- var Deferred = EmberObject.extend(DeferredMixin);
18297
+ var Deferred = EmberObject.extend(DeferredMixin, {
18298
+ init: function() {
18299
+ Ember.deprecate('Usage of Ember.Deferred is deprecated.');
18300
+ this._super();
18301
+ }
18302
+ });
18248
18303
 
18249
18304
  Deferred.reopenClass({
18250
18305
  promise: function(callback, binding) {
@@ -18685,6 +18740,15 @@ define("ember-runtime/system/namespace",
18685
18740
 
18686
18741
  var STARTS_WITH_UPPERCASE = /^[A-Z]/;
18687
18742
 
18743
+ function tryIsNamespace(lookup, prop) {
18744
+ try {
18745
+ var obj = lookup[prop];
18746
+ return obj && obj.isNamespace && obj;
18747
+ } catch (e) {
18748
+ // continue
18749
+ }
18750
+ }
18751
+
18688
18752
  function findNamespaces() {
18689
18753
  var lookup = Ember.lookup, obj, isNamespace;
18690
18754
 
@@ -18699,14 +18763,8 @@ define("ember-runtime/system/namespace",
18699
18763
 
18700
18764
  // At times we are not allowed to access certain properties for security reasons.
18701
18765
  // There are also times where even if we can access them, we are not allowed to access their properties.
18702
- try {
18703
- obj = lookup[prop];
18704
- isNamespace = obj && obj.isNamespace;
18705
- } catch (e) {
18706
- continue;
18707
- }
18708
-
18709
- if (isNamespace) {
18766
+ obj = tryIsNamespace(lookup, prop);
18767
+ if (obj) {
18710
18768
  obj[NAME_KEY] = prop;
18711
18769
  }
18712
18770
  }
@@ -5,7 +5,7 @@
5
5
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
6
6
  * @license Licensed under MIT license
7
7
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
8
- * @version 1.7.0-beta.2
8
+ * @version 1.7.0-beta.3
9
9
  */
10
10
 
11
11
  (function() {
@@ -1255,6 +1255,18 @@ define("ember-application/tests/system/application_test",
1255
1255
 
1256
1256
  ok(app.__container__.lookup('router:main') instanceof CustomRouter, 'application resolved the correct router');
1257
1257
  });
1258
+
1259
+ test("throws helpful error if `app.then` is used", function() {
1260
+ run(function() {
1261
+ app = Application.create({
1262
+ rootElement: '#qunit-fixture'
1263
+ });
1264
+ });
1265
+
1266
+ expectDeprecation(function() {
1267
+ run(app, 'then', Ember.K);
1268
+ }, /Do not use `.then` on an instance of Ember.Application. Please use the `.ready` hook instead./);
1269
+ });
1258
1270
  });
1259
1271
  define("ember-application/tests/system/application_test.jshint",
1260
1272
  [],
@@ -2209,9 +2221,8 @@ define("ember-application/tests/system/logging_test",
2209
2221
  run(App, 'advanceReadiness');
2210
2222
 
2211
2223
  visit('/posts').then(function() {
2212
-
2213
- equal(Ember.keys(logs).length, 8, 'expected logs');
2214
- });
2224
+ equal(Ember.keys(logs).length, 6, 'expected logs');
2225
+ });
2215
2226
  });
2216
2227
 
2217
2228
  test("do NOT log class generation if logging disabled", function() {
@@ -2433,57 +2444,37 @@ define("ember-application/tests/system/readiness_test",
2433
2444
  // it was triggered after initialization.
2434
2445
 
2435
2446
  test("Ember.Application's ready event is called right away if jQuery is already ready", function() {
2436
- var wasResolved = 0;
2437
2447
  jQuery.isReady = true;
2438
2448
 
2439
2449
  run(function() {
2440
2450
  application = Application.create({ router: false });
2441
- application.then(function() {
2442
- wasResolved++;
2443
- });
2444
2451
 
2445
2452
  equal(readyWasCalled, 0, "ready is not called until later");
2446
- equal(wasResolved, 0);
2447
2453
  });
2448
2454
 
2449
- equal(wasResolved, 1);
2450
2455
  equal(readyWasCalled, 1, "ready was called");
2451
2456
 
2452
2457
  domReady();
2453
2458
 
2454
- equal(wasResolved, 1);
2455
2459
  equal(readyWasCalled, 1, "application's ready was not called again");
2456
2460
  });
2457
2461
 
2458
2462
  test("Ember.Application's ready event is called after the document becomes ready", function() {
2459
- var wasResolved = 0;
2460
2463
  run(function() {
2461
2464
  application = Application.create({ router: false });
2462
- application.then(function() {
2463
- wasResolved++;
2464
- });
2465
- equal(wasResolved, 0);
2466
2465
  });
2467
2466
 
2468
2467
  equal(readyWasCalled, 0, "ready wasn't called yet");
2469
- equal(wasResolved, 0);
2470
2468
 
2471
2469
  domReady();
2472
2470
 
2473
- equal(wasResolved, 1);
2474
2471
  equal(readyWasCalled, 1, "ready was called now that DOM is ready");
2475
2472
  });
2476
2473
 
2477
2474
  test("Ember.Application's ready event can be deferred by other components", function() {
2478
- var wasResolved = 0;
2479
-
2480
2475
  run(function() {
2481
2476
  application = Application.create({ router: false });
2482
- application.then(function() {
2483
- wasResolved++;
2484
- });
2485
2477
  application.deferReadiness();
2486
- equal(wasResolved, 0);
2487
2478
  });
2488
2479
 
2489
2480
  equal(readyWasCalled, 0, "ready wasn't called yet");
@@ -2491,29 +2482,22 @@ define("ember-application/tests/system/readiness_test",
2491
2482
  domReady();
2492
2483
 
2493
2484
  equal(readyWasCalled, 0, "ready wasn't called yet");
2494
- equal(wasResolved, 0);
2495
2485
 
2496
2486
  run(function() {
2497
2487
  application.advanceReadiness();
2498
2488
  equal(readyWasCalled, 0);
2499
- equal(wasResolved, 0);
2500
2489
  });
2501
2490
 
2502
- equal(wasResolved, 1);
2503
2491
  equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
2504
2492
  });
2505
2493
 
2506
2494
  test("Ember.Application's ready event can be deferred by other components", function() {
2507
- var wasResolved = 0;
2508
2495
  jQuery.isReady = false;
2509
2496
 
2510
2497
  run(function() {
2511
2498
  application = Application.create({ router: false });
2512
2499
  application.deferReadiness();
2513
- application.then(function() {
2514
- wasResolved++;
2515
- });
2516
- equal(wasResolved, 0);
2500
+ equal(readyWasCalled, 0, "ready wasn't called yet");
2517
2501
  });
2518
2502
 
2519
2503
  domReady();
@@ -2522,10 +2506,8 @@ define("ember-application/tests/system/readiness_test",
2522
2506
 
2523
2507
  run(function() {
2524
2508
  application.advanceReadiness();
2525
- equal(wasResolved, 0);
2526
2509
  });
2527
2510
 
2528
- equal(wasResolved, 1);
2529
2511
  equal(readyWasCalled, 1, "ready was called now all readiness deferrals are advanced");
2530
2512
 
2531
2513
  expectAssertion(function() {
@@ -2577,12 +2559,13 @@ define("ember-application/tests/system/reset_test",
2577
2559
 
2578
2560
  test("Brings it's own run-loop if not provided", function() {
2579
2561
  application = run(Application, 'create');
2562
+ application.ready = function() {
2563
+ QUnit.start();
2564
+ ok(true, 'app booted');
2565
+ };
2580
2566
 
2567
+ QUnit.stop();
2581
2568
  application.reset();
2582
-
2583
- run(application,'then', function() {
2584
- ok(true, 'app booted');
2585
- });
2586
2569
  });
2587
2570
 
2588
2571
  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",
4921
4904
  });
4922
4905
  });
4923
4906
  define("ember-handlebars/tests/controls/text_field_test",
4924
- ["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"],
4925
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
4907
+ ["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"],
4908
+ function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__) {
4926
4909
  "use strict";
4927
4910
  /*globals TestObject:true */
4928
4911
 
@@ -4936,6 +4919,8 @@ define("ember-handlebars/tests/controls/text_field_test",
4936
4919
  var EmberObject = __dependency6__["default"];
4937
4920
  var View = __dependency7__["default"];
4938
4921
  var TextField = __dependency8__["default"];
4922
+ var EventDispatcher = __dependency9__["default"];
4923
+ var jQuery = __dependency10__["default"];
4939
4924
 
4940
4925
  var textField;
4941
4926
  var K = Ember.K;
@@ -5400,6 +5385,139 @@ define("ember-handlebars/tests/controls/text_field_test",
5400
5385
  textField.trigger('keyUp', event);
5401
5386
  equal(stopPropagationCount, 1, "propagation was prevented if bubbles is false");
5402
5387
  });
5388
+
5389
+
5390
+ var dispatcher, StubController;
5391
+ QUnit.module("Ember.TextField - Action events", {
5392
+ setup: function() {
5393
+
5394
+ dispatcher = EventDispatcher.create();
5395
+ dispatcher.setup();
5396
+
5397
+ StubController = EmberObject.extend({
5398
+ send: function(actionName, value, sender) {
5399
+ equal(actionName, 'doSomething', "text field sent correct action name");
5400
+ }
5401
+ });
5402
+
5403
+ },
5404
+
5405
+ teardown: function() {
5406
+ run(function() {
5407
+ dispatcher.destroy();
5408
+
5409
+ if (textField) {
5410
+ textField.destroy();
5411
+ }
5412
+ });
5413
+ }
5414
+ });
5415
+
5416
+ test("when the text field is blurred, the `focus-out` action is sent to the controller", function() {
5417
+ expect(1);
5418
+
5419
+ textField = TextField.create({
5420
+ 'focus-out': 'doSomething',
5421
+ targetObject: StubController.create({})
5422
+ });
5423
+
5424
+ append();
5425
+
5426
+ run(function() {
5427
+ textField.$().blur();
5428
+ });
5429
+
5430
+ });
5431
+
5432
+ test("when the text field is focused, the `focus-in` action is sent to the controller", function() {
5433
+ expect(1);
5434
+
5435
+ textField = TextField.create({
5436
+ 'focus-in': 'doSomething',
5437
+ targetObject: StubController.create({})
5438
+ });
5439
+
5440
+ append();
5441
+
5442
+ run(function() {
5443
+ textField.$().focusin();
5444
+ });
5445
+
5446
+
5447
+ });
5448
+
5449
+ test("when the user presses a key, the `key-press` action is sent to the controller", function() {
5450
+ expect(1);
5451
+
5452
+ textField = TextField.create({
5453
+ 'key-press': 'doSomething',
5454
+ targetObject: StubController.create({})
5455
+ });
5456
+
5457
+ append();
5458
+
5459
+ run(function() {
5460
+ var event = jQuery.Event("keypress");
5461
+ event.keyCode = event.which = 13;
5462
+ textField.$().trigger(event);
5463
+ });
5464
+
5465
+ });
5466
+
5467
+ test("when the user inserts a new line, the `insert-newline` action is sent to the controller", function() {
5468
+ expect(1);
5469
+
5470
+ textField = TextField.create({
5471
+ 'insert-newline': 'doSomething',
5472
+ targetObject: StubController.create({})
5473
+ });
5474
+
5475
+ append();
5476
+
5477
+ run(function() {
5478
+ var event = jQuery.Event("keyup");
5479
+ event.keyCode = event.which = 13;
5480
+ textField.$().trigger(event);
5481
+ });
5482
+
5483
+ });
5484
+
5485
+
5486
+ test("when the user presses the `enter` key, the `enter` action is sent to the controller", function() {
5487
+ expect(1);
5488
+
5489
+ textField = TextField.create({
5490
+ 'enter': 'doSomething',
5491
+ targetObject: StubController.create({})
5492
+ });
5493
+
5494
+ append();
5495
+
5496
+ run(function() {
5497
+ var event = jQuery.Event("keyup");
5498
+ event.keyCode = event.which = 13;
5499
+ textField.$().trigger(event);
5500
+ });
5501
+
5502
+ });
5503
+
5504
+ test("when the user hits escape, the `escape-press` action is sent to the controller", function() {
5505
+ expect(1);
5506
+
5507
+ textField = TextField.create({
5508
+ 'escape-press': 'doSomething',
5509
+ targetObject: StubController.create({})
5510
+ });
5511
+
5512
+ append();
5513
+
5514
+ run(function() {
5515
+ var event = jQuery.Event("keyup");
5516
+ event.keyCode = event.which = 27;
5517
+ textField.$().trigger(event);
5518
+ });
5519
+
5520
+ });
5403
5521
  });
5404
5522
  define("ember-handlebars/tests/controls/text_field_test.jshint",
5405
5523
  [],
@@ -12428,6 +12546,53 @@ define("ember-handlebars/tests/views/collection_view_test.jshint",
12428
12546
  ok(true, 'ember-handlebars/tests/views/collection_view_test.js should pass jshint.');
12429
12547
  });
12430
12548
  });
12549
+ define("ember-handlebars/tests/views/handlebars_bound_view_test",
12550
+ ["ember-handlebars/views/handlebars_bound_view"],
12551
+ function(__dependency1__) {
12552
+ "use strict";
12553
+ var SimpleHandlebarsView = __dependency1__.SimpleHandlebarsView;
12554
+
12555
+ QUnit.module('SimpleHandlebarsView');
12556
+
12557
+ test('does not render if update is triggured by normalizedValue is the same as the previous normalizedValue', function(){
12558
+ var html = null;
12559
+ var path = 'foo';
12560
+ var pathRoot = { 'foo': 'bar' };
12561
+ var isEscaped = false;
12562
+ var templateData;
12563
+ var view = new SimpleHandlebarsView(path, pathRoot, isEscaped, templateData);
12564
+
12565
+ view.morph.html = function(newHTML) {
12566
+ html = newHTML;
12567
+ };
12568
+
12569
+ equal(html, null);
12570
+
12571
+ view.update();
12572
+
12573
+ equal(html, 'bar', 'expected call to morph.html with "bar"');
12574
+ html = null;
12575
+
12576
+ view.update();
12577
+
12578
+ equal(html, null, 'expected no call to morph.html');
12579
+
12580
+ pathRoot.foo = 'baz'; // change property
12581
+
12582
+ view.update();
12583
+
12584
+ equal(html, 'baz', 'expected call to morph.html with "baz"');
12585
+ });
12586
+ });
12587
+ define("ember-handlebars/tests/views/handlebars_bound_view_test.jshint",
12588
+ [],
12589
+ function() {
12590
+ "use strict";
12591
+ module('JSHint - ember-handlebars/tests/views');
12592
+ test('ember-handlebars/tests/views/handlebars_bound_view_test.js should pass jshint', function() {
12593
+ ok(true, 'ember-handlebars/tests/views/handlebars_bound_view_test.js should pass jshint.');
12594
+ });
12595
+ });
12431
12596
  define("ember-handlebars/tests/views/metamorph_view_test",
12432
12597
  ["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"],
12433
12598
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__) {
@@ -14769,6 +14934,22 @@ define("ember-metal/tests/computed_test",
14769
14934
  ok('foo' in obj, 'foo in obj should pass');
14770
14935
  });
14771
14936
 
14937
+ testBoth("when setting a value after it had been retrieved empty don't pass function UNDEFINED as oldValue", function(get, set) {
14938
+ var obj = {}, oldValueIsNoFunction = true;
14939
+
14940
+ defineProperty(obj, 'foo', computed(function(key, value, oldValue) {
14941
+ if(typeof oldValue === 'function') {
14942
+ oldValueIsNoFunction = false;
14943
+ }
14944
+
14945
+ return undefined;
14946
+ }));
14947
+
14948
+ get(obj, 'foo');
14949
+ set(obj, 'foo', undefined);
14950
+
14951
+ ok(oldValueIsNoFunction);
14952
+ });
14772
14953
 
14773
14954
  QUnit.module('computed - setter');
14774
14955
 
@@ -24216,6 +24397,34 @@ define("ember-routing/tests/system/dsl_test",
24216
24397
  });
24217
24398
  }, "'basic' cannot be used as a resource name.");
24218
24399
  });
24400
+
24401
+ test("should reset namespace if nested with resource", function(){
24402
+ var router = Router.map(function(){
24403
+ this.resource('bleep', function(){
24404
+ this.resource('bloop', function() {
24405
+ this.resource('blork');
24406
+ });
24407
+ });
24408
+ });
24409
+
24410
+ ok(router.recognizer.names['bleep'], 'nested resources do not contain parent name');
24411
+ ok(router.recognizer.names['bloop'], 'nested resources do not contain parent name');
24412
+ ok(router.recognizer.names['blork'], 'nested resources do not contain parent name');
24413
+ });
24414
+
24415
+ test("should retain resource namespace if nested with routes", function(){
24416
+ var router = Router.map(function(){
24417
+ this.route('bleep', function(){
24418
+ this.route('bloop', function() {
24419
+ this.route('blork');
24420
+ });
24421
+ });
24422
+ });
24423
+
24424
+ ok(router.recognizer.names['bleep'], 'parent name was used as base of nested routes');
24425
+ ok(router.recognizer.names['bleep.bloop'], 'parent name was used as base of nested routes');
24426
+ ok(router.recognizer.names['bleep.bloop.blork'], 'parent name was used as base of nested routes');
24427
+ });
24219
24428
  });
24220
24429
  define("ember-routing/tests/system/dsl_test.jshint",
24221
24430
  [],
@@ -28750,6 +28959,8 @@ define("ember-runtime/tests/ext/rsvp_test",
28750
28959
  ["ember-metal/run_loop","ember-runtime/ext/rsvp"],
28751
28960
  function(__dependency1__, __dependency2__) {
28752
28961
  "use strict";
28962
+ /* global Promise:true */
28963
+
28753
28964
  var run = __dependency1__["default"];
28754
28965
  var RSVP = __dependency2__["default"];
28755
28966
 
@@ -28769,6 +28980,95 @@ define("ember-runtime/tests/ext/rsvp_test",
28769
28980
  equal(e, error, "error was re-thrown");
28770
28981
  }
28771
28982
  });
28983
+
28984
+ var asyncStarted = 0;
28985
+ var asyncEnded = 0;
28986
+ var Promise = RSVP.Promise;
28987
+
28988
+ var EmberTest;
28989
+ var EmberTesting;
28990
+
28991
+ QUnit.module("Deferred RSVP's async + Testing", {
28992
+ setup: function() {
28993
+ EmberTest = Ember.Test;
28994
+ EmberTesting = Ember.testing;
28995
+
28996
+ Ember.Test = {
28997
+ adapter: {
28998
+ asyncStart: function() {
28999
+ asyncStarted++;
29000
+ QUnit.stop();
29001
+ },
29002
+ asyncEnd: function() {
29003
+ asyncEnded++;
29004
+ QUnit.start();
29005
+ }
29006
+ }
29007
+ };
29008
+ },
29009
+ teardown: function() {
29010
+ asyncStarted = 0;
29011
+ asyncEnded = 0;
29012
+
29013
+ Ember.testing = EmberTesting;
29014
+ Ember.Test = EmberTest;
29015
+ }
29016
+ });
29017
+
29018
+ test("given `Ember.testing = true`, correctly informs the test suite about async steps", function() {
29019
+ expect(19);
29020
+
29021
+ ok(!run.currentRunLoop, 'expect no run-loop');
29022
+
29023
+ Ember.testing = true;
29024
+
29025
+ equal(asyncStarted, 0);
29026
+ equal(asyncEnded, 0);
29027
+
29028
+ var user = Promise.resolve({
29029
+ name: 'tomster'
29030
+ });
29031
+
29032
+ equal(asyncStarted, 0);
29033
+ equal(asyncEnded, 0);
29034
+
29035
+ user.then(function(user){
29036
+ equal(asyncStarted, 1);
29037
+ equal(asyncEnded, 1);
29038
+
29039
+ equal(user.name, 'tomster');
29040
+
29041
+ return Promise.resolve(1).then(function(){
29042
+ equal(asyncStarted, 1);
29043
+ equal(asyncEnded, 1);
29044
+ });
29045
+
29046
+ }).then(function(){
29047
+ equal(asyncStarted, 1);
29048
+ equal(asyncEnded, 1);
29049
+
29050
+ return new Promise(function(resolve){
29051
+ QUnit.stop(); // raw async, we must inform the test framework manually
29052
+ setTimeout(function(){
29053
+ QUnit.start(); // raw async, we must inform the test framework manually
29054
+
29055
+ equal(asyncStarted, 1);
29056
+ equal(asyncEnded, 1);
29057
+
29058
+ resolve({
29059
+ name: 'async tomster'
29060
+ });
29061
+
29062
+ equal(asyncStarted, 2);
29063
+ equal(asyncEnded, 1);
29064
+ }, 0);
29065
+ });
29066
+ }).then(function(user){
29067
+ equal(user.name, 'async tomster');
29068
+ equal(asyncStarted, 2);
29069
+ equal(asyncEnded, 2);
29070
+ });
29071
+ });
28772
29072
  });
28773
29073
  define("ember-runtime/tests/ext/rsvp_test.jshint",
28774
29074
  [],
@@ -31905,7 +32205,7 @@ define("ember-runtime/tests/mixins/deferred_test",
31905
32205
  ["ember-metal/core","ember-metal/run_loop","ember-runtime/system/object","ember-runtime/mixins/deferred","ember-runtime/ext/rsvp"],
31906
32206
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
31907
32207
  "use strict";
31908
- /* global Promise:true */
32208
+ /* global Promise:true,EmberDev */
31909
32209
 
31910
32210
  var Ember = __dependency1__["default"];
31911
32211
  var run = __dependency2__["default"];
@@ -31913,7 +32213,18 @@ define("ember-runtime/tests/mixins/deferred_test",
31913
32213
  var Deferred = __dependency4__["default"];
31914
32214
  var RSVP = __dependency5__["default"];
31915
32215
 
31916
- QUnit.module("Deferred");
32216
+ var originalDeprecate;
32217
+
32218
+ QUnit.module("Deferred", {
32219
+ setup: function() {
32220
+ originalDeprecate = Ember.deprecate;
32221
+ Ember.deprecate = function() { };
32222
+ },
32223
+
32224
+ teardown: function() {
32225
+ Ember.deprecate = originalDeprecate;
32226
+ }
32227
+ });
31917
32228
 
31918
32229
  test("can resolve deferred", function() {
31919
32230
  var deferred, count = 0;
@@ -32227,94 +32538,25 @@ define("ember-runtime/tests/mixins/deferred_test",
32227
32538
  run(deferred, 'resolve', fulfillment);
32228
32539
  });
32229
32540
 
32230
- var asyncStarted = 0;
32231
- var asyncEnded = 0;
32232
- var Promise = RSVP.Promise;
32233
-
32234
- var EmberTest;
32235
- var EmberTesting;
32236
-
32237
- QUnit.module("Deferred RSVP's async + Testing", {
32238
- setup: function() {
32239
- EmberTest = Ember.Test;
32240
- EmberTesting = Ember.testing;
32541
+ if (!EmberDev.runningProdBuild){
32542
+ test("causes a deprecation warning when used", function() {
32543
+ var deferred, deprecationMade, obj = {};
32241
32544
 
32242
- Ember.Test = {
32243
- adapter: {
32244
- asyncStart: function() {
32245
- asyncStarted++;
32246
- QUnit.stop();
32247
- },
32248
- asyncEnd: function() {
32249
- asyncEnded++;
32250
- QUnit.start();
32251
- }
32252
- }
32545
+ Ember.deprecate = function(message) {
32546
+ deprecationMade = message;
32253
32547
  };
32254
- },
32255
- teardown: function() {
32256
- asyncStarted = 0;
32257
- asyncEnded = 0;
32258
-
32259
- Ember.testing = EmberTesting;
32260
- Ember.Test = EmberTest;
32261
- }
32262
- });
32263
32548
 
32264
- test("given `Ember.testing = true`, correctly informs the test suite about async steps", function() {
32265
- expect(19);
32266
-
32267
- ok(!run.currentRunLoop, 'expect no run-loop');
32268
-
32269
- Ember.testing = true;
32270
-
32271
- equal(asyncStarted, 0);
32272
- equal(asyncEnded, 0);
32273
-
32274
- var user = Promise.resolve({
32275
- name: 'tomster'
32276
- });
32277
-
32278
- equal(asyncStarted, 0);
32279
- equal(asyncEnded, 0);
32280
-
32281
- user.then(function(user){
32282
- equal(asyncStarted, 1);
32283
- equal(asyncEnded, 1);
32284
-
32285
- equal(user.name, 'tomster');
32549
+ deferred = EmberObject.createWithMixins(Deferred);
32550
+ equal(deprecationMade, undefined, 'no deprecation was made on init');
32286
32551
 
32287
- return Promise.resolve(1).then(function(){
32288
- equal(asyncStarted, 1);
32289
- equal(asyncEnded, 1);
32552
+ deferred.then(function(value) {
32553
+ equal(value, obj, "successfully resolved to given value");
32290
32554
  });
32555
+ equal(deprecationMade, 'Usage of Ember.DeferredMixin or Ember.Deferred is deprecated.');
32291
32556
 
32292
- }).then(function(){
32293
- equal(asyncStarted, 1);
32294
- equal(asyncEnded, 1);
32295
-
32296
- return new Promise(function(resolve){
32297
- QUnit.stop(); // raw async, we must inform the test framework manually
32298
- setTimeout(function(){
32299
- QUnit.start(); // raw async, we must inform the test framework manually
32300
-
32301
- equal(asyncStarted, 1);
32302
- equal(asyncEnded, 1);
32303
-
32304
- resolve({
32305
- name: 'async tomster'
32306
- });
32307
-
32308
- equal(asyncStarted, 2);
32309
- equal(asyncEnded, 1);
32310
- }, 0);
32311
- });
32312
- }).then(function(user){
32313
- equal(user.name, 'async tomster');
32314
- equal(asyncStarted, 2);
32315
- equal(asyncEnded, 2);
32557
+ run(deferred, 'resolve', obj);
32316
32558
  });
32317
- });
32559
+ }
32318
32560
  });
32319
32561
  define("ember-runtime/tests/mixins/deferred_test.jshint",
32320
32562
  [],
@@ -38246,30 +38488,34 @@ define("ember-runtime/tests/system/deferred_test",
38246
38488
  asyncTest("Can resolve a promise", function() {
38247
38489
  var value = { value: true };
38248
38490
 
38249
- var promise = Deferred.promise(function(deferred) {
38250
- setTimeout(function() {
38251
- run(function() { deferred.resolve(value); });
38491
+ ignoreDeprecation(function() {
38492
+ var promise = Deferred.promise(function(deferred) {
38493
+ setTimeout(function() {
38494
+ run(function() { deferred.resolve(value); });
38495
+ });
38252
38496
  });
38253
- });
38254
38497
 
38255
- promise.then(function(resolveValue) {
38256
- QUnit.start();
38257
- equal(resolveValue, value, "The resolved value should be correct");
38498
+ promise.then(function(resolveValue) {
38499
+ QUnit.start();
38500
+ equal(resolveValue, value, "The resolved value should be correct");
38501
+ });
38258
38502
  });
38259
38503
  });
38260
38504
 
38261
38505
  asyncTest("Can reject a promise", function() {
38262
38506
  var rejected = { rejected: true };
38263
38507
 
38264
- var promise = Deferred.promise(function(deferred) {
38265
- setTimeout(function() {
38266
- run(function() { deferred.reject(rejected); });
38508
+ ignoreDeprecation(function() {
38509
+ var promise = Deferred.promise(function(deferred) {
38510
+ setTimeout(function() {
38511
+ run(function() { deferred.reject(rejected); });
38512
+ });
38267
38513
  });
38268
- });
38269
38514
 
38270
- promise.then(null, function(rejectedValue) {
38271
- QUnit.start();
38272
- equal(rejectedValue, rejected, "The resolved value should be correct");
38515
+ promise.then(null, function(rejectedValue) {
38516
+ QUnit.start();
38517
+ equal(rejectedValue, rejected, "The resolved value should be correct");
38518
+ });
38273
38519
  });
38274
38520
  });
38275
38521
  });
@@ -38749,7 +38995,7 @@ define("ember-runtime/tests/system/object/computed_test",
38749
38995
  }, "metaForProperty() could not find a computed property with key 'staticProperty'.");
38750
38996
  });
38751
38997
 
38752
- testBoth("can iterate over a list of computed properties for a class", function(get, set) {
38998
+ test("can iterate over a list of computed properties for a class", function() {
38753
38999
  var MyClass = EmberObject.extend({
38754
39000
  foo: computed(function() {
38755
39001
 
@@ -38798,6 +39044,40 @@ define("ember-runtime/tests/system/object/computed_test",
38798
39044
 
38799
39045
  deepEqual(list.sort(), ['bar', 'bat', 'baz', 'foo'], "all inherited properties are included");
38800
39046
  });
39047
+
39048
+ test("list of properties updates when an additional property is added (such cache busting)", function() {
39049
+ var MyClass = EmberObject.extend({
39050
+ foo: computed(Ember.K),
39051
+
39052
+ fooDidChange: observer('foo', function() {
39053
+
39054
+ }),
39055
+
39056
+ bar: computed(Ember.K)
39057
+ });
39058
+
39059
+ var list = [];
39060
+
39061
+ MyClass.eachComputedProperty(function(name) {
39062
+ list.push(name);
39063
+ });
39064
+
39065
+ deepEqual(list.sort(), ['bar', 'foo'].sort(), 'expected two computed properties');
39066
+
39067
+ MyClass.reopen({
39068
+ baz: computed(Ember.K)
39069
+ });
39070
+
39071
+ MyClass.create(); // force apply mixins
39072
+
39073
+ list = [];
39074
+
39075
+ MyClass.eachComputedProperty(function(name) {
39076
+ list.push(name);
39077
+ });
39078
+
39079
+ deepEqual(list.sort(), ['bar', 'foo', 'baz'].sort(), 'expected three computed properties');
39080
+ });
38801
39081
  });
38802
39082
  define("ember-runtime/tests/system/object/computed_test.jshint",
38803
39083
  [],
@@ -40014,6 +40294,50 @@ define("ember-runtime/tests/system/object/reopen_test.jshint",
40014
40294
  ok(true, 'ember-runtime/tests/system/object/reopen_test.js should pass jshint.');
40015
40295
  });
40016
40296
  });
40297
+ define("ember-runtime/tests/system/object/strict-mode-test",
40298
+ ["ember-metal/core","ember-runtime/system/object"],
40299
+ function(__dependency1__, __dependency2__) {
40300
+ "use strict";
40301
+ var Ember = __dependency1__["default"];
40302
+ var EmberObject = __dependency2__["default"];
40303
+
40304
+ var originalLookup, lookup;
40305
+
40306
+ QUnit.module('strict mode tests');
40307
+
40308
+ test('__superWrapper does not throw errors in strict mode', function() {
40309
+ var Foo = EmberObject.extend({
40310
+ blah: function() {
40311
+ return 'foo';
40312
+ }
40313
+ });
40314
+
40315
+ var Bar = Foo.extend({
40316
+ blah: function() {
40317
+ return 'bar';
40318
+ },
40319
+
40320
+ callBlah: function() {
40321
+ var blah = this.blah;
40322
+
40323
+ return blah();
40324
+ }
40325
+ });
40326
+
40327
+ var bar = Bar.create();
40328
+
40329
+ equal(bar.callBlah(), 'bar', 'can call local function without call/apply');
40330
+ });
40331
+ });
40332
+ define("ember-runtime/tests/system/object/strict-mode-test.jshint",
40333
+ [],
40334
+ function() {
40335
+ "use strict";
40336
+ module('JSHint - ember-runtime/tests/system/object');
40337
+ test('ember-runtime/tests/system/object/strict-mode-test.js should pass jshint', function() {
40338
+ ok(true, 'ember-runtime/tests/system/object/strict-mode-test.js should pass jshint.');
40339
+ });
40340
+ });
40017
40341
  define("ember-runtime/tests/system/object/subclasses_test",
40018
40342
  ["ember-metal/run_loop","ember-metal/computed","ember-runtime/system/object"],
40019
40343
  function(__dependency1__, __dependency2__, __dependency3__) {
@@ -43371,9 +43695,11 @@ define("ember-views/tests/system/event_dispatcher_test",
43371
43695
  ok(!parentViewReceived, "parent view does not receive the event");
43372
43696
  });
43373
43697
 
43374
- test("should not interfere with event propagation", function() {
43698
+ test('should not interfere with event propagation of virtualViews', function() {
43375
43699
  var receivedEvent;
43376
- view = View.create({
43700
+
43701
+ var view = View.create({
43702
+ isVirtual: true,
43377
43703
  render: function(buffer) {
43378
43704
  buffer.push('<div id="propagate-test-div"></div>');
43379
43705
  }
@@ -43389,8 +43715,8 @@ define("ember-views/tests/system/event_dispatcher_test",
43389
43715
 
43390
43716
  jQuery('#propagate-test-div').click();
43391
43717
 
43392
- ok(receivedEvent, "allowed event to propagate outside Ember");
43393
- deepEqual(receivedEvent.target, jQuery('#propagate-test-div')[0], "target property is the element that was clicked");
43718
+ ok(receivedEvent, 'allowed event to propagate');
43719
+ deepEqual(receivedEvent && receivedEvent.target, jQuery('#propagate-test-div')[0], 'target property is the element that was clicked');
43394
43720
  });
43395
43721
 
43396
43722
  test("should dispatch events to nearest event manager", function() {
@@ -52737,16 +53063,16 @@ define("ember/tests/routing/basic_test",
52737
53063
  this.resource("special", { path: "/specials/:menu_item_id" });
52738
53064
  });
52739
53065
 
52740
- var menuItem;
53066
+ var menuItem, resolve;
52741
53067
 
52742
- App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
53068
+ App.MenuItem = Ember.Object.extend();
52743
53069
  App.MenuItem.reopenClass({
52744
53070
  find: function(id) {
52745
- menuItem = App.MenuItem.create({
52746
- id: id
52747
- });
53071
+ menuItem = App.MenuItem.create({ id: id });
52748
53072
 
52749
- return menuItem;
53073
+ return new Ember.RSVP.Promise(function(res) {
53074
+ resolve = res;
53075
+ });
52750
53076
  }
52751
53077
  });
52752
53078
 
@@ -52777,7 +53103,7 @@ define("ember/tests/routing/basic_test",
52777
53103
  equal(Ember.$('p', '#qunit-fixture').text(), "LOADING!", "The app is in the loading state");
52778
53104
 
52779
53105
  Ember.run(function() {
52780
- menuItem.resolve(menuItem);
53106
+ resolve(menuItem);
52781
53107
  });
52782
53108
 
52783
53109
  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",
52867
53193
  this.resource("special", { path: "/specials/:menu_item_id" });
52868
53194
  });
52869
53195
 
52870
- var menuItem;
53196
+ var menuItem, promise, resolve;
52871
53197
 
52872
- App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
53198
+ App.MenuItem = Ember.Object.extend();
52873
53199
  App.MenuItem.reopenClass({
52874
53200
  find: function(id) {
52875
53201
  menuItem = App.MenuItem.create({ id: id });
52876
- return menuItem;
53202
+ promise = new Ember.RSVP.Promise(function(res) {
53203
+ resolve = res;
53204
+ });
53205
+
53206
+ return promise;
52877
53207
  }
52878
53208
  });
52879
53209
 
@@ -52892,7 +53222,9 @@ define("ember/tests/routing/basic_test",
52892
53222
 
52893
53223
  handleURLRejectsWith('/specials/1', 'Setup error');
52894
53224
 
52895
- Ember.run(menuItem, menuItem.resolve, menuItem);
53225
+ Ember.run(function() {
53226
+ resolve(menuItem);
53227
+ });
52896
53228
  });
52897
53229
 
52898
53230
  function testOverridableErrorHandler(handlersName) {
@@ -52904,13 +53236,15 @@ define("ember/tests/routing/basic_test",
52904
53236
  this.resource("special", { path: "/specials/:menu_item_id" });
52905
53237
  });
52906
53238
 
52907
- var menuItem;
53239
+ var menuItem, resolve;
52908
53240
 
52909
- App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
53241
+ App.MenuItem = Ember.Object.extend();
52910
53242
  App.MenuItem.reopenClass({
52911
53243
  find: function(id) {
52912
53244
  menuItem = App.MenuItem.create({ id: id });
52913
- return menuItem;
53245
+ return new Ember.RSVP.Promise(function(res) {
53246
+ resolve = res;
53247
+ });
52914
53248
  }
52915
53249
  });
52916
53250
 
@@ -52933,7 +53267,9 @@ define("ember/tests/routing/basic_test",
52933
53267
 
52934
53268
  handleURLRejectsWith("/specials/1", "Setup error");
52935
53269
 
52936
- Ember.run(menuItem, 'resolve', menuItem);
53270
+ Ember.run(function() {
53271
+ resolve(menuItem);
53272
+ });
52937
53273
  }
52938
53274
 
52939
53275
  test("ApplicationRoute's default error handler can be overridden", function() {
@@ -52952,7 +53288,7 @@ define("ember/tests/routing/basic_test",
52952
53288
  this.resource("special", { path: "/specials/:menu_item_id" });
52953
53289
  });
52954
53290
 
52955
- App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
53291
+ App.MenuItem = Ember.Object.extend();
52956
53292
 
52957
53293
  App.SpecialRoute = Ember.Route.extend({
52958
53294
  setupController: function(controller, model) {
@@ -52980,7 +53316,7 @@ define("ember/tests/routing/basic_test",
52980
53316
 
52981
53317
  var promiseContext = App.MenuItem.create({ id: 1 });
52982
53318
  Ember.run.later(function() {
52983
- promiseContext.resolve(promiseContext);
53319
+ Ember.RSVP.resolve(promiseContext);
52984
53320
  }, 1);
52985
53321
 
52986
53322
  return router.transitionTo('special', promiseContext);
@@ -53006,9 +53342,9 @@ define("ember/tests/routing/basic_test",
53006
53342
  })
53007
53343
  });
53008
53344
 
53009
- var menuItem;
53345
+ var menuItem, resolve;
53010
53346
 
53011
- App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
53347
+ App.MenuItem = Ember.Object.extend();
53012
53348
  App.MenuItem.reopenClass({
53013
53349
  find: function(id) {
53014
53350
  menuItem = App.MenuItem.create({ id: id });
@@ -53078,7 +53414,9 @@ define("ember/tests/routing/basic_test",
53078
53414
 
53079
53415
  Ember.run(function() {
53080
53416
  var menuItem = App.MenuItem.create({ id: 1 });
53081
- Ember.run.later(function() { menuItem.resolve(menuItem); }, 1);
53417
+ Ember.run.later(function() {
53418
+ Ember.RSVP.resolve(menuItem);
53419
+ }, 1);
53082
53420
 
53083
53421
  router.transitionTo('special', menuItem).then(function(result) {
53084
53422
  equal(rootSetup, 1, "The root setup was not triggered again");
@@ -53089,10 +53427,8 @@ define("ember/tests/routing/basic_test",
53089
53427
  equal(rootModel, 1, "The root model was called again");
53090
53428
 
53091
53429
  deepEqual(router.location.path, '/specials/1');
53430
+ equal(currentPath, 'root.special');
53092
53431
 
53093
-
53094
- equal(currentPath, 'root.special.index');
53095
-
53096
53432
  QUnit.start();
53097
53433
  });
53098
53434
  });
@@ -55156,29 +55492,6 @@ define("ember/tests/routing/basic_test",
55156
55492
  });
55157
55493
 
55158
55494
 
55159
-
55160
- test("specifying no callback to `this.resources` still generates ", function() {
55161
- expect(1);
55162
-
55163
- Router.map(function() {
55164
- this.resource("home");
55165
- });
55166
-
55167
- var currentPath;
55168
-
55169
- App.ApplicationController = Ember.Controller.extend({
55170
- currentPathDidChange: Ember.observer('currentPath', function() {
55171
- currentPath = get(this, 'currentPath');
55172
- })
55173
- });
55174
-
55175
- bootApplication();
55176
-
55177
- Ember.run(router, 'transitionTo', 'home');
55178
- equal(currentPath, 'home.index');
55179
- });
55180
-
55181
-
55182
55495
  test("Errors in transitionTo within redirect hook are logged", function() {
55183
55496
  expect(2);
55184
55497
  var actual = [];