sproutcore 1.4.5 → 1.5.0.pre.3

data/lib/frameworks/sproutcore/frameworks/runtime/tests/core/isArray.js

@@ -1,25 +0,0 @@
-// ========================================================================
-// SC.isArray Tests
-// ========================================================================
-/*globals module test */
-
-var objectA,objectB,objectC, objectD, objectE; //global variables
-
-module("Array Check" , {
-	
-	setup: function(){
-		objectA = [1,2,3];
-		objectB = 23;
-		objectC = ["Hello","Hi"];
-		objectD = "Hello";
-		objectE	= {};
-	}
-});
-
-test("should check if a given object is an array or not " ,function(){
-	equals(SC.isArray(objectA),true);
-	equals(SC.isArray(objectB),false);
-	equals(SC.isArray(objectC),true);
-	equals(SC.isArray(objectD),false);
-	equals(SC.isArray(objectE),false);
-});

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

@@ -1,336 +0,0 @@
-// ==========================================================================
-// SC.Statechart
-// ==========================================================================
-require('system/state');
-/**
-  @namespace
-  
-  A most excellent statechart implementation
-  
-  @author: Mike Ball
-  @author: Michael Cohen
-  @author: Evin Grano
-  @version: 0.1
-  @since: 0.1
-*/
-
-SC.Statechart = {
-    
-  isStatechart: true,
-  
-  log: NO,
-  
-  initMixin: function(){
-    //setup data
-    this._all_states = {};
-    this._all_states[SC.DEFAULT_TREE] = {};
-    this._current_state = {};
-    this._current_state[SC.DEFAULT_TREE] = null;
-    this._goStateLocked = NO;
-    this._pendingStateTransitions = [];
-    //alias sendAction
-    this.sendAction = this.sendEvent;
-    if(this.get('startOnInit')) this.startupStatechart();
-  },
-  
-  startOnInit: YES,
-  
-  
-  startupStatechart: function(){
-    //add all unregistered states
-    if(!this._started){
-      var key, tree, state, trees, startStates, startState, currTree;
-      for(key in this){
-        if(this.hasOwnProperty(key) && SC.kindOf(this[key], SC.State) && this[key].get && !this[key].get('beenAddedToStatechart')){
-          state = this[key];
-          this._addState(key, state);
-        }
-      }
-      trees = this._all_states;
-      //init the statechart
-      for(key in trees){  
-        if(trees.hasOwnProperty(key)){
-          tree = trees[key];
-          //for all the states in this tree
-          for(state in tree){
-            if(tree.hasOwnProperty(state)){
-              tree[state].initState();
-            }
-          }
-        }
-      }
-      //enter the startstates
-      startStates = this.get('startStates');
-      if(!startStates) throw 'Please add startStates to your statechart!';
-      
-      for(key in trees){  
-        if(trees.hasOwnProperty(key)){
-          startState = startStates[key];
-          currTree = trees[key];
-          if(!startState) console.error('The parallel statechart %@ must have a start state!'.fmt(key));
-          if(!currTree) throw 'The parallel statechart %@ does not exist!'.fmt(key);
-          if(!currTree[startState]) throw 'The parallel statechart %@ doesn\'t have a start state [%@]!'.fmt(key, startState);
-          this.goState(startState, key);
-        }
-      }
-    }
-    this._started = YES;
-  },
-  
-  
-  /**
-    Adds a state to a state manager
-    
-    if the stateManager and stateName objects are blank it is assumed
-    that this state will be picked up by the StateManger's init
-    
-    @param {Object} the state definition
-    @param {SC.Object} Optional: Any SC.Object that mixes in SC.Statechart 
-    @param {String} Optional: the state name
-    @returns {SC.State} the state object
-  */
-  registerState: function(stateDefinition, stateManager, stateName){
-    
-    var state, tree;
-    //create the state object
-    state = SC.State.create(stateDefinition);
-    
-    //passed in optional arguments
-    if(stateManager && stateName){
-      if(stateManager.isStatechart){
-
-        stateManager._addState(stateName, state);
-        state.initState();
-      }
-      else{
-        throw 'Cannot add state: %@ because state manager does not mixin SC.Statechart'.fmt(state.get('name'));
-      }
-    }
-    else{
-      state.set('beenAddedToStatechart', NO);
-    }
-    //push state onto list of states
-    
-    return state;
-  },
-  
-  goHistoryState: function(requestedState, tree, isRecursive){
-    var allStateForTree = this._all_states[tree],
-        pState, realHistoryState;
-    if(!tree || !allStateForTree) throw 'State requesting go history does not have a valid parallel tree';
-    pState = allStateForTree[requestedState];
-    if (pState) realHistoryState = pState.get('history') || pState.get('initialSubState');
-
-    if (!realHistoryState) {
-      if (!isRecursive) console.warn('Requesting History State for [%@] and it is not a parent state'.fmt(requestedState));
-      realHistoryState = requestedState;
-      this.goState(realHistoryState, tree);
-    }
-    else if (isRecursive) {
-      this.goHistoryState(realHistoryState, tree, isRecursive);
-    }
-    else {
-      this.goState(realHistoryState, tree);
-    }
-  },
-  
-  goState: function(requestedState, tree) {
-    var currentState = this._current_state[tree],
-        enterStates = [],
-        exitStates = [],
-        enterMatchIndex,
-        exitMatchIndex,
-        pivotState, pState, cState, 
-        i, hasLogging = this.get('log'), loggingStr;
-             
-    if (!tree) throw '#goState: State requesting go does not have a valid parallel tree';
-    
-    requestedState = this._all_states[tree][requestedState];
-    
-    if (!requestedState) throw '#goState: Could not find the requested state!';
-
-    if (this._goStateLocked) {
-      // There is a state transition currently happening. Add this requested state
-      // transition to the queue of pending state transitions. The request will
-      // be invoked after the current state transition is finished.
-      this._pendingStateTransitions.push({
-        requestedState: requestedState,
-        tree: tree
-      });
-      return;
-    }
-    
-    // Lock the current state transition so that no other requested state transition 
-    // interferes. 
-    this._goStateLocked = YES;
-
-    // Get the parent states for the current state and the registered state. We will
-    // use them to find a common parent state. 
-    enterStates = this._parentStates_with_root(requestedState);
-    exitStates = currentState ? this._parentStates_with_root(currentState) : [];
-  
-    // Continue by finding the common parent state for the current and requested states
-    //
-    // At most, this takes O(m^2) time, where m is the maximum depth from the
-    // root of the tree to either the requested state or the current state. 
-    // Will always be less than or equal to O(n^2), where n is the number of 
-    // states in the tree.
-    pivotState = exitStates.find(function(item,index){
-      exitMatchIndex = index;
-      enterMatchIndex = enterStates.indexOf(item);
-      if (enterMatchIndex >= 0) return YES;
-    });
-      
-    // Looks like we were unable to find a common parent state. This means that we
-    // must enter from the root state in the tree
-    if (!enterMatchIndex) enterMatchIndex = enterStates.length - 1;
-    
-    // Now, from the current state, exit up the parent states to the common parent state, 
-    // but don't exit the common parent itself since you are technically still in it.
-    loggingStr = "";
-    for (i = 0; i < exitMatchIndex; i += 1) {
-      if (hasLogging) loggingStr += 'Exiting State: [%@] in [%@]\n'.fmt(exitStates[i], tree);
-      exitStates[i].exitState();
-    }
-    
-    if (hasLogging) console.info(loggingStr);
-    
-    // Finally, from the the common parent state, but not including the parent state, enter the 
-    // sub states down to the requested state. If the requested state has an initial sub state
-    // then we must enter it too.
-    loggingStr = "";
-    for (i = enterMatchIndex-1; i >= 0; i -= 1) {
-      //TODO call initState?
-      cState = enterStates[i];
-      if (hasLogging) loggingStr += 'Entering State: [%@] in [%@]\n'.fmt(cState, tree);
-      pState = enterStates[i+1];
-      if (pState && SC.typeOf(pState) === SC.T_OBJECT) pState.set('history', cState.name);
-      cState.enterState();
-
-      if (cState === requestedState) {
-        // Make sure to enter the requested state's initial sub state!
-        cState.enterInitialSubState(this._all_states[tree || SC.DEFAULT_TREE]);
-      }
-    }
-    if (hasLogging) console.info(loggingStr);
-    
-    // Set the current state for this state transition
-    this._current_state[tree] = requestedState;
-            
-    // Okay. We're done with the current state transition. Make sure to unlock the
-    // goState and let other pending state transitions execute.
-    this._goStateLocked = NO;
-    this._flushPendingStateTransition();
-  },
-  
-  /** @private
-  
-    Called by goState to flush a pending state transition and the front of the 
-    pending queue.
-  */
-  _flushPendingStateTransition: function() {
-    var pending = this._pendingStateTransitions.shift();
-    if (!pending) return;
-    this.goState(pending.requestedState, pending.tree);
-  },
-  
-  currentState: function(tree){
-    tree = tree || SC.DEFAULT_TREE;
-    return this._current_state[tree];
-  },
-  
-  //Walk like a duck
-  isResponderContext: YES,
-  
-  
-  /**
-    Sends the event to all the parallel state's current state
-    and walks up the graph looking if current does not respond
-    
-    @param {String} action name of action
-    @param {Object} sender object sending the action
-    @param {Object} context optional additonal context info
-    @returns {SC.Responder} the responder that handled it or null
-  */
-  sendEvent: function(action, sender, context) {
-    var trace = this.get('log'),
-        handled = NO,
-        currentStates = this._current_state,
-        responder;
-    
-    this._locked = YES;
-    if (trace) {
-      console.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
-    }
-    
-    for(var tree in currentStates){
-      if(currentStates.hasOwnProperty(tree)){
-        handled = NO;
-        
-        responder = currentStates[tree];
-       
-        while(!handled && responder){
-          if(responder.tryToPerform){
-            handled = responder.tryToPerform(action, sender, context);
-          }
-          
-          if(!handled) responder = responder.get('parentState') ? this._all_states[tree][responder.get('parentState')] : null;
-        }
-        
-        if (trace) {
-          if (!handled) console.log("%@:  action '%@' NOT HANDLED in tree %@".fmt(this,action, tree));
-          else console.log("%@: action '%@' handled by %@ in tree %@".fmt(this, action, responder.get('name'), tree));
-        }
-      }
-    }
-    
-    this._locked = NO ;
-    
-    return responder ;
-  },
-  
-  
-  
-  _addState: function(name, state){
-    state.set('stateManager', this);
-    state.set('name', name);
-    var tree = state.get('parallelStatechart') || SC.DEFAULT_TREE;
-    state.setIfChanged('parallelStatechart', tree);
-    
-    if(!this._all_states[tree]) this._all_states[tree] = {};
-    if(this._all_states[tree][name]) throw 'Trying to add state %@ to state tree %@ and it already exists'.fmt(name, tree);
-    this._all_states[tree][name] = state;
-    
-    state.set('beenAddedToStatechart', YES);
-  },
-  
-  
-  _parentStates: function(state){
-    var ret = [], curr = state;
-    
-    //always add the first state
-    ret.push(curr);
-    curr = curr.get('parentStateObject');
-    
-    while(curr){
-      ret.push(curr);
-      curr = curr.get('parentStateObject');
-    }
-    return ret;
-  },
-  
-  _parentStates_with_root: function(state){
-    var ret = this._parentStates(state);
-    //always push the root
-    ret.push('root');
-    return ret;
-  },
-  
-  parentStateObject: function(name, tree){
-    if(name && tree && this._all_states[tree] && this._all_states[tree][name]){
-      return this._all_states[tree][name];
-    }
-    return null;
-  }
- };
-

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

