Support defining injections to occur after other injections

packages/ember-application/lib/system/application.js

@@ -308,9 +308,8 @@ Ember.Application = Ember.Namespace.extend(
         router.get('postsController.router') // router
   */
   initialize: function(router) {
-    var properties = Ember.A(Ember.keys(this)),
-        injections = get(this.constructor, 'injections'),
-        namespace = this, controller, name;
+    var injections = get(this.constructor, 'injections'),
+        namespace = this, properties;
 
     if (!router && Ember.Router.detect(namespace['Router'])) {
       router = namespace['Router'].create();
@@ -329,9 +328,30 @@ Ember.Application = Ember.Namespace.extend(
       set(router, 'namespace', this);
     }
 
+    // Sort injections by their befores and afters.
+    // NOTE: Injections cannot have both a before and an after.
+    injections.sort(function(a, b) {
+      if (a.before) {
+        if (!b.before || a.before === b.name) { return -1; }
+      } else if (a.after) {
+        if (!b.after || a.after === b.name) { return 1; }
+      }
+
+      if (b.before) {
+        if (!a.before || b.before === a.name) { return 1; }
+      } else if (b.after) {
+        if (!a.after || b.after === a.name) { return -1; }
+      }
+
+      return 0;
+    });
+
     injections.forEach(function(injection) {
+      // Grab properties before each injection, in case an injection added
+      // properties to the namespace.
+      properties = Ember.A(Ember.keys(namespace));
       properties.forEach(function(property) {
-        injection[1](namespace, router, property);
+        injection.injection(namespace, router, property);
       });
     });
 
@@ -408,23 +428,14 @@ Ember.Application = Ember.Namespace.extend(
 Ember.Application.reopenClass({
   concatenatedProperties: ['injections'],
   injections: Ember.A(),
-  registerInjection: function(options) {
-    var injections = get(this, 'injections'),
-        before = options.before,
-        name = options.name,
-        injection = options.injection,
-        location;
-
-    if (before) {
-      location = injections.find(function(item) {
-        if (item[0] === before) { return true; }
-      });
-      location = injections.indexOf(location);
-    } else {
-      location = get(injections, 'length');
-    }
+  registerInjection: function(injection) {
+    var injections = get(this, 'injections');
+
+    Ember.assert("The injection '" + injection.name + "' has already been registered", !injections.findProperty('name', injection.name));
+    Ember.assert("An injection cannot be registered with both a before and an after", !(injection.before && injection.after));
+    Ember.assert("An injection cannot be registered without an injection function", Ember.canInvoke(injection, 'injection'));
 
-    injections.splice(location, 0, [name, injection]);
+    injections.push(injection);
   }
 });
 

packages/ember-application/tests/system/application_test.js

@@ -219,37 +219,124 @@ test("injections can be registered in a specified order", function() {
 
   var oldInjections = Ember.Application.injections;
   var firstInjectionCalled = 0,
-      secondInjectionCalled = 0;
+      secondInjectionCalled = 0,
+      thirdInjectionCalled = 0,
+      fourthInjectionCalled = 0,
+      fifthInjectionCalled = 0;
 
   Ember.Application.injections = Ember.A();
+  Ember.Application.registerInjection({
+    name: 'fourth',
+    after: 'third',
+    injection: function() {
+      ok(firstInjectionCalled > 1, "fourth: first injection should have been called");
+      ok(secondInjectionCalled > 1, "fourth: second injection should have been called");
+      ok(thirdInjectionCalled > 1, "fourth: third injection should have been called");
+      ok(fifthInjectionCalled === 0, "fourth: fifth injection should not have been called yet");
+      fourthInjectionCalled++;
+    }
+  });
+
   Ember.Application.registerInjection({
     name: 'second',
+    before: 'third',
     injection: function() {
-      ok(firstInjectionCalled > 0, 'first injection should be called first');
+      ok(firstInjectionCalled > 1, "second: first injection should have been called");
+      ok(thirdInjectionCalled === 0, "second: third injection should not have been called yet");
+      ok(fourthInjectionCalled === 0, "second: fourth injection should not have been called yet");
+      ok(fifthInjectionCalled === 0, "second: fifth injection should not have been called yet yet");
       secondInjectionCalled++;
     }
   });
 
+  Ember.Application.registerInjection({
+    name: 'fifth',
+    after: 'fourth',
+    injection: function() {
+      ok(firstInjectionCalled > 1, "fifth: first injection should have been called");
+      ok(secondInjectionCalled > 1, "fifth: second injection should have been called");
+      ok(thirdInjectionCalled > 1, "fifth: third injection should have been called");
+      ok(fourthInjectionCalled > 1, "fifth: fourth injection should have been called");
+      fifthInjectionCalled++;
+    }
+  });
+
   Ember.Application.registerInjection({
     name: 'first',
+    before: 'second',
     injection: function() {
+      ok(secondInjectionCalled === 0, "first: second injection should not have been called yet");
+      ok(thirdInjectionCalled === 0, "first: third injection should not have been called yet");
+      ok(fourthInjectionCalled === 0, "first: fourth injection should not have been called yet");
+      ok(fifthInjectionCalled === 0, "first: fifth injection should not have been called yet yet");
       firstInjectionCalled++;
-      ok(secondInjectionCalled === 0, "second injection should not have been called yet");
-    },
-    before: 'second'
+    }
+  });
+
+  Ember.Application.registerInjection({
+    name: 'third',
+    injection: function() {
+      ok(firstInjectionCalled > 1, "third: first injection should have been called");
+      ok(secondInjectionCalled > 1, "third: second injection should have been called");
+      ok(fourthInjectionCalled === 0, "third: fourth injection should not have been called yet");
+      ok(fifthInjectionCalled === 0, "third: fifth injection should not have been called yet yet");
+      thirdInjectionCalled++;
+    }
+  });
+
+  var router;
+  Ember.run(function() {
+    app = Ember.Application.create({
+      rootElement: '#qunit-fixture'
+    });
+    expect(get(Ember.keys(app), 'length') * 25);
+    router = Ember.Object.create();
+
+    app.initialize(router);
+  });
+
+  Ember.run(function() {
+    router.destroy();
+  });
+
+  Ember.Application.injections = oldInjections;
+});
+
+test("injections are passed properties created from previous injections", function() {
+
+  var oldInjections = Ember.Application.injections;
+  var secondInjectionWasPassedProperty = false;
+
+  Ember.Application.injections = Ember.A();
+  Ember.Application.registerInjection({
+    name: 'first',
+    injection: function(app, router, property) {
+      app.set('foo', true);
+    }
+  });
+
+  Ember.Application.registerInjection({
+    name: 'second',
+    after: 'first',
+    injection: function(app, router, property) {
+      if (property === 'foo') {
+        secondInjectionWasPassedProperty = true;
+      }
+    }
   });
 
   var router;
   Ember.run(function() {
     app = Ember.Application.create({
       rootElement: '#qunit-fixture'
     });
-    expect(get(Ember.keys(app), 'length') * 2);
     router = Ember.Object.create();
 
     app.initialize(router);
   });
 
+  ok(secondInjectionWasPassedProperty, "second injections wasn't passed the property created in the first");
+
   Ember.run(function() {
     router.destroy();
   });