Allow State.transitionTo handle multiple contexts

packages/ember-states/lib/main.js

@@ -1,4 +1,5 @@
 require('ember-runtime');
+require('ember-views');
 
 /**
 Ember States

packages/ember-states/lib/state.js

@@ -181,8 +181,6 @@ Ember.State = Ember.Object.extend(Ember.Evented,
   exit: Ember.K
 });
 
-var Event = Ember.$ && Ember.$.Event;
-
 Ember.State.reopenClass(
 /** @scope Ember.State */{
 
@@ -211,24 +209,26 @@ Ember.State.reopenClass(
   @static
   @param {String} target
   */
+
   transitionTo: function(target) {
-    var event = function(stateManager, context) {
-      if (Event && context instanceof Event) {
-        if (context.hasOwnProperty('context')) {
-          context = context.context;
-        } else {
-          // If we received an event and it doesn't contain
-          // a context, don't pass along a superfluous
-          // context to the target of the event.
-          return stateManager.transitionTo(target);
-        }
+
+    var transitionFunction = function(stateManager, contextOrEvent) {
+      var contexts, transitionArgs;
+
+      if (contextOrEvent && (contextOrEvent instanceof Ember.$.Event) && contextOrEvent.hasOwnProperty('contexts')) {
+        contexts = contextOrEvent.contexts.slice();
+      }
+      else {
+        contexts = [].slice.call(arguments, 1);
       }
 
-      stateManager.transitionTo(target, context);
+      contexts.unshift(target);
+      stateManager.transitionTo.apply(stateManager, contexts);
     };
 
-    event.transitionTarget = target;
+    transitionFunction.transitionTarget = target;
 
-    return event;
+    return transitionFunction;
   }
+
 });

packages/ember-states/lib/state_manager.js

@@ -623,14 +623,24 @@ Ember.StateManager = Ember.State.extend({
   */
   errorOnUnhandledEvent: true,
 
-  send: function(event, context) {
+  send: function(event) {
+    var contexts, sendRecursiveArguments;
+
     Ember.assert('Cannot send event "' + event + '" while currentState is ' + get(this, 'currentState'), get(this, 'currentState'));
-    return this.sendRecursively(event, get(this, 'currentState'), context);
+
+    contexts = [].slice.call(arguments, 1);
+    sendRecursiveArguments = contexts;
+    sendRecursiveArguments.unshift(event, get(this, 'currentState'));
+
+    return this.sendRecursively.apply(this, sendRecursiveArguments);
   },
 
-  sendRecursively: function(event, currentState, context) {
+  sendRecursively: function(event, currentState) {
     var log = this.enableLogging,
-        action = currentState[event];
+        action = currentState[event],
+        contexts, sendRecursiveArguments, actionArguments;
+
+    contexts = [].slice.call(arguments, 2);
 
     // Test to see if the action is a method that
     // can be invoked. Don't blindly check just for
@@ -640,11 +650,19 @@ Ember.StateManager = Ember.State.extend({
     // case.
     if (typeof action === 'function') {
       if (log) { Ember.Logger.log(fmt("STATEMANAGER: Sending event '%@' to state %@.", [event, get(currentState, 'path')])); }
-      return action.call(currentState, this, context);
+
+      actionArguments = contexts;
+      actionArguments.unshift(this);
+
+      return action.apply(currentState, actionArguments);
     } else {
       var parentState = get(currentState, 'parentState');
       if (parentState) {
-        return this.sendRecursively(event, parentState, context);
+
+        sendRecursiveArguments = contexts;
+        sendRecursiveArguments.unshift(event, parentState);
+
+        return this.sendRecursively.apply(this, sendRecursiveArguments);
       } else if (get(this, 'errorOnUnhandledEvent')) {
         throw new Ember.Error(this.toString() + " could not respond to event " + event + " in state " + get(this, 'currentState.path') + ".");
       }

packages/ember-states/package.json

@@ -12,7 +12,8 @@
 
   "dependencies": {
     "spade":              "~> 1.0",
-    "ember-runtime": "1.0.pre"
+    "ember-runtime": "1.0.pre",
+    "ember-views": "1.0.pre"
   },
 
   "dependencies:development": {

packages/ember-states/tests/state_manager_test.js

@@ -383,7 +383,7 @@ test("it sends exit events in the correct order when changing to a state multipl
   equal(exitOrder[1], 'exitedOuter', "outer exit is called second");
 });
 
-var passedContext, loadingEventCalled, loadedEventCalled, eventInChildCalled;
+var passedContext, passedContexts, loadingEventCalled, loadedEventCalled, eventInChildCalled;
 loadingEventCalled = loadedEventCalled = eventInChildCalled = 0;
 
 module("Ember.StateManager - Event Dispatching", {
@@ -393,6 +393,7 @@ module("Ember.StateManager - Event Dispatching", {
         anEvent: function(manager, context) {
           loadingEventCalled++;
           passedContext = context;
+          passedContexts = [].slice.call(arguments, 1);
         }
       }),
 
@@ -442,6 +443,12 @@ test("it supports arguments to events", function() {
   equal(passedContext.context, true, "send passes along a context");
 });
 
+test("it supports multiple arguments to events", function() {
+  stateManager.send('anEvent', {name: 'bestie'}, {name: 'crofty'});
+  equal(passedContexts[0].name, 'bestie', "send passes along the first context");
+  equal(passedContexts[1].name, 'crofty', "send passes along the second context");
+});
+
 test("it throws an exception if an event is dispatched that is unhandled", function() {
   raises(function() {
     stateManager.send('unhandledEvent');

packages/ember-states/tests/state_test.js

@@ -180,3 +180,176 @@ test("the isLeaf property is false when a state has child states", function() {
   equal(otherInsideFirst.get('isLeaf'), false);
   equal(definitelyInside.get('isLeaf'), true);
 });
+
+test("Ember.State.transitionTo sets the transition target", function(){
+  var receivedTarget,
+      stateManager,
+      transitionFunction;
+
+  stateManager = {
+    transitionTo: function(target, context){
+      receivedTarget = target;
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager);
+
+  equal( receivedTarget, 'targetState' );
+});
+
+test("Ember.State.transitionTo passes no context arguments when there are no contexts", function(){
+  var contextArgsCount,
+      stateManager,
+      transitionFunction,
+      event;
+
+  event = new Ember.$.Event();
+  event.contexts = [];
+
+  stateManager = {
+    transitionTo: function(){
+      contextArgsCount = [].slice.call(arguments, 1).length;
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, event);
+
+  equal( contextArgsCount, 0);
+});
+
+test("Ember.State.transitionTo passes through a single context", function(){
+  var contextArgsCount,
+      stateManager,
+      transitionFunction,
+      event;
+
+  event = new Ember.$.Event();
+  event.contexts = [];
+
+  stateManager = {
+    transitionTo: function(){
+      contextArgsCount = [].slice.call(arguments, 1).length;
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, event);
+
+  equal(contextArgsCount, 0);
+});
+
+test("Ember.State.transitionTo passes through a single context", function(){
+  var receivedContext,
+      stateManager,
+      transitionFunction,
+      event;
+
+  event = new Ember.$.Event();
+  event.contexts = [{ value: 'context value' }];
+
+  stateManager = {
+    transitionTo: function(target, context){
+      receivedContext = context;
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, event);
+
+  equal( receivedContext, event.contexts[0]);
+});
+
+test("Ember.State.transitionTo passes through multiple contexts as additional arguments", function(){
+  var receivedContexts,
+      stateManager,
+      transitionFunction,
+      event;
+
+  event = new Ember.$.Event();
+  event.contexts = [ { value: 'context1' }, { value: 'context2' } ];
+
+  stateManager = {
+    transitionTo: function(target){
+      receivedContexts = [].slice.call(arguments, 1);
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, event);
+
+  deepEqual( receivedContexts, event.contexts);
+});
+
+test("Ember.State.transtionTo does not mutate the event contexts value", function(){
+  var receivedContexts,
+      stateManager,
+      transitionFunction,
+      originalContext,
+      event;
+
+  originalContext = [ { value: 'context1' }, { value: 'context2' } ];
+
+  event = new Ember.$.Event();
+  event.contexts = originalContext.slice();
+
+  stateManager = {
+    transitionTo: function(target){
+      receivedContexts = [].slice.call(arguments, 1);
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, event);
+
+  deepEqual(event.contexts, originalContext);
+});
+
+test("Ember.State.transitionTo passes no context arguments when called with no context or event", function(){
+  var receivedContexts,
+      stateManager,
+      transitionFunction;
+
+  stateManager = {
+    transitionTo: function(target){
+      receivedContexts = [].slice.call(arguments, 1);
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager);
+
+  equal( receivedContexts.length, 0, "transitionTo receives no context");
+});
+
+test("Ember.State.transitionTo handles contexts without an event", function(){
+  var receivedContexts,
+      stateManager,
+      transitionFunction,
+      context1,
+      context2;
+
+  context1 = { value: 'context1', contexts: 'I am not an event'};
+  context2 = { value: 'context2', contexts: ''};
+
+  stateManager = {
+    transitionTo: function(target){
+      receivedContexts = [].slice.call(arguments, 1);
+    }
+  };
+
+  transitionFunction = Ember.State.transitionTo('targetState');
+
+  transitionFunction(stateManager, context1, context2);
+
+  equal( receivedContexts[0], context1, "the first context is passed through" );
+  equal( receivedContexts[1], context2, "the second context is passed through" );
+});