@@ -1,90 +0,0 @@
-// ==========================================================================
-// SC.Statechart Unit Test
-// ==========================================================================
-/**
-  @author Mike Ball
-*/
-var basic;
-
-// ..........................................................
-// CONTENT CHANGING
-// 
-
-module("SC.Statechart Mixin: Basic Unit test", {
-  setup: function() {
-    basic = SC.Object.create(SC.Statechart,{
-      startStates: {'default': 'bar'},
-      startOnInit: NO,
-      
-      foo: SC.Statechart.registerState({
-        initState: function(){
-          this.set('fooStateInit', true);
-        },
-        
-        enterState: function(){
-
-        },
-
-        exitState: function(){
-
-        },
-        
-        
-        blah: function(){
-          this.goState('bar');
-        },
-        
-        whatever: function(){
-          basic.set('whateverWasCalled', YES);
-        }
-      })
-    });
-    basic.mixin({
-      bar: SC.Statechart.registerState({
-        
-        enterState: function(){
-
-        },
-
-        exitState: function(){
-
-        },
-
-        blah: function(){
-          this.goState('bar');
-        }
-
-      })     
-    });
-    basic.startupStatechart();
-  },
-  
-  teardown: function() {
-    basic.destroy();
-  }
-});
-
-test("basic state transition", function() {
-  basic.foo.goState('foo');
-  equals(basic.foo, basic.foo.state(), "should be in state foo");
-  basic.foo.goState('bar');
-  equals(basic.bar, basic.bar.state(), "should be in state bar");
-  equals(basic.bar, basic.foo.state(), "should be in state bar");
-});
-
-test("basic sendEvent", function(){
-  basic.foo.goState('foo');
-  equals(basic.get('whateverWasCalled'), null, "nothing to report");
-  basic.sendEvent("whatever");
-  equals(basic.get("whateverWasCalled"), YES, "whatever method was called");
-});
-
-test("test method alias", function(){
-  equals(basic.sendAction, basic.sendEvent, "these methods are the same");
-});
-
-test("test basic init", function(){
-  ok(basic.getPath('foo.fooStateInit'), "foo state should have had init called");
-});
-
-