sproutcore 1.7.1.beta → 1.8.0

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state_transitioning/routing/with_concurrent_states/basic.js

@@ -0,0 +1,213 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC */
+
+var statechart, del, monitor, stateFoo, stateBar, stateA, stateB, stateX, stateY, TestState;
+
+module("SC.Statechart: Concurrent States - Trigger Routing on States Basic Tests", {
+  
+  setup: function() {
+
+    del = SC.Object.create(SC.StatechartDelegate, {
+      
+      location: null,
+      
+      handlers: {},
+      
+      statechartUpdateLocationForState: function(statechart, location, state) {
+        this.set('location', location);
+      },
+
+      statechartAcquireLocationForState: function(statechart, state) {
+        return this.get('location');
+      },
+
+      statechartBindStateToRoute: function(statechart, state, route, handler) {
+        this.handlers[route] = {
+          statechart: statechart,
+          state: state,
+          handler: handler
+        };
+      }
+      
+    });
+    
+    TestState = SC.State.extend({
+
+      enterState: function(context) {
+        this.info = {};
+        this.info.enterState = {
+          state: this,
+          context: context
+        };
+      }
+      
+    });
+
+    statechart = SC.Statechart.create({
+      
+      monitorIsActive: YES,
+      
+      delegate: del,
+        
+      statesAreConcurrent: YES,
+        
+      foo: SC.State.design({
+        
+        initialSubstate: 'a',
+        
+        a: TestState.design({
+          
+          representRoute: 'dog'
+          
+        }),
+        
+        b: TestState.design({
+          
+          representRoute: 'cat'
+          
+        })
+        
+      }),
+      
+      bar: SC.State.design({
+        
+        initialSubstate: 'x',
+        
+        x: TestState.design({
+          
+          representRoute: 'pig'
+          
+        }),
+        
+        y: TestState.design({
+          
+          representRoute: 'cow',
+          
+          enterStateByRoute: function(context) {
+            this.info = {};
+            this.info.enterStateByRoute = {
+              context: context
+            };
+          }
+          
+        })
+        
+      })
+      
+    });
+    
+    statechart.initStatechart();
+    
+    monitor = statechart.get('monitor');
+    stateFoo = statechart.getState('foo');
+    stateBar = statechart.getState('bar');
+    stateA = statechart.getState('a');
+    stateB = statechart.getState('b');
+    stateX = statechart.getState('x');
+    stateY = statechart.getState('y');
+  },
+  
+  teardown: function() {
+    statechart = del = monitor = TestState = stateFoo = stateBar = stateA = stateB = stateX = stateY = null;
+  }
+  
+});
+
+test("check statechart initialization", function() {
+  equals(del.get('location'), null, "del.location should be null");
+  
+  var handlers = del.handlers;
+  
+  ok(handlers['dog'], "delegate should have a route 'dog'");
+  equals(handlers['dog'].statechart, statechart, "route 'dog' should be bound to statechart");
+  equals(handlers['dog'].state, stateA, "route 'dog' should be bound to state A");
+  equals(handlers['dog'].handler, stateA.routeTriggered, "route 'dog' should be bound to handler stateA.routeTriggered");
+  
+  ok(handlers['cat'], "delegate should have a route 'cat'");
+  equals(handlers['cat'].statechart, statechart, "route 'cat' should be bound to statechart");
+  equals(handlers['cat'].state, stateB, "route 'cat' should be bound to state B");
+  equals(handlers['cat'].handler, stateB.routeTriggered, "route 'cat' should be bound to handler stateB.routeTriggered");
+  
+  ok(handlers['pig'], "delegate should have a route 'pig'");
+  equals(handlers['pig'].statechart, statechart, "route 'pig' should be bound to statechart");
+  equals(handlers['pig'].state, stateX, "route 'pig' should be bound to state X");
+  equals(handlers['pig'].handler, stateX.routeTriggered, "route 'pig' should be bound to handler stateX.routeTriggered");
+  
+  ok(handlers['cow'], "delegate should have a route 'cow'");
+  equals(handlers['cow'].statechart, statechart, "route 'cow' should be bound to statechart");
+  equals(handlers['cow'].state, stateY, "route 'cow' should be bound to state Y");
+  equals(handlers['cow'].handler, stateY.routeTriggered, "route 'cow' should be bound to handler stateY.routeTriggered");
+});
+
+test("trigger state B's route", function() {
+  var params = {};
+  
+  monitor.reset();
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be a current state");
+  ok(stateX.get('isCurrentState'), "state X should be a current state");
+  ok(!stateY.get('isCurrentState'), "state Y should not be a current state");
+  
+  del.set('location', 'cat');
+  
+  stateB.routeTriggered(params);
+  
+  var seq = monitor.matchSequence().begin().exited('a').entered('b').end();
+  ok(seq, 'sequence should be exited[a], entered[b]');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be a current state");
+  ok(stateB.get('isCurrentState'), "state B should be a current state");
+  ok(stateX.get('isCurrentState'), "state X should be a current state");
+  ok(!stateY.get('isCurrentState'), "state Y should not be a current state");
+  
+  var info = stateB.info;
+  
+  ok(info.enterState, "state B's enterState should have been invoked");
+  
+  var context = info.enterState.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state B's enterState method should have been provided a state route handler context object");
+  equals(context.get('state'), stateB);
+  equals(context.get('location'), 'cat');
+  equals(context.get('params'), params);
+  equals(context.get('handler'), stateB.routeTriggered);
+});
+
+test("trigger state Y's route", function() {
+  var params = {};
+  
+  monitor.reset();
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be a current state");
+  ok(stateX.get('isCurrentState'), "state X should be a current state");
+  ok(!stateY.get('isCurrentState'), "state Y should not be a current state");
+  
+  del.set('location', 'cow');
+  
+  stateY.routeTriggered(params);
+  
+  var seq = monitor.matchSequence().begin().exited('x').entered('y').end();
+  ok(seq, 'sequence should be exited[x], entered[y]');
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be a current state");
+  ok(!stateX.get('isCurrentState'), "state X should not be a current state");
+  ok(stateY.get('isCurrentState'), "state Y should be a current state");
+  
+  var info = stateY.info;
+  
+  ok(!info.enterState, "state Y's enterState should not have been invoked");
+  ok(info.enterStateByRoute, "state Y's enterStateByRoute should have been invoked");
+  
+  var context = info.enterStateByRoute.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state X's enterState method should have been provided a state route handler context object");
+  equals(context.get('state'), stateY);
+  equals(context.get('location'), 'cow');
+  equals(context.get('params'), params);
+  equals(context.get('handler'), stateX.routeTriggered);
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state_transitioning/routing/without_concurrent_states/basic.js

@@ -0,0 +1,212 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC */
+
+var statechart, del, monitor, stateA, stateB, stateC;
+
+module("SC.Statechart: No Concurrent States - Trigger Routing on States Basic Tests", {
+  setup: function() {
+
+    del = SC.Object.create(SC.StatechartDelegate, {
+      
+      location: null,
+      
+      handlers: {},
+      
+      statechartUpdateLocationForState: function(statechart, location, state) {
+        this.set('location', location);
+      },
+
+      statechartAcquireLocationForState: function(statechart, state) {
+        return this.get('location');
+      },
+
+      statechartBindStateToRoute: function(statechart, state, route, handler) {
+        this.handlers[route] = {
+          statechart: statechart,
+          state: state,
+          handler: handler
+        };
+      }
+      
+    });
+
+    statechart = SC.Statechart.create({
+      
+      monitorIsActive: YES,
+      
+      delegate: del,
+        
+      initialState: 'a',
+        
+      a: SC.State.design({
+        
+        representRoute: 'foo',
+        
+        info: {},
+        
+        enterState: function(context) {
+          this.info.enterState = {
+            context: context
+          };
+        }
+        
+      }),
+      
+      b: SC.State.design({
+        
+        representRoute: 'bar',
+        
+        info: {},
+        
+        enterState: function(context) {
+          this.info.enterState = {
+            context: context
+          };
+        }
+        
+      }),
+      
+      c: SC.State.design({
+        
+        representRoute: 'mah',
+        
+        info: {},
+        
+        enterStateByRoute: function(context) {
+          this.info.enterStateByRoute = {
+            context: context
+          };
+        },
+        
+        enterState: function(context) {
+          this.info.enterState = {
+            context: context
+          };
+        }
+         
+      })
+      
+    });
+    
+    statechart.initStatechart();
+    
+    monitor = statechart.get('monitor');
+    stateA = statechart.getState('a');
+    stateB = statechart.getState('b');
+    stateC = statechart.getState('c');
+  },
+  
+  teardown: function() {
+    statechart = del = monitor = stateA = stateB = stateC = null;
+  }
+  
+});
+
+test("check statechart initialization", function() {
+  equals(del.get('location'), null, "del.location should be null");
+  
+  var handlers = del.handlers;
+  
+  ok(handlers['foo'], "delegate should have a route 'foo'");
+  equals(handlers['foo'].statechart, statechart, "route 'foo' should be bound to statechart");
+  equals(handlers['foo'].state, stateA, "route 'foo' should be bound to state A");
+  equals(handlers['foo'].handler, stateA.routeTriggered, "route 'foo' should be bound to handler stateA.routeTriggered");
+  
+  ok(handlers['bar'], "delegate should have a route 'bar'");
+  equals(handlers['bar'].statechart, statechart, "route 'foo' should be bound to statechart");
+  equals(handlers['bar'].state, stateB, "route 'bar' should be bound to state B");
+  equals(handlers['bar'].handler, stateB.routeTriggered, "route 'bar' should be bound to handler stateB.routeTriggered");
+  
+  ok(handlers['mah'], "delegate should have a route 'mah'");
+  equals(handlers['mah'].statechart, statechart, "route 'foo' should be bound to statechart");
+  equals(handlers['mah'].state, stateC, "route 'mah' should be bound to state C");
+  equals(handlers['mah'].handler, stateC.routeTriggered, "route 'mah' should be bound to handler stateC.routeTriggered");
+});
+
+test("trigger state B's route", function() {
+  var params = {};
+  
+  monitor.reset();
+  
+  del.set('location', 'bar');
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be a current state");
+  
+  stateB.routeTriggered(params);
+  
+  var seq = monitor.matchSequence().begin().exited('a').entered('b').end();
+  ok(seq, 'sequence should be exited[a], entered[b]');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be a current state after route triggered");
+  ok(stateB.get('isCurrentState'), "state B should be a current state after route triggered");
+  
+  var info = stateB.info;
+  
+  ok(info.enterState, "state B's enterState should have been invoked");
+  
+  var context = info.enterState.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state B's enterState method should have been provided a state route handler context object");
+  equals(context.get('state'), stateB);
+  equals(context.get('location'), 'bar');
+  equals(context.get('params'), params);
+  equals(context.get('handler'), stateB.routeTriggered);
+});
+
+test("trigger state C's route", function() {
+  var params = {};
+  
+  monitor.reset();
+  
+  del.set('location', 'mah');
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateC.get('isCurrentState'), "state C should not be a current state");
+  
+  stateC.routeTriggered(params);
+  
+  var seq = monitor.matchSequence().begin().exited('a').entered('c').end();
+  ok(seq, 'sequence should be exited[a], entered[c]');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be a current state after route triggered");
+  ok(stateC.get('isCurrentState'), "state C should be a current state after route triggered");
+  
+  var info = stateC.info;
+  
+  ok(!info.enterState, "state C's enterState should not have been invoked");
+  ok(info.enterStateByRoute, "state C's enterStateByRoute should have been invoked");
+  
+  var context = info.enterStateByRoute.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state C's enterState method should have been provided a state route handler context object");
+  equals(context.get('state'), stateC);
+  equals(context.get('location'), 'mah');
+  equals(context.get('params'), params);
+  equals(context.get('handler'), stateC.routeTriggered);
+});
+
+test("Go to state C without triggering state's route", function() {
+  var context = {};
+  
+  monitor.reset();
+  
+  ok(stateA.get('isCurrentState'), "state A should be a current state");
+  ok(!stateC.get('isCurrentState'), "state C should not be a current state");
+  
+  statechart.gotoState(stateC, context);
+  
+  var seq = monitor.matchSequence().begin().exited('a').entered('c').end();
+  ok(seq, 'sequence should be exited[a], entered[c]');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be a current state after route triggered");
+  ok(stateC.get('isCurrentState'), "state C should be a current state after route triggered");
+  
+  var info = stateC.info;
+  
+  ok(info.enterState, "state C's enterState should have been invoked");
+  ok(!info.enterStateByRoute, "state C's enterStateByRoute should not have been invoked");
+  equals(info.enterState.context, context, "state C's enterState should have been passed a context value");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state_transitioning/standard/without_concurrent_states/core.js

@@ -278,4 +278,12 @@ test("from state g, go to state m calling state g\'s gotoState", function() {
   equals(stateM.get('isCurrentState'), true, 'state m should be current state');
   
   ok(monitor.matchEnteredStates(root, 'b', 'f', 'm'), 'states root, B, F and M should all be entered');
+});
+
+test("from state g, go to state h using 'parentState' syntax", function() {
+  monitor.reset();
+  stateG.gotoState('h');
+  
+  equals(monitor.matchSequence().begin().exited('g').entered('h').end(), 
+    true, 'sequence should be exited[g], entered[h]');
 });

data/lib/frameworks/sproutcore/frameworks/statechart/tests/{state/namespacing.js → statechart/methods/get_state.js}

@@ -5,7 +5,7 @@
 
 var statechart1, statechart2, statechart3, statechart4;
 
-module("SC.Statechart: Namespace - Access Substate Tests", {
+module("SC.Statechart: getState method Tests", {
   setup: function() {
     
     statechart1 = SC.Statechart.create({
@@ -155,10 +155,10 @@ test("access statechart2 states", function() {
   equals(state.get('value'), 'state F', 'state b.f should have value "state F"');
 });
 
-test("access all A states in statechart3", function() {
+test("attempt to access all A states in statechart3", function() {
   var state;
       
-  state = statechart3.getState('a');
+  state = statechart3.getState('this.a');
   equals(SC.none(state), false, 'state a should not be null');
   equals(state.get('value'), 'state A', 'state a should have value "state A"');
   
@@ -171,28 +171,6 @@ test("access all A states in statechart3", function() {
   equals(state.get('value'), 'state B.C.A', 'state a should have value "state B.C.A"');
 });
 
-test("access all A states relative to state B in statechart3", function() {
-  var state,
-      stateB = statechart3.getState('b');
-      
-  state = stateB.getSubstate('a');
-  equals(SC.none(state), false, 'state a should not be null');
-  equals(state.get('value'), 'state B.A', 'state a should have value "state B.A"');
-  
-  state = stateB.getSubstate('c.a');
-  equals(SC.none(state), false, 'state c.a should not be null');
-  equals(state.get('value'), 'state B.C.A', 'state a should have value "state B.C.A"');
-});
-
-test("access all A states relative to state C in statechart3", function() {
-  var state,
-      stateC = statechart3.getState('c');
-      
-  state = stateC.getSubstate('a');
-  equals(SC.none(state), false, 'state a should not be null');
-  equals(state.get('value'), 'state B.C.A', 'state a should have value "state B.C.A"');
-});
-
 test("access all states in statechart4", function() {
   var state, 
       stateA = statechart4.getState('a'),
@@ -229,20 +207,4 @@ test("access all states in statechart4", function() {
   console.log('expecting to get an error message...');
   state = statechart4.getState('y');
   equals(SC.none(state), true, 'state y should be null');
-  
-  state = stateA.getSubstate('x');
-  equals(SC.none(state), false, 'state a.x should not be null');
-  equals(state.get('value'), 'state A.X', 'state a should have value "state A.X"');
-  
-  state = stateA.getSubstate('y');
-  equals(SC.none(state), false, 'state a.y should not be null');
-  equals(state.get('value'), 'state A.Y', 'state a should have value "state A.Y"');
-  
-  state = stateB.getSubstate('x');
-  equals(SC.none(state), false, 'state b.x should not be null');
-  equals(state.get('value'), 'state B.X', 'state a should have value "state B.X"');
-  
-  state = stateB.getSubstate('y');
-  equals(SC.none(state), false, 'state b.y should not be null');
-  equals(state.get('value'), 'state B.Y', 'state a should have value "state B.Y"');
 });