sproutcore 1.6.0.beta.3 → 1.6.0.rc.1

data/lib/frameworks/sproutcore/frameworks/statechart/system/statechart.js

@@ -10,6 +10,8 @@
 sc_require('system/state');
 
 /**
+  @class
+
   The startchart manager mixin allows an object to be a statechart. By becoming a statechart, the
   object can then be manage a set of its own states.
   
@@ -163,10 +165,9 @@ sc_require('system/state');
   into as many files as you see fit.
 
   @author Michael Cohen
-
 */
 
-SC.StatechartManager = {
+SC.StatechartManager = /** @scope SC.StatechartManager.prototype */{
   
   // Walk like a duck
   isResponderContext: YES,
@@ -547,7 +548,8 @@ SC.StatechartManager = {
         trace = this.get('allowStatechartTracing'),
         rootState = this.get('rootState'),
         paramState = state,
-        paramFromCurrentState = fromCurrentState;
+        paramFromCurrentState = fromCurrentState,
+        msg;
     
     state = rootState.getSubstate(state);
     
@@ -578,7 +580,7 @@ SC.StatechartManager = {
       // Check to make sure the current state given is actually a current state of this statechart
       fromCurrentState = rootState.getSubstate(fromCurrentState);
       if (SC.none(fromCurrentState) || !fromCurrentState.get('isCurrentState')) {
-        var msg = "Can not to goto state %@. %@ is not a recognized current state in statechart";
+        msg = "Can not to goto state %@. %@ is not a recognized current state in statechart";
         this.statechartLogError(msg.fmt(paramState, paramFromCurrentState));
         this._gotoStateLocked = NO;
         return;
@@ -592,8 +594,12 @@ SC.StatechartManager = {
         
     if (trace) {
       this.statechartLogTrace("BEGIN gotoState: %@".fmt(state));
-      this.statechartLogTrace("starting from current state: %@".fmt(fromCurrentState));
-      this.statechartLogTrace("current states before: %@".fmt(this.get('currentStates')));
+      msg = "starting from current state: %@";
+      msg = msg.fmt(fromCurrentState ? fromCurrentState : '---');
+      this.statechartLogTrace(msg);
+      msg = "current states before: %@";
+      msg = msg.fmt(this.getPath('currentStates.length') > 0 ? this.get('currentStates') : '---');
+      this.statechartLogTrace(msg);
     }
 
     // If there is a current state to start the transition process from, then determine what
@@ -739,7 +745,7 @@ SC.StatechartManager = {
       parentState = parentState.get('parentState');
     }
       
-    if (this.get('allowStatechartTracing')) this.statechartLogTrace("exiting state: %@".fmt(state));
+    if (this.get('allowStatechartTracing')) this.statechartLogTrace("<-- exiting state: %@".fmt(state));
     
     state.set('currentSubstates', []);
     state.notifyPropertyChange('isCurrentState');
@@ -787,7 +793,7 @@ SC.StatechartManager = {
       parentState = parentState.get('parentState');
     }
     
-    if (this.get('allowStatechartTracing')) this.statechartLogTrace("entering state: %@".fmt(state));
+    if (this.get('allowStatechartTracing')) this.statechartLogTrace("--> entering state: %@".fmt(state));
     
     state.notifyPropertyChange('isCurrentState');
   
@@ -1474,73 +1480,3 @@ SC.Statechart = SC.Object.extend(SC.StatechartManager, {
 });
 
 SC.Statechart.design = SC.Statechart.extend;
-
-/**
-  Represents a call that is intended to be asynchronous. This is
-  used during a state transition process when either entering or
-  exiting a state.
-*/
-SC.Async = SC.Object.extend({
-  
-  func: null,
-  
-  arg1: null,
-  
-  arg2: null,
-  
-  /** @private
-    Called by the statechart
-  */
-  tryToPerform: function(state) {
-    var func = this.get('func'),
-        arg1 = this.get('arg1'),
-        arg2 = this.get('arg2'),
-        funcType = SC.typeOf(func);
-      
-    if (funcType === SC.T_STRING) {
-      state.tryToPerform(func, arg1, arg2);
-    } 
-    else if (funcType === SC.T_FUNCTION) {
-      func.apply(state, [arg1, arg2]);
-    }
-  }
-  
-});
-
-/**
-  Singleton
-*/
-SC.Async.mixin({
-  
-  /**
-    Call in either a state's enterState or exitState method when you
-    want a state to perform an asynchronous action, such as an animation.
-    
-    Examples:
-    
-        SC.State.extend({
-    
-          enterState: function() {
-            return SC.Async.perform('foo');
-          },
-      
-          exitState: function() {
-            return SC.Async.perform('bar', 100);
-          }
-      
-          foo: function() { ... },
-      
-          bar: function(arg) { ... }
-    
-        });
-    
-    @param func {String|Function} the functio to be invoked on a state
-    @param arg1 Optional. An argument to pass to the given function
-    @param arg2 Optional. An argument to pass to the given function
-    @return {SC.Async} a new instance of a SC.Async
-  */
-  perform: function(func, arg1, arg2) {
-    return SC.Async.create({ func: func, arg1: arg1, arg2: arg2 });
-  }
-  
-});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/debug/sequence_matcher.js

@@ -0,0 +1,464 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC */
+
+var obj, monitor, rootState, a, b, c, d, e, m, n, o, p, x, y;
+
+module("SC.Statechart: Destroy Statechart Tests", {
+  setup: function() {
+    
+    obj = SC.Object.create(SC.StatechartManager, {
+      
+      initialState: 'A',
+      A: SC.State.design(),
+      B: SC.State.design(),
+      C: SC.State.design(),
+      D: SC.State.design(),
+      E: SC.State.design(),
+      M: SC.State.design(),
+      N: SC.State.design(),
+      O: SC.State.design(),
+      P: SC.State.design(),
+      X: SC.State.design(),
+      Y: SC.State.design()
+      
+    });
+    
+    obj.initStatechart();
+    rootState = obj.get('rootState');
+    a = obj.getState('A');
+    b = obj.getState('B');
+    c = obj.getState('C');
+    d = obj.getState('D');
+    e = obj.getState('E');
+    m = obj.getState('M');
+    n = obj.getState('N');
+    o = obj.getState('O');
+    p = obj.getState('P');
+    x = obj.getState('X');
+    y = obj.getState('Y');
+    
+    monitor = SC.StatechartMonitor.create({ statechart: obj });
+  },
+  
+  teardown: function() {
+    obj = monitor = rootState = null;
+    a = b = c = d = e = m = n = o = p = x = y = null;
+  }
+});
+
+test("match against sequence entered A", function() {
+  monitor.pushEnteredState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().entered(a).end(), "should match entered A");
+  ok(matcher.begin().entered('A').end(), "should match entered 'A'");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().exited(a).end(), "should not match exited A");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().entered(a, b).end(), "should not match entered [A, B]");
+  ok(!matcher.begin().entered(a).entered(b).end(), "should not match entered A, entered B");
+});
+
+test("match against sequence exited A", function() {
+  monitor.pushExitedState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a).end(), "should match exited A");
+  ok(matcher.begin().exited('A').end(), "should match exited 'A'");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().entered(a).end(), "should not match entered A");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().exited(a, b).end(), "should not match exited [A, B]");
+  ok(!matcher.begin().exited(a).exited(b).end(), "should not match exited A, exited B");
+});
+
+test("match against sequence entered A, entered B", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().entered(a, b).end(), "should match entered [A, B]");
+  ok(matcher.begin().entered('A', 'B').end(), "should match entered ['A', 'B']");
+  ok(matcher.begin().entered(a).entered(b).end(), "should match entered A, entered B");
+  ok(!matcher.begin().entered(a).end(), "should not match entered A");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().entered(b, a).end(), "should not match entered [B, A]");
+  ok(!matcher.begin().entered('B', 'A').end(), "should match entered ['B', 'A']");
+  ok(!matcher.begin().entered(b).entered(a).end(), "should not matched entered B, entered A");
+  ok(!matcher.begin().entered(a, c).end(), "should not match entered [A, C]");
+  ok(!matcher.begin().entered('A', 'C').end(), "should not match entered [A, C]");
+  ok(!matcher.begin().entered(a).entered(c).end(), "should not match entered A, entered C");
+  ok(!matcher.begin().entered(a, b, c).end(), "should not match entered [A, B, C]");
+});
+
+test("match against sequence exited A, exited B", function() {
+  monitor.pushExitedState(a);
+  monitor.pushExitedState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a, b).end(), "should match exited [A, B]");
+  ok(matcher.begin().exited('A', 'B').end(), "should match exited ['A', 'B']");
+  ok(matcher.begin().exited(a).exited(b).end(), "should match exited A, entered B");
+  ok(!matcher.begin().exited(a).end(), "should not match exited A");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().exited(b, a).end(), "should not match exited [B, A]");
+  ok(!matcher.begin().exited('B', 'A').end(), "should not match exited ['B', 'A']");
+  ok(!matcher.begin().exited(b).exited(a).end(), "should not matched exited B, exited A");
+  ok(!matcher.begin().exited(a, c).end(), "should not match exited [A, C]");
+  ok(!matcher.begin().exited('A', 'C').end(), "should not match exited ['A', 'C']");
+  ok(!matcher.begin().exited(a).exited(c).end(), "should not match exited A, exited C");
+});
+
+test("match against sequence exited A, entered B", function() {
+  monitor.pushExitedState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a).entered(b).end(), "should match exited A, entered B");
+  ok(matcher.begin().exited('A').entered('B').end(), "should match exited 'A', entered 'B'");
+  ok(!matcher.begin().entered(a).exited(a).end(), "should not match entered A, exited B");
+  ok(!matcher.begin().entered('A').exited('B').end(), "should not match entered 'A', exited 'B'");
+  ok(!matcher.begin().exited(a).entered(c).end(), "should not match exited A, entered C");
+  ok(!matcher.begin().exited(a).entered(b, c).end(), "should not match exited A, entered [B, C]");
+  ok(!matcher.begin().exited(a).entered(b).entered(c).end(), "should not match exited A, entered B, entered C");
+  ok(!matcher.begin().exited(a).entered(b).exited(c).end(), "should not match exited A, entered B, exited C");
+});
+
+test("match against sequence seq(enter A), seq(enter B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A), seq(entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A, entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A, entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a, b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered [A, B]");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(c)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A), seq(entered C)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(b)
+    .endSequence()
+    .beginSequence()
+      .entered(c)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A), seq(entered B), seq(entered C)");
+});
+
+test("match against sequence con(entered A)", function() {
+  monitor.pushEnteredState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+     .beginConcurrent()
+       .entered(a)
+     .endConcurrent()
+   .end();
+   
+   ok(matcher.get('match'), "should match con(entered A)");
+   
+   matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+    .endConcurrent()
+  .end();
+
+  ok(matcher.get('match'), "should match con(seq(entered A))");
+   
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should match con(entered B)");
+   
+  matcher.begin()
+    .beginConcurrent()
+      .exited(a)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should match con(exited B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+    .endConcurrent()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match con(entered A, entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+      .entered(a)
+    .endConcurrent()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match con(entered B, entered A)");
+});
+
+test("match against sequence con(entered A entered B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered A, entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+      .entered(a)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered B, entered A)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(seq(entered A), entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+      .beginSequence()
+        .entered(b)
+      .endSequence()
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(seq(entered A), seq(entered B))");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a, b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered [A, B])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+        .entered(b)
+      .endSequence()
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered [A, B])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(c)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A, entered C)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+      .entered(c)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A, entered B, entered C)");
+   
+});
+
+test("match against sequence con(entered A entered B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  monitor.pushEnteredState(x);
+  monitor.pushEnteredState(m);
+  monitor.pushEnteredState(n);
+  monitor.pushEnteredState(y);
+  monitor.pushEnteredState(o);
+  monitor.pushEnteredState(p);
+  monitor.pushEnteredState(c);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+  
+  ok(matcher.get('match'), 
+    "should match entered A, entered B, con(seq(entered [X, M, N]), seq(entered [Y, O, P])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(matcher.get('match'), 
+    "should match entered A, entered B, con(seq(entered [Y, O, P]), seq(entered [X, M, N])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M]), seq(entered [Y, O, P])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M]), seq(entered [Y, O])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+      .entered(e)
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M, N]), seq(entered [Y, O, P]), entered E) entered C)");
+  
+});