sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/destroy.js

@@ -0,0 +1,73 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var obj, rootState, stateA, stateB;
+
+module("SC.Statechart: Destroy Statechart Tests", {
+  setup: function() {
+    
+    obj = SC.Object.create(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      stateA: SC.State.design(),
+      
+      stateB: SC.State.design()
+      
+    });
+    
+    obj.initStatechart();
+    rootState = obj.get('rootState');
+    stateA = obj.getState('stateA');
+    stateB = obj.getState('stateB');
+  },
+  
+  teardown: function() {
+    obj = rootState = stateA = stateB = null;
+  }
+});
+
+test("check obj before and after destroy", function() {
+  ok(!obj.get('isDestroyed'), "obj should not be destroyed");
+  ok(obj.hasObserverFor('owner'), "obj should have observers for property owner");
+  ok(obj.hasObserverFor('trace'), "obj should have observers for property trace");
+  equals(obj.get('rootState'), rootState, "object should have a root state");
+  
+  ok(!rootState.get('isDestroyed'), "root state should not be destoryed");
+  equals(rootState.getPath('substates.length'), 2, "root state should have two substates");
+  equals(rootState.getPath('currentSubstates.length'), 1, "root state should one current substate");
+  equals(rootState.get('historyState'), stateA, "root state should have history state of A");
+  equals(rootState.get('initialSubstate'), stateA, "root state should have initial substate of A");
+  equals(rootState.get('statechart'), obj, "root state's statechart should be obj");
+  equals(rootState.get('owner'), obj, "root state's owner should be obj");
+  
+  ok(!stateA.get('isDestroyed'), "state A should not be destoryed");
+  equals(stateA.get('parentState'), rootState, "state A should have a parent state of root state");
+  
+  ok(!stateB.get('isDestroyed'), "state B should not be destroyed");
+  equals(stateB.get('parentState'), rootState, "state B should have a parent state of root state");
+  
+  obj.destroy();
+
+  ok(obj.get('isDestroyed'), "obj should be destroyed");
+  ok(!obj.hasObserverFor('owner'), "obj should not have observers for property owner");
+  ok(!obj.hasObserverFor('trace'), "obj should not have observers for property trace");
+  equals(obj.get('rootState'), null, "obj should not have a root state");
+  
+  ok(rootState.get('isDestroyed'), "root state should be destroyed");
+  equals(rootState.get('substates'), null, "root state should not have substates");
+  equals(rootState.get('currentSubstates'), null, "root state should not have current substates");
+  equals(rootState.get('parentState'), null, "root state should not have a parent state");
+  equals(rootState.get('historyState'), null, "root state should not have a history state");
+  equals(rootState.get('initialSubstate'), null, "root state should not have an initial substate");
+  equals(rootState.get('statechart'), null, "root state's statechart should be null");
+  equals(rootState.get('owner'), null, "root state's owner should be null");
+  
+  ok(stateA.get('isDestroyed'), "state A should be destroyed");
+  equals(stateA.get('parentState'), null, "state A should not have a parent state");
+  
+  ok(stateB.get('isDestroyed'), "state B should be destroyed");
+  equals(stateB.get('parentState'), null, "state B should not have a parent state");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/invoke_state_method.js

@@ -0,0 +1,241 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var TestState;
+var obj1, rootState1, stateA, stateB;
+var obj2, rootState2, stateC, stateD;
+
+module("SC.Statechart: invokeStateMethod Tests", {
+  setup: function() {
+    TestState = SC.State.extend({
+      testInvokedCount: 0,
+      arg1: undefined,
+      arg2: undefined,
+      returnValue: undefined,
+      
+      testInvoked: function() {
+        return this.get('testInvokedCount') > 0;
+      }.property('testInvokedCount'),
+      
+      test: function(arg1, arg2) {
+        this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+        this.set('arg1', arg1);
+        this.set('arg2', arg2);
+        if (this.get('returnValue') !== undefined) {
+          return this.get('returnValue');
+        } 
+      }
+    });
+    
+    obj1 = SC.Object.extend(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      rootStateExample: TestState.design({
+        testX: function(arg1, arg2) {
+          this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+          this.set('arg1', arg1);
+          this.set('arg2', arg2);
+          if (this.get('returnValue') !== undefined) {
+            return this.get('returnValue');
+          } 
+        }
+      }),
+      
+      stateA: TestState.design(),
+      
+      stateB: TestState.design()
+      
+    });
+    
+    obj1 = obj1.create();
+    rootState1 = obj1.get('rootState');
+    stateA = obj1.getState('stateA');
+    stateB = obj1.getState('stateB');
+    
+    obj2 = SC.Object.extend(SC.StatechartManager, {
+      
+      statesAreConcurrent: YES,
+      
+      rootStateExample: TestState.design({
+        testX: function(arg1, arg2) {
+          this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+          this.set('arg1', arg1);
+          this.set('arg2', arg2);
+          if (this.get('returnValue') !== undefined) {
+            return this.get('returnValue');
+          } 
+        }
+      }),
+      
+      stateC: TestState.design(),
+      
+      stateD: TestState.design()
+      
+    });
+    
+    obj2 = obj2.create();
+    rootState2 = obj2.get('rootState');
+    stateC = obj2.getState('stateC');
+    stateD = obj2.getState('stateD');
+  },
+  
+  teardown: function() {
+    TestState = obj1 = rootState1 = stateA = stateB = null;
+    obj2 = rootState2 = stateC = stateD = null;
+  }
+});
+
+test("check obj1 - invoke method test1", function() {
+  var result = obj1.invokeStateMethod('test1');
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, no args, no return value", function() {
+  var result = obj1.invokeStateMethod('test');
+  equals(stateA.get('testInvokedCount'), 1, "state A's test method should have been invoked once");
+  equals(stateA.get('arg1'), undefined, "state A's arg1 method should be undefined");
+  equals(stateA.get('arg2'), undefined, "state A's arg2 method should be undefined");
+  equals(result, undefined, "returned result should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, one args, no return value", function() {
+  var result = obj1.invokeStateMethod('test', "frozen");
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(stateA.get('arg1'), "frozen", "state A's arg1 method should be 'frozen'");
+  equals(stateA.get('arg2'), undefined, "state A's arg2 method should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, two args, no return value", function() {
+  var result = obj1.invokeStateMethod('test', 'frozen', 'canuck');
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(stateA.get('arg1'), "frozen", "state A's arg1 method should be 'frozen'");
+  equals(stateA.get('arg2'), "canuck", "state A's arg2 method should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, no args, return value", function() {
+  stateA.set('returnValue', 100);
+  var result = obj1.invokeStateMethod('test');
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(result, 100, "returned result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state B, two args, return value", function() {
+  stateB.set('returnValue', 100);
+  obj1.gotoState(stateB);
+  ok(stateB.get('isCurrentState'), "state B should be curren state");
+  var result = obj1.invokeStateMethod('test', 'frozen', 'canuck');
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  equals(stateB.get('testInvokedCount'), 1, "state B's test method should have been invoked once");
+  equals(stateB.get('arg1'), 'frozen', "state B's arg1 method should be 'frozen'");
+  equals(stateB.get('arg2'), 'canuck', "state B's arg2 method should be 'canuck'");
+  equals(result, 100, "returned result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, use callback", function() {
+  var callbackState, callbackResult;
+  obj1.invokeStateMethod('test', function(state, result) {
+    callbackState = state;
+    callbackResult = result;
+  });
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+  equals(callbackState, stateA, "state should be state A");
+  equals(callbackResult, undefined, "result should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1- invoke method test, current state B, use callback", function() {
+  var callbackState, callbackResult;
+  obj1.gotoState(stateB);
+  stateB.set('returnValue', 100);
+  obj1.invokeStateMethod('test', function(state, result) {
+    callbackState = state;
+    callbackResult = result;
+  });
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(stateB.get('testInvoked'), "state B's test method should have been invoked");
+  equals(callbackState, stateB, "state should be state B");
+  equals(callbackResult, 100, "result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method testX", function() {
+  rootState1.set('returnValue', 100);
+  var result = obj1.invokeStateMethod('testX');
+  equals(rootState1.get('testInvokedCount'), 1, "root state's testX method should not have been invoked once");
+  equals(result, 100, "result should have value 100");
+  ok(!stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj2 - invoke method test1", function() {
+  var result = obj2.invokeStateMethod('test1');
+  ok(!rootState2.get('testInvoked'), "root state test method should not have been invoked");
+  ok(!stateC.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(!stateD.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj2 - invoke test, no args, no return value", function() {
+  var result = obj2.invokeStateMethod('test');
+  equals(stateC.get('testInvokedCount'), 1, "state C's test method should have been invoked once");
+  equals(stateD.get('testInvokedCount'), 1, "state D's test method should have been invoked once");
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  equals(stateC.get('arg1'), undefined, "state C's arg1 method should be undefined");
+  equals(stateC.get('arg2'), undefined, "state C's arg2 method should be undefined");
+  equals(stateD.get('arg1'), undefined, "state D's arg1 method should be undefined");
+  equals(stateD.get('arg2'), undefined, "state D's arg2 method should be undefined");
+  equals(result, undefined, "returned result should be undefined");
+});
+
+test("check obj2 - invoke test, two args, return value, callback", function() {
+  var numCallbacks = 0,
+      callbackInfo = {};
+  stateC.set('returnValue', 100);
+  stateD.set('returnValue', 200);
+  var result = obj2.invokeStateMethod('test', 'frozen', 'canuck', function(state, result) {
+    numCallbacks += 1;
+    callbackInfo['state' + numCallbacks] = state;
+    callbackInfo['result' + numCallbacks] = result;
+  });
+  
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  equals(stateC.get('testInvokedCount'), 1, "state C's test method should have been invoked once");
+  equals(stateD.get('testInvokedCount'), 1, "state D's test method should have been invoked once");
+  
+  equals(stateC.get('arg1'), 'frozen', "state C's arg1 method should be 'frozen'");
+  equals(stateC.get('arg2'), 'canuck', "state C's arg2 method should be 'canuck'");
+  
+  equals(stateD.get('arg1'), 'frozen', "state D's arg1 method should be 'frozen'");
+  equals(stateD.get('arg2'), 'canuck', "state D's arg2 method should be 'canuck'");
+  
+  equals(numCallbacks, 2, "callback should have been invoked twice");
+  equals(callbackInfo['state1'], stateC, "first callback state arg should be state C");
+  equals(callbackInfo['result1'], 100, "first callback result arg should be 100");
+  equals(callbackInfo['state2'], stateD, "second callback state arg should be state D");
+  equals(callbackInfo['result2'], 200, "second callback result arg should be 200");
+  
+  equals(result, undefined, "returned result should be undefined");
+});
+
+test("check obj2 - invoke method testX", function() {
+  rootState2.set('returnValue', 100);
+  var result = obj2.invokeStateMethod('testX');
+  equals(rootState2.get('testInvokedCount'), 1, "root state's testX method should not have been invoked once");
+  equals(result, 100, "result should have value 100");
+  ok(!stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/owner.js

@@ -0,0 +1,236 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var obj1, rootState1, stateA, stateB, stateX, stateY, stateZ;
+var obj2, rootState2, stateC, stateD;
+var obj3, rootState3, stateE, stateF;
+var owner, owner2;
+var TestObject, TestState;
+
+module("SC.Statechart: Change Statechart Owner Property Tests", {
+  setup: function() {
+    owner = SC.Object.create({
+      toString: function() { return "owner"; }
+    });
+    
+    owner2 = SC.Object.create({
+      toString: function() { return "owner2"; }
+    });
+    
+    TestState = SC.State.extend({
+      accessedOwner: null,
+      
+      reset: function() {
+        this.set('accessedOwner', null);
+      },
+      
+      render: function() {
+        this.set('accessedOwner', this.get('owner'));
+      }
+    });
+    
+    TestObject = SC.Object.extend(SC.StatechartManager, {
+      render: function() {
+        this.invokeStateMethod('render');
+      }
+    });
+    
+    obj1 = TestObject.extend({
+      
+      initialState: 'stateA',
+      
+      stateA: TestState.design({
+        foo: function() {
+          this.gotoState('stateB');
+        }
+      }),
+      
+      stateB: TestState.design({
+        bar: function() {
+          this.gotoState('stateA');
+        }
+      }),
+      
+      stateX: TestState.design({
+        initialSubstate: 'stateY',
+        
+        stateY: TestState.design({
+          initialSubstate: 'stateZ',
+          
+          stateZ: TestState.design()
+        })
+      })
+
+    });
+    
+    obj1 = obj1.create();
+    rootState1 = obj1.get('rootState');
+    stateA = obj1.getState('stateA');
+    stateB = obj1.getState('stateB');
+    stateX = obj1.getState('stateX');
+    stateY = obj1.getState('stateY');
+    stateZ = obj1.getState('stateZ');  
+    
+    obj2 = TestObject.extend({
+      
+      owner: owner,
+      
+      initialState: 'stateC',
+      
+      stateC: TestState.design({
+        foo: function() {
+          this.gotoState('stateD');
+        }
+      }),
+      
+      stateD: TestState.design({
+        bar: function() {
+          this.gotoState('stateC');
+        }
+      })
+      
+    });
+    
+    obj2 = obj2.create();
+    rootState2 = obj2.get('rootState');
+    stateC = obj2.getState('stateC');
+    stateD = obj2.getState('stateD');
+    
+    obj3 = TestObject.extend({
+      
+      statechartOwnerKey: 'fooOwner',
+      
+      fooOwner: owner,
+      
+      initialState: 'stateE',
+      
+      stateE: TestState.design({
+        foo: function() {
+          this.gotoState('stateF');
+        }
+      }),
+      
+      stateF: TestState.design({
+        bar: function() {
+          this.gotoState('stateE');
+        }
+      })
+      
+    });
+    
+    obj3 = obj3.create();
+    rootState3 = obj3.get('rootState');
+    stateE = obj3.getState('stateE');
+    stateF = obj3.getState('stateF');
+  },
+  
+  teardown: function() {
+    obj1 = rootState1 = stateA = stateB = stateX = stateY = stateZ = null;
+    obj2 = rootState2 = stateC = stateD = null;
+    obj3 = rootState3 = stateE = stateF = null;
+    owner = owner2 = null;
+    TestObject = TestState = null;
+  }
+});
+
+test("check obj1 -- basic owner get and set", function() {
+  equals(rootState1.get('owner'), obj1, "root state's owner should be obj");
+  equals(stateA.get('owner'), obj1, "state A's owner should be obj");
+  equals(stateB.get('owner'), obj1, "state B's owner should be obj");
+  equals(stateX.get('owner'), obj1, "state X's owner should be obj");
+  equals(stateY.get('owner'), obj1, "state Y's owner should be obj");
+  equals(stateZ.get('owner'), obj1, "state Z's owner should be obj");
+  
+  obj1.set('owner', owner);
+  
+  equals(rootState1.get('owner'), owner, "root state's owner should be owner");
+  equals(stateA.get('owner'), owner, "state A's owner should be owner");
+  equals(stateB.get('owner'), owner, "state B's owner should be owner");
+  equals(stateX.get('owner'), owner, "state X's owner should be owner");
+  equals(stateY.get('owner'), owner, "state Y's owner should be owner");
+  equals(stateZ.get('owner'), owner, "state Z's owner should be owner");
+  
+  obj1.set('owner', null);
+  
+  equals(rootState1.get('owner'), obj1, "root state's owner should be obj");
+  equals(stateA.get('owner'), obj1, "state A's owner should be obj");
+  equals(stateB.get('owner'), obj1, "state B's owner should be obj");
+  equals(stateX.get('owner'), obj1, "state X's owner should be obj");
+  equals(stateY.get('owner'), obj1, "state Y's owner should be obj");
+  equals(stateZ.get('owner'), obj1, "state Z's owner should be obj");
+});
+
+test("check stateA -- access owner via invokeStateMethod", function() {
+  ok(stateA.get('isCurrentState'));
+  equals(stateA.get('accessedOwner'), null);
+  
+  obj1.render();
+  
+  equals(stateA.get('accessedOwner'), obj1);
+  
+  stateA.reset();
+  obj1.set('owner', owner);
+  obj1.render();
+  
+  equals(stateA.get('accessedOwner'), owner);
+});
+
+test("check stateZ -- access owner via invokeStateMethod", function() {
+  obj1.gotoState(stateZ);
+  ok(stateZ.get('isCurrentState'));
+  
+  equals(stateZ.get('accessedOwner'), null);
+  
+  obj1.render();
+  
+  equals(stateZ.get('accessedOwner'), obj1);
+  
+  stateA.reset();
+  obj1.set('owner', owner);
+  obj1.render();
+  
+  equals(stateZ.get('accessedOwner'), owner);
+});
+
+test("check obj2 -- statechartOwnerKey", function() {
+  equals(rootState2.get('owner'), owner, "root state's owner should be owner");
+  equals(stateC.get('owner'), owner, "state C's owner should be owner");
+  equals(stateD.get('owner'), owner, "state D's owner should be owner");
+  
+  obj2.set('owner', null);
+  
+  equals(rootState2.get('owner'), obj2, "root state's owner should be obj");
+  equals(stateC.get('owner'), obj2, "state C's owner should be obj");
+  equals(stateD.get('owner'), obj2, "state D's owner should be obj");
+});
+
+test("check obj3 -- basic owner get and set", function() {
+  equals(obj3.get('statechartOwnerKey'), 'fooOwner', "obj's statechartOwnerKey should be fooOwner");
+  equals(obj3.get('fooOwner'), owner, "obj's fooOwner should be owner");
+  
+  equals(rootState3.get('owner'), owner, "root state's owner should be owner");
+  equals(stateE.get('owner'), owner, "state E's owner should be owner");
+  equals(stateF.get('owner'), owner, "state F's owner should be owner");
+  
+  obj3.set('fooOwner', null);
+  
+  equals(rootState3.get('owner'), obj3, "root state's owner should be obj");
+  equals(stateE.get('owner'), obj3, "state E's owner should be obj");
+  equals(stateF.get('owner'), obj3, "state F's owner should be obj");
+  
+  obj3.set('fooOwner', owner2);
+  
+  equals(rootState3.get('owner'), owner2, "root state's owner2 should be owner2");
+  equals(stateE.get('owner'), owner2, "state E's owner2 should be owner2");
+  equals(stateF.get('owner'), owner2, "state F's owner2 should be owner2");
+  
+  ok(obj3.hasObserverFor('fooOwner'));
+  equals(rootState3.get('owner'), owner2);
+  
+  obj3.destroy();
+  
+  ok(!obj3.hasObserverFor('fooOwner'));
+  equals(rootState3.get('owner'), null);
+});

data/lib/frameworks/sproutcore/frameworks/table/mixins/table_delegate.js

@@ -0,0 +1,41 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple, Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  A delegate for table resize operations.
+*/
+SC.TableDelegate = {
+  /**
+    Walk like a duck.
+  */
+  isTableDelegate: YES,
+  
+  /**
+    Called just before a table resizes a column to a proposed width.  You
+    can use this method to constrain the allowed width.  The default 
+    implementation uses the minWidth and maxWidth of the column object.
+  */
+  tableShouldResizeColumnTo: function(table, column, proposedWidth) {
+    var min = column.get('minWidth') || 0,
+        max = column.get('maxWidth') || proposedWidth;
+    
+    proposedWidth = Math.max(min, proposedWidth);
+    proposedWidth = Math.min(max, proposedWidth);
+    
+    return proposedWidth;
+  },
+  
+  tableShouldResizeWidthTo: function(table, proposedWidth) {
+    var min = table.get('minWidth') || 0,
+        max = table.get('maxWidth') || proposedWidth;
+        
+    proposedWidth = Math.max(min, proposedWidth);
+    proposedWidth = Math.min(max, proposedWidth);
+    
+    return proposedWidth;
+  }
+};