sproutcore 1.7.1.beta → 1.8.0

data/lib/frameworks/sproutcore/frameworks/statechart/tests/event_handling/basic/with_concurrent_states.js

@@ -22,6 +22,12 @@ module("SC.Statechart: With Concurrent States - Send Event Tests", {
         
         x: SC.State.design({
           
+          fooInvokedCount: 0,
+          
+          foo: function() {
+            this.fooInvokedCount++;
+          },
+          
           substatesAreConcurrent: YES,
           
           a: SC.State.design({
@@ -201,3 +207,13 @@ test("send event eventZ", function() {
   equals(statechart.stateIsCurrentState('c'), true, 'current state should be c');
   equals(statechart.stateIsCurrentState('e'), true, 'current state should be e');
 });
+
+test("send event foo to statechart and ensure event is only handled once by state X", function() {
+  var x = statechart.getState('x');
+  
+  equals(x.fooInvokedCount, 0, "x.fooInvokedCount should be 0");
+  
+  statechart.sendEvent('foo');
+  
+  equals(x.fooInvokedCount, 1, "x.fooInvokedCount should be 1");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/event_handling/responder/responder_chain.js

@@ -18,6 +18,7 @@ module("SC.Statechart: Responder Chain Tests", {
         viewB: SC.View.extend(SC.StatechartManager, {
 
           initialState: 'a',
+          returnValue: NO,
 
           a: SC.State.design({
             mouseDown: function(evt) {
@@ -41,11 +42,15 @@ module("SC.Statechart: Responder Chain Tests", {
           
           keyUp: function(evt) { 
             responder = this;
-          }
+            return this.get('returnValue');
+          },
+          
+          toString: function() { return "view B"; }
 
         }),
         
         keyUp: function(evt) { 
+          console.log('%@: keyUp invoked'.fmt(this));
           responder = this;
         },
         
@@ -55,7 +60,9 @@ module("SC.Statechart: Responder Chain Tests", {
         
         click: function(evt) {
           responder = this;
-        }
+        },
+        
+        toString: function() { return "view A"; }
         
       })
       
@@ -91,9 +98,10 @@ test("check state A and B are responders -- mouseDown, mouseUp", function() {
 });
 
 test("check view B is responder -- keyUp", function() {
+  viewB.set('returnValue', YES);
   equals(responder, null, "responder should be null");
   pane.sendEvent('keyUp', {}, viewB);
-  equals(responder, viewB, "view A should be responder");
+  equals(responder, viewB, "view B should be responder");
 });
 
 test("check view A is responder -- keyDown", function() {

data/lib/frameworks/sproutcore/frameworks/statechart/tests/private/state_path_matcher.js

@@ -0,0 +1,116 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC */
+
+var state1, state2;
+module("SC.StatePathMatcher: match Tests", {
+  setup: function() {
+    state1 = SC.Object.create({
+      substates: [
+        SC.Object.create({ name: 'a' })
+      ]
+    });
+
+    state2 = SC.Object.create({
+      substates: [
+        SC.Object.create({ name: 'b' })
+      ]
+    });
+  },
+  
+  teardown: function() {
+    state1 = state2 = null;
+  }
+
+});
+
+test("test with expresson 'a'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'a' });
+  ok(spm.match('a'), "should match 'a'");
+  ok(spm.match('b.a'), "should match 'b.a'");
+
+  ok(!spm.match('b'), "should not match 'b'");
+  ok(!spm.match('a.b'), "should not match 'a.b'"); 
+});
+
+test("test with expresson 'a.b'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'a.b' });
+  ok(spm.match('a.b'), "should match 'a.b'");
+  ok(spm.match('x.a.b'), "should match 'x.a.b'");
+
+  ok(!spm.match('b'), "should not match 'b'");
+  ok(!spm.match('a'), "should not match 'a'");
+  ok(!spm.match('b.a'), "should not match 'b.a'");
+  ok(!spm.match('a.b.x'), "should not match 'a.b.x'"); 
+});
+
+test("test with expresson 'a~b'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'a~b' });
+  ok(spm.match('a.b'), "should match 'a.b'");
+  ok(spm.match('a.x.b'), "should match 'a.x.b'");
+  ok(spm.match('a.x.y.b'), "should match 'a.x.y.b'");
+  ok(spm.match('x.a.b'), "should match 'x.a.b'");
+  ok(spm.match('x.a.y.b'), "should match 'x.a.y.b'");
+
+  ok(!spm.match('b'), "should not match 'b'");
+  ok(!spm.match('a'), "should not match 'a'");
+  ok(!spm.match('a.b.x'), "should not match 'a.b.x'"); 
+  ok(!spm.match('a.y.b.x'), "should not match 'a.y.b.x'"); 
+  ok(!spm.match('y.a.b.x'), "should not match 'y.a.b.x'"); 
+});
+
+test("test with expresson 'a.b~c.d'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'a.b~c.d' });
+  ok(spm.match('a.b.c.d'), "should match 'a.b.c.d'");
+  ok(spm.match('a.b.x.c.d'), "should match 'a.b.x.c.d'");
+  ok(spm.match('a.b.x.y.c.d'), "should match 'a.b.x.y.c.d'");
+  ok(spm.match('z.a.b.x.y.c.d'), "should match 'z.a.b.x.y.c.d'");
+
+  ok(!spm.match('a.b.c.d.x'), "should not match 'a.b.c.d.x'");
+  ok(!spm.match('b.c.d'), "should not match 'b.c.d'");
+  ok(!spm.match('a.b.c'), "should not match 'a.b.c'");
+  ok(!spm.match('a.b.d'), "should not match 'a.b.d'");
+  ok(!spm.match('a.c.d'), "should not match 'a.c.d'");
+  ok(!spm.match('a.b.y.c.d.x'), "should not match 'a.b.y.c.d.x'"); 
+});
+
+test("test with expresson 'this.a'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'this.a' });
+  
+  spm.set('state', state1);
+   
+  ok(spm.match('a'), "should match 'a' for state1");
+  ok(!spm.match('b'), "should not match 'b' for state1");
+  ok(!spm.match('a.b'), "should not match 'a.b' for state1");
+  
+  spm.set('state', state2);
+  
+  ok(!spm.match('a'), "should not match 'a' for state2"); 
+   
+});
+
+test("test with expresson 'this.a.b'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'this.a.b' });
+  
+  spm.set('state', state1);
+
+  ok(spm.match('a.b'), "should match 'a.b'");
+  ok(!spm.match('a'), "should not match 'a'");
+  ok(!spm.match('b'), "should not match 'b'");
+   
+});
+
+test("test with expresson 'this.a~b'", function() {
+  var spm = SC.StatePathMatcher.create({ expression: 'this.a~b' });
+  
+  spm.set('state', state1);
+
+  ok(spm.match('a.b'), "should match 'a.b'");
+  ok(spm.match('a.x.b'), "should match 'a.x.b'");
+  
+  ok(!spm.match('a'), "should not match 'a'");
+  ok(!spm.match('b'), "should not match 'b'");
+  ok(!spm.match('b.a'), "should not match 'b.a'");
+   
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/methods/add_substate.js

@@ -0,0 +1,108 @@
+// ==========================================================================
+// SC Unit Test
+// ==========================================================================
+/*globals SC */
+
+var sc, root, stateA, stateB, stateX, stateY;
+
+module("SC.State: addSubstate method Tests", {
+  
+  setup: function() {
+    
+    sc = SC.Statechart.create({
+      
+      trace: YES,
+      
+      initialState: 'a',
+    
+      a: SC.State.design(),
+      
+      b: SC.State.design({
+        
+        substatesAreConcurrent: YES,
+        
+        x: SC.State.design(),
+        
+        y: SC.State.design()
+        
+      })
+      
+    });
+    
+    sc.initStatechart();
+    root = sc.get('rootState');
+    stateA = sc.getState('a');
+    stateB = sc.getState('b');
+    stateX = sc.getState('x');
+    stateY = sc.getState('y');
+  },
+  
+  teardown: function() {
+    sc = root = stateA = stateB = stateX = stateY = null;
+  }
+  
+});
+
+test("add a substate to the statechart's root state", function() {
+  ok(!root.getSubstate('z'), "root state should not have a state z");
+  
+  var state = root.addSubstate('z');
+  
+  ok(SC.kindOf(state, SC.State) && state.isObject, "addState should return a state object");
+  equals(root.getSubstate('z'), state, "root state should have a state z after adding state");
+  ok(state.get('stateIsInitialized'), "state z should be initialized");
+  ok(!state.get('isEnteredState'), "state z should not be entered");
+  ok(!state.get('isCurrentState'), "state z should not be current");
+  
+  sc.gotoState('z');
+  
+  ok(state.get('isEnteredState'), "state z should be entered after transitioning to it");
+  ok(state.get('isCurrentState'), "state z should be current after transitioning to it");
+});
+
+test("add a substate to state A", function() {
+  ok(!stateA.getSubstate('z'), "state A should not have a state z");
+  ok(!stateA.get('initialSubstate'), "state A should not have an initial substate");
+
+  var state = stateA.addSubstate('z');
+  
+  ok(SC.kindOf(state, SC.State) && state.isObject, "addState should return a state object");
+  equals(stateA.getSubstate('z'), state, "state A should have a state z after adding state");
+  ok(SC.kindOf(stateA.get('initialSubstate'), SC.EmptyState), "state A's initial substate should be an empty state after adding state");
+  ok(!state.get('isEnteredState'), "state z should not be entered");
+  ok(!state.get('isCurrentState'), "state z should not be current");
+  ok(stateA.get('isCurrentState'), "state A should be current");
+  ok(stateA.get('isEnteredState'), "state A should be entered");
+  
+  console.log('reentering state A');
+  stateA.set('initialSubstate', state);
+  stateA.reenter();
+  
+  ok(state.get('isEnteredState'), "state z should be entered after reentering state A");
+  ok(state.get('isCurrentState'), "state z should be current after reentering state A");
+  ok(stateA.get('isEnteredState'), "state A should be entered after reentering");
+  ok(!stateA.get('isCurrentState'), "state A should not be current after reentering");
+});
+
+test("add a substate to state B", function() {
+  ok(!stateB.getSubstate('z'), "state B should not have a state z");
+  sc.gotoState('b');
+
+  var state = stateB.addSubstate('z');
+  
+  ok(SC.kindOf(state, SC.State) && state.isObject, "addState should return a state object");
+  equals(stateB.getSubstate('z'), state, "state B should have a state z after adding state");
+  ok(!state.get('isEnteredState'), "state z should not be entered");
+  ok(!state.get('isCurrentState'), "state z should not be current");
+  ok(!stateB.get('isCurrentState'), "state B should be current");
+  ok(!stateB.get('initialSubstate'), "state B's initial substate should not be set");
+  ok(stateB.get('isEnteredState'), "state B should be entered");
+  equals(stateB.getPath('currentSubstates.length'), 2, "state B should have 2 current substates");
+  
+  stateB.reenter();
+  
+  ok(state.get('isEnteredState'), "state z should be entered after reentering state B");
+  ok(state.get('isCurrentState'), "state z should be current after reentering state B");
+  ok(stateB.get('isEnteredState'), "state B should be entered");
+  equals(stateB.getPath('currentSubstates.length'), 3, "state B should have 3 current substates");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/methods/find_first_relative_current_state/with_concurrent.js

@@ -0,0 +1,179 @@
+// ==========================================================================
+// SC Unit Test
+// ==========================================================================
+/*globals SC */
+
+var sc, root, stateFoo, stateBar, stateA, stateB, stateX, stateY, stateA1, stateA2, stateB1, stateB2, stateX1, stateX2, stateY1, stateY2;
+
+module("SC.State: findFirstRelativeCurrentState method Tests (without concurrent states)", {
+  
+  setup: function() {
+    
+    sc = SC.Statechart.create({
+      
+      initialState: 'foo',
+    
+      foo: SC.State.design({
+        
+        substatesAreConcurrent: YES,
+        
+        a: SC.State.design({
+          initialSubstate: 'a1',
+          a1: SC.State.design(),
+          a2: SC.State.design()
+        }),
+        
+        b: SC.State.design({
+          initialSubstate: 'b1',
+          b1: SC.State.design(),
+          b2: SC.State.design()
+        })
+        
+      }),
+      
+      bar: SC.State.design({
+        
+        substatesAreConcurrent: YES,
+        
+        x: SC.State.design({
+          initialSubstate: 'x1',
+          x1: SC.State.design(),
+          x2: SC.State.design()
+        }),
+        
+        y: SC.State.design({
+          initialSubstate: 'y1',
+          y1: SC.State.design(),
+          y2: SC.State.design()
+        })
+        
+      })
+      
+    });
+    
+    sc.initStatechart();
+    
+    root = sc.get('rootState');
+    stateFoo = sc.getState('foo');
+    stateBar = sc.getState('bar');
+    stateA = sc.getState('a');
+    stateB = sc.getState('b');
+    stateX = sc.getState('x');
+    stateY = sc.getState('y');
+    stateA1 = sc.getState('a1');
+    stateA2 = sc.getState('a2');
+    stateB1 = sc.getState('b1');
+    stateB2 = sc.getState('b2');
+    stateX1 = sc.getState('x1');
+    stateX2 = sc.getState('x2');
+    stateY1 = sc.getState('y1');
+    stateY2 = sc.getState('y2');
+  },
+  
+  teardown: function() {
+    sc = root = stateFoo = stateBar = null;
+    stateA = stateB = stateX = stateY = null;
+    stateA1 = stateA2 = stateB1 = stateB2 = null;
+    stateX1 = stateX2 = stateY1 = stateY2 = null;
+  }
+  
+});
+
+test("check using state A1 with state foo entered", function() {
+  equals(stateA1.findFirstRelativeCurrentState(), stateA1, "state should return state A1");
+});
+
+test("check using state A2 with state foo entered", function() {
+  equals(stateA2.findFirstRelativeCurrentState(), stateA1, "state should return state A1");
+});
+
+test("check using state A with state foo entered", function() {
+  equals(stateA.findFirstRelativeCurrentState(), stateA1, "state should return state A1");
+});
+
+test("check using state Foo with state foo entered", function() {
+  var result;
+
+  ok(stateFoo.get('isEnteredState'), 'state foo should be entered');
+  ok(stateA.get('isEnteredState'), 'state a should be entered');
+  ok(stateB.get('isEnteredState'), 'state b should be entered');
+  ok(stateA1.get('isCurrentState'), 'state a1 should be entered');
+  ok(stateB1.get('isCurrentState'), 'state b1 should be entered');
+  
+  result = stateFoo.findFirstRelativeCurrentState();
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return either state A1 or B1 without anchor");
+  
+  equals(stateFoo.findFirstRelativeCurrentState(stateA), stateA1, "state should return A1 with anchor state A");
+  equals(stateFoo.findFirstRelativeCurrentState('a'), stateA1, "state should return A1 with anchor state 'a'");
+  equals(stateFoo.findFirstRelativeCurrentState(stateA1), stateA1, "state should return A1 with anchor state A1");
+  equals(stateFoo.findFirstRelativeCurrentState('a1'), stateA1, "state should return A1 with anchor state 'a1'");
+  equals(stateFoo.findFirstRelativeCurrentState('a.a1'), stateA1, "state should return A1 with anchor state 'a.a1'");
+  equals(stateFoo.findFirstRelativeCurrentState(stateA2), stateA1, "state should return A1 with anchor state A2");
+  equals(stateFoo.findFirstRelativeCurrentState('a2'), stateA1, "state should return A1 with anchor state 'a2'");
+  equals(stateFoo.findFirstRelativeCurrentState('a.a2'), stateA1, "state should return A1 with anchor state 'a.a2'");
+
+  equals(stateFoo.findFirstRelativeCurrentState(stateB), stateB1, "state should return B1 with anchor state B");
+  equals(stateFoo.findFirstRelativeCurrentState('b'), stateB1, "state should return B1 with anchor state 'b'");
+  equals(stateFoo.findFirstRelativeCurrentState(stateB1), stateB1, "state should return B1 with anchor state B1");
+  equals(stateFoo.findFirstRelativeCurrentState('b1'), stateB1, "state should return B1 with anchor state 'b1'");
+  equals(stateFoo.findFirstRelativeCurrentState('b.b1'), stateB1, "state should return B1 with anchor state 'b.b1'");
+  equals(stateFoo.findFirstRelativeCurrentState(stateB2), stateB1, "state should return B1 with anchor state B2");
+  equals(stateFoo.findFirstRelativeCurrentState('b2'), stateB1, "state should return B1 with anchor state 'b2'");
+  equals(stateFoo.findFirstRelativeCurrentState('b.b2'), stateB1, "state should return B1 with anchor state 'b.b2'");
+});
+
+test("check using root state with state foo entered", function() {
+  var result;
+  
+  result = root.findFirstRelativeCurrentState();
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return either state A1 or B1 without anchor");
+
+  result = root.findFirstRelativeCurrentState(stateFoo); 
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return either state A1 or B1 with anchor state Foo");
+
+  result = root.findFirstRelativeCurrentState(stateBar);
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return either state A1 or B1 with anchor state Bar");
+ 
+  equals(root.findFirstRelativeCurrentState(stateA), stateA1, "state should return state A1 with anchor state A");
+  equals(root.findFirstRelativeCurrentState('a'), stateA1, "state should return state A1 with anchor state 'a'");
+  equals(root.findFirstRelativeCurrentState('foo.a'), stateA1, "state should return state A1 with anchor state 'foo.a'");
+ 
+  equals(root.findFirstRelativeCurrentState(stateB), stateB1, "state should return state B1 with anchor state B");
+  equals(root.findFirstRelativeCurrentState('b'), stateB1, "state should return state B1 with anchor state 'b'");
+  equals(root.findFirstRelativeCurrentState('foo.b'), stateB1, "state should return state B1 with anchor state 'foo.b'");
+
+  result = root.findFirstRelativeCurrentState(stateX);
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return state either state A1 or B1 with anchor state X");
+
+  result = root.findFirstRelativeCurrentState(stateY);
+  ok([stateA1, stateB1].indexOf(result) >= 0, "state should return state either state A1 or B1 with anchor state Y");
+});
+
+test("check using root state with state bar entered", function() {
+  var result;
+  
+  sc.gotoState('bar');
+  
+  result = root.findFirstRelativeCurrentState();
+  ok([stateX1, stateY1].indexOf(result) >= 0, "state should return either state X1 or Y1 without anchor");
+  
+  result = root.findFirstRelativeCurrentState(stateFoo);
+  ok(root.findFirstRelativeCurrentState(stateFoo), "state should return either state X1 or Y1 with anchor state Foo");
+
+  result = root.findFirstRelativeCurrentState(stateBar);
+  ok([stateX1, stateY1].indexOf(result) >= 0, "state should return either state X1 or Y1 with anchor state Bar");
+ 
+  equals(root.findFirstRelativeCurrentState(stateX), stateX1, "state should return state X1 with anchor state X");
+  equals(root.findFirstRelativeCurrentState('x'), stateX1, "state should return state X1 with anchor state 'x'");
+  equals(root.findFirstRelativeCurrentState('bar.x'), stateX1, "state should return state X1 with anchor state 'bar.x'");
+ 
+  equals(root.findFirstRelativeCurrentState(stateY), stateY1, "state should return state Y1 with anchor state Y");
+  equals(root.findFirstRelativeCurrentState('y'), stateY1, "state should return state Y1 with anchor state 'y'");
+  equals(root.findFirstRelativeCurrentState('bar.y'), stateY1, "state should return state Y1 with anchor state 'bar.y'");
+ 
+  result = root.findFirstRelativeCurrentState(stateA);
+  ok([stateX1, stateY1].indexOf(result) >= 0, "state should return either state X1 or Y1 with anchor state A");
+  
+  result = root.findFirstRelativeCurrentState(stateB);
+  ok([stateX1, stateY1].indexOf(result) >= 0, "state should return either state X1 or Y1 with anchor state B");
+});