Merge pull request emberjs#1503 from teddyzeenny/fix-href-nested-routes

wagenet · wagenet · commit 991689c321b0 · 2012-11-01T20:50:28.000-07:00
Bug Fix: Generated href for nested routes with multiple contexts
diff --git a/packages/ember-routing/lib/routable.js b/packages/ember-routing/lib/routable.js
@@ -121,27 +121,44 @@ Ember.Routable = Ember.Mixin.create({
 
     @method absoluteRoute
     @param manager {Ember.StateManager}
-    @param hash {Hash}
+    @param hashes {Array}
   */
-  absoluteRoute: function(manager, hash) {
-    var parentState = get(this, 'parentState');
-    var path = '', generated;
+  absoluteRoute: function(manager, hashes) {
+    var parentState = get(this, 'parentState'),
+      path = '', 
+      generated,
+      currentHash;
+
+    // check if object passed instead of array
+    // in this case set currentHash = hashes 
+    // this allows hashes to be a single hash 
+    // (it will be applied to state and all parents)
+    currentHash = null;
+    if (hashes) {
+      if (hashes instanceof Array) {
+        if (hashes.length > 0) {
+          currentHash = hashes.shift();
+        }
+      } else {
+        currentHash = hashes;
+      }
+    }
 
     // If the parent state is routable, use its current path
     // as this route's prefix.
     if (get(parentState, 'isRoutable')) {
-      path = parentState.absoluteRoute(manager, hash);
+      path = parentState.absoluteRoute(manager, hashes);
     }
 
     var matcher = get(this, 'routeMatcher'),
         serialized = manager.getStateMeta(this, 'serialized');
 
     // merge the existing serialized object in with the passed
     // in hash.
-    hash = hash || {};
-    merge(hash, serialized);
+    currentHash = currentHash || {};
+    merge(currentHash, serialized);
 
-    generated = matcher && matcher.generate(hash);
+    generated = matcher && matcher.generate(currentHash);
 
     if (generated) {
       path = path + '/' + generated;
diff --git a/packages/ember-routing/lib/router.js b/packages/ember-routing/lib/router.js
@@ -499,44 +499,50 @@ Ember.Router = Ember.StateManager.extend(
     }
   },
 
-  urlFor: function(path, hash) {
+  urlFor: function(path, hashes) {
     var currentState = get(this, 'currentState') || this,
         state = this.findStateByPath(currentState, path);
 
     Ember.assert(Ember.String.fmt("Could not find route with path '%@'", [path]), state);
     Ember.assert(Ember.String.fmt("To get a URL for the state '%@', it must have a `route` property.", [path]), get(state, 'routeMatcher'));
 
     var location = get(this, 'location'),
-        absoluteRoute = state.absoluteRoute(this, hash);
+        absoluteRoute = state.absoluteRoute(this, hashes);
 
     return location.formatURL(absoluteRoute);
   },
 
   urlForEvent: function(eventName) {
-    var contexts = Array.prototype.slice.call(arguments, 1);
-    var currentState = get(this, 'currentState');
-    var targetStateName = currentState.lookupEventTransition(eventName);
+    var contexts = Array.prototype.slice.call(arguments, 1),
+      currentState = get(this, 'currentState'),
+      targetStateName = currentState.lookupEventTransition(eventName),
+      targetState,
+      hashes;
 
     Ember.assert(Ember.String.fmt("You must specify a target state for event '%@' in order to link to it in the current state '%@'.", [eventName, get(currentState, 'path')]), targetStateName);
 
-    var targetState = this.findStateByPath(currentState, targetStateName);
+    targetState = this.findStateByPath(currentState, targetStateName);
 
     Ember.assert("Your target state name " + targetStateName + " for event " + eventName + " did not resolve to a state", targetState);
 
-    var hash = this.serializeRecursively(targetState, contexts, {});
 
-    return this.urlFor(targetStateName, hash);
+    hashes = this.serializeRecursively(targetState, contexts, []);
+
+    return this.urlFor(targetStateName, hashes);
   },
 
-  serializeRecursively: function(state, contexts, hash) {
-    var parentState,
-        context = get(state, 'hasContext') ? contexts.pop() : null;
-    merge(hash, state.serialize(this, context));
-    parentState = state.get("parentState");
-    if (parentState && parentState instanceof Ember.Route) {
-      return this.serializeRecursively(parentState, contexts, hash);
+  serializeRecursively: function(state, contexts, hashes) {
+    var parentState, 
+			context = get(state, 'hasContext') ? contexts.pop() : null,
+      hash = context ? state.serialize(this, context) : null;
+
+		hashes.push(hash);
+		parentState = state.get("parentState");
+
+		if (parentState && parentState instanceof Ember.Route) {
+      return this.serializeRecursively(parentState, contexts, hashes);
     } else {
-      return hash;
+      return hashes;
     }
   },
 
diff --git a/packages/ember-routing/tests/routable_test.js b/packages/ember-routing/tests/routable_test.js
@@ -831,6 +831,33 @@ test("urlFor supports merging the current information for dynamic segments", fun
   expectURL('/dashboard/posts/1/manage/2');
 });
 
+
+test("urlForEvent supports nested routes that have different contexts but share property names", function() {
+  var router = Ember.Router.create({
+    location: locationStub,
+
+    root: Ember.Route.create({
+      goToComments: Ember.Route.transitionTo('root.dashboard.posts.comments'),
+
+      dashboard: Ember.Route.create({
+        route: '/dashboard',
+
+        posts: Ember.Route.create({
+          route: '/posts/:id',
+          comments: Ember.Route.create({
+            route: '/comments/:id'
+          })
+        })
+      })
+    })
+  });
+
+  var url = router.urlForEvent('goToComments', { id: 1 }, {id: 5});
+  equal(url, "/dashboard/posts/1/comments/5");
+  expectURL('/dashboard/posts/1/comments/5');
+});
+
+
 test("navigateAway is called if the URL changes", function() {
   var navigated = 0;
 
