sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/foundation/system/responder.js

@@ -0,0 +1,120 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/** @class
+
+  Provides common methods for sending events down a responder chain.
+  Responder chains are used most often to deliver events to user interface
+  elements in your application, but you can also use them to deliver generic
+  events to any part of your application, including controllers.
+
+  @extends SC.Object
+  @since SproutCore 1.0
+*/
+SC.Responder = SC.Object.extend( /** SC.Responder.prototype */ {
+
+  isResponder: YES,
+  
+  /** @property
+    The pane this responder belongs to.  This is used to determine where you 
+    belong to in the responder chain.  Normally you should leave this property
+    set to null.
+  */
+  pane: null,
+  
+  /** @property
+    The app this responder belongs to.  For non-user-interface responder 
+    chains, this is used to determine the context.  Usually this
+    is the property you will want to work with.
+  */
+  responderContext: null,
+  
+  /** @property
+    This is the nextResponder in the responder chain.  If the receiver does 
+    not implement a particular event handler, it will bubble to the next 
+    responder.
+    
+    This can point to an object directly or it can be a string, in which case
+    the path will be resolved from the responderContext root.
+  */
+  nextResponder: null,
+  
+  /** @property 
+    YES if the view is currently first responder.  This property is always 
+    edited by the pane during its makeFirstResponder() method.
+  */
+  isFirstResponder: NO,
+  
+  /** @property
+  
+    YES the responder is somewhere in the responder chain.  This currently
+    only works when used with a ResponderContext.
+    
+    @type {Boolean}
+  */
+  hasFirstResponder: NO,    
+  
+  /** @property
+    Set to YES if your view is willing to accept first responder status.  This is used when calculcating key responder loop.
+  */
+  acceptsFirstResponder: YES,
+  
+  /** 
+    Call this method on your view or responder to make it become first 
+    responder.
+    
+    @returns {SC.Responder} receiver
+  */
+  becomeFirstResponder: function() {  
+    var pane = this.get('pane') || this.get('responderContext');
+    if (pane && this.get('acceptsFirstResponder')) {
+      if (pane.get('firstResponder') !== this) pane.makeFirstResponder(this);
+    } 
+    return this ;
+  },
+  
+  /**
+    Call this method on your view or responder to resign your first responder 
+    status. Normally this is not necessary since you will lose first responder 
+    status automatically when another view becomes first responder.
+    
+    @returns {SC.Responder} receiver
+  */
+  resignFirstResponder: function() {
+    var pane = this.get('pane') || this.get('responderContext');
+    if (pane && (pane.get('firstResponder') === this)) {
+      pane.makeFirstResponder(null);
+    }
+    return YES;  
+  },
+
+  /**
+    Called just before the responder or any of its subresponder's are about to
+    lose their first responder status.  The passed responder is the responder
+    that is about to lose its status. 
+    
+    Override this method to provide any standard teardown when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that is about to change
+    @returns {void}
+  */
+  willLoseFirstResponder: function(responder) {},
+  
+  /**
+    Called just after the responder or any of its subresponder's becomes a 
+    first responder.  
+    
+    Override this method to provide any standard setup when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that changed
+    @returns {void}
+  */
+  didBecomeFirstResponder: function(responder) {}
+
+});

data/frameworks/sproutcore/frameworks/foundation/system/responder_context.js

@@ -0,0 +1,243 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/responder');
+
+/** @class
+
+  The root object for a responder chain.  A responder context can dispatch
+  actions directly to a first responder; walking up the responder chain until
+  it finds a responder that can handle the action.  
+  
+  If no responder can be found to handle the action, it will attempt to send
+  the action to the defaultResponder.
+  
+  You can have as many ResponderContext's as you want within your application.
+  Every SC.Pane and SC.Application automatically implements this mixin.
+  
+  Note that to implement this you must be a responder yourself.
+  
+  @extends SC.Responder
+  @since SproutCore 1.0
+*/
+SC.ResponderContext = SC.Responder.extend({
+
+  // ..........................................................
+  // PROPERTIES
+  // 
+  
+  isResponderContext: YES,
+  
+  /** @property
+  
+    When set to YES, logs tracing information about all actions sent and 
+    responder changes.
+  */
+  trace: NO,
+  
+  /** @property
+    The default responder.  Set this to point to a responder object that can 
+    respond to events when no other view in the hierarchy handles them.
+    
+    You can also implement actions directly on the application object if you
+    prefer.
+  */
+  defaultResponder: null,
+  
+  /** @property
+    The next responder for an app is always its defaultResponder.
+  */
+  nextResponder: function() {
+    return this.get('defaultResponder');
+  }.property('defaultResponder').cacheable(),
+  
+  /** @property
+    The first responder.  This is the first responder that should receive 
+    actions.
+  */
+  firstResponder: null,
+
+  // ..........................................................
+  // METHODS
+  // 
+
+  /**
+    Finds the next responder for the passed responder based on the responder's
+    nextResponder property.  If the property is a string, then lookup the path
+    in the receiver.
+  */
+  nextResponderFor: function(responder) {
+    var next = responder.get('nextResponder');
+    if (typeof next === SC.T_STRING) {
+      next = SC.objectForPropertyPath(next, this);
+    } else if (!next && (responder !== this)) next = this ;
+    return next ;  
+  },
+
+  /**
+    Finds the responder name by searching the responders one time.
+  */
+  responderNameFor: function(responder) {
+    if (!responder) return "(No Responder)";
+    else if (responder._scrc_name) return responder._scrc_name;
+    
+    // none found, let's go hunting...look three levels deep
+    var n = this.NAMESPACE;
+    this._findResponderNamesFor(this, 3, n ? [this.NAMESPACE] : []);
+    
+    return responder._scrc_name || responder.toString(); // try again
+  },
+  
+  _findResponderNamesFor: function(responder, level, path) {
+    var key, value;
+    
+    for(key in responder) {
+      if (key === 'nextResponder') continue ;
+      value = responder[key];
+      if (value && value.isResponder) {
+        if (value._scrc_name) continue ;
+        path.push(key);
+        value._scrc_name = path.join('.');
+        if (level>0) this._findResponderNamesFor(value, level-1, path);
+        path.pop();
+      }
+    }
+  },
+  
+  /**
+    Makes the passed responder into the new firstResponder for this 
+    responder context.  This will cause the current first responder to lose 
+    its responder status and possibly keyResponder status as well.
+    
+    When you change the first responder, this will send callbacks to 
+    responders up the chain until you reach a shared responder, at which point
+    it will stop notifying.
+    
+    @param {SC.Responder} responder
+    @returns {SC.ResponderContext} receiver
+  */
+  makeFirstResponder: function(responder) {
+    var current = this.get('firstResponder'), 
+        last    = this.get('nextResponder'),
+        trace   = this.get('trace'),
+        common ;
+
+    if (this._locked) {
+      if (trace) {
+        console.log('%@: AFTER ACTION: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
+      }
+
+      this._pendingResponder = responder;
+      return ;
+    }
+    
+    if (trace) {
+      console.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
+    }
+    
+    this._locked = YES;
+    this._pendingResponder = null;
+    
+    // Find the nearest common responder in the responder chain for the new
+    // responder.  If there are no common responders, use last responder.
+    common = responder ? this.nextResponderFor(responder) : null;
+    while (common) {
+      if (common.get('hasFirstResponder')) break;
+      common = (common===last) ? null : this.nextResponderFor(common);
+    }
+    if (!common) common = last;
+    
+    // Cleanup old first responder
+    this._notifyWillLoseFirstResponder(current, current, common);
+    if (current) current.set('isFirstResponder', NO);
+
+    // Set new first responder.  If new firstResponder does not have its 
+    // responderContext property set, then set it.
+    this.set('firstResponder', responder) ;
+    if (responder) responder.set('isFirstResponder', YES);
+    
+    this._notifyDidBecomeFirstResponder(responder, responder, common);
+    
+    this._locked = NO ;
+    if (responder = this._pendingResponder) {
+      this._pendingResponder= null ;
+      this.makeFirstResponder(this._pendingResponder);
+    }
+    
+    return this ;
+  },
+
+  _notifyWillLoseFirstResponder: function(responder, cur, root) {
+    if (cur === root) return ; // nothing to do
+
+    cur.willLoseFirstResponder(responder);  
+    cur.set('hasFirstResponder', NO);
+
+    var next = this.nextResponderFor(cur);
+    if (next) this._notifyWillLoseFirstResponder(responder, next, root);
+  },
+  
+  _notifyDidBecomeFirstResponder: function(responder, cur, root) {
+    if (cur === root) return ; // nothing to do
+
+    var next = this.nextResponderFor(cur);
+    if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
+    
+    cur.set('hasFirstResponder', YES);
+    cur.didBecomeFirstResponder(responder);  
+  },
+  
+  /**
+    Send the passed action down the responder chain, starting with the 
+    current first responder.  This will look for the first responder that 
+    actually implements the action method and returns YES or no value when 
+    called.
+    
+    @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
+  */
+  sendAction: function(action, sender, context) {
+    var working = this.get('firstResponder'),
+        last    = this.get('nextResponder'),
+        trace   = this.get('trace'),
+        handled = NO,
+        responder;
+
+    this._locked = YES;
+    if (trace) {
+      console.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
+    }
+    
+    while (!handled && working) {
+      if (working.tryToPerform) {
+        handled = working.tryToPerform(action, sender, context);
+      }
+      
+      if (!handled) {
+        working = (working===last) ? null : this.nextResponderFor(working);
+      }
+    }
+
+    if (trace) {
+      if (!handled) console.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
+      else console.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
+    }
+    
+    this._locked = NO ;
+    
+    if (responder = this._pendingResponder) {
+      this._pendingResponder= null ;
+      this.makeFirstResponder(responder);
+    }
+    
+    
+    return working ;
+  }
+
+});

data/frameworks/sproutcore/frameworks/foundation/system/root_responder.js

@@ -177,28 +177,51 @@ SC.RootResponder = SC.Object.extend({
     the action name you pass to this method.  Set 'tagret' to null to search 
     the responder chain.
     
+    IMPORTANT: This method's API and implementation will likely change 
+    significantly after SproutCore 1.0 to match the version found in 
+    SC.ResponderContext.
+    
+    You generally should not call or override this method in your own 
+    applications.
+    
     @param {String} action The action to perform - this is a method name.
     @param {SC.Responder} target object to set method to (can be null)
     @param {Object} sender The sender of the action
     @param {SC.Pane} pane optional pane to start search with
+    @param {Object} context optional. only passed to ResponderContexts
     @returns {Boolean} YES if action was performed, NO otherwise
     @test in targetForAction
   */
-  sendAction: function( action, target, sender, pane) {
+  sendAction: function( action, target, sender, pane, context) {
     target = this.targetForAction(action, target, sender, pane) ;
-    return target && target.tryToPerform(action, sender) ;
+    
+    // HACK: If the target is a ResponderContext, forward the action.
+    if (target && target.isResponderContext) {
+      return !!target.sendAction(action, sender, context);
+    } else return target && target.tryToPerform(action, sender);
   },
   
   _responderFor: function(target, methodName) {
+    var defaultResponder = target ? target.get('defaultResponder') : null;
+
     if (target) {
-      target = target.get('firstResponder') ||
-        target.get('defaultResponder') ||
-        target ;
+      target = target.get('firstResponder') || target;
       do {
         if (target.respondsTo(methodName)) return target ;
       } while (target = target.get('nextResponder')) ;
     }
-    return null ;
+
+    // HACK: Eventually we need to normalize the sendAction() method between
+    // this and the ResponderContext, but for the moment just look for a 
+    // ResponderContext as the defaultResponder and return it if present.
+    if (typeof defaultResponder === SC.T_STRING) {
+      defaultResponder = SC.objectForPropertyPath(defaultResponder);
+    }
+
+    if (!defaultResponder) return null;
+    else if (defaultResponder.isResponderContext) return defaultResponder;
+    else if (defaultResponder.respondsTo(methodName)) return defaultResponder;
+    else return null;
   },
   
   /**

data/frameworks/sproutcore/frameworks/foundation/system/routes.js

@@ -9,7 +9,7 @@
   @class
   
   Routes makes it possible to load a location in the browser.
-
+  
   This is useful when application need to change state depending upon the URL 
   change. Applications can support deep-linking using routes, which means user 
   can type specific URL to see certain state of the app e.g.
@@ -36,11 +36,11 @@
   the location.
   
   h2. Example
-
+  
   {{{
     SC.routes.add(':', RoutesDemo, 'routeHandler');
   }}}
-
+  
   This route would match any URL change. Whatever comes after # would get 
   passed as parameter. RouteDemo is the object that contains method 
   'routeHandler'.
@@ -56,8 +56,9 @@
   @extends SC.Object
   @since SproutCore 1.0
 */
-SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
-
+SC.routes = SC.Object.create(
+/** @scope SC.routes.prototype */ {
+  
   // set this property to your current app lication
   location: function(key,value) {
     if (value !== undefined) {
@@ -65,18 +66,18 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
       
       // convert an object hash to a string, if it was passed.
       if (typeof(value) == "object") {
-
+        
         // get the original route and any params
-        var parts = (value.route) ? value.route.split('&') : [''] ;
+        var parts = value.route ? value.route.split('&') : [''] ;
         var route = parts.shift() ;
         var params = {} ;
         parts.forEach(function(p) {
           var bits = p.split('=') ;
           params[bits[0]] = bits[1] ;
         }) ;
-
+        
         // overlay any params passed in the object.
-        for(var key in value) {
+        for(key in value) {
           if (!value.hasOwnProperty(key)) continue ;
           if (key != 'route') {
             params[key] = encodeURIComponent(''+value[key]) ;
@@ -85,7 +86,7 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
         
         // now build params.
         parts = [route] ;
-        for(var key in params) {
+        for(key in params) {
           if (!params.hasOwnProperty(key)) continue ;
           parts.push([key,params[key]].join('=')) ;          
         }
@@ -103,7 +104,9 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     return this._location ;
   }.property(),
   
-  // ensures we are at the current route location.
+  /**
+    Ensures we are at the current route location.
+  */
   ping: function() { 
     if (!this._didSetupHistory) {
       this._didSetupHistory = true ;
@@ -112,38 +115,49 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     this._checkWindowLocation(); 
   },
   
-  // register a route here.  Routes have the following format:
-  // static/route/path -- matches this path only.
-  // static/route/:path -- matches any static/route, :path passed as param.
-  // static/*route -- matches any static, route gets rest of URL.
-  //
-  // parameters can also be passed using &.
-  // static/route&param1=value&param2=value2
-
+  /**
+    Register a route here.  Routes have the following format:
+    
+    static/route/path -- matches this path only.
+    static/route/:path -- matches any static/route, :path passed as param.
+    static/ *route -- matches any static, route gets rest of URL.
+    
+    parameters can also be passed using &.
+    static/route&param1=value&param2=value2
+    
+    @param {string} route
+    @param {Object} target
+    @param {Function or String} method or method name on target
+    @returns {SC.routes} receiver
+  */
   add: function(route, target, method) {
-		// normalize the target/method
-		if (SC.typeOf(target) === SC.T_FUNCTION) {
-		  method = target; target = null ;
-		} else if (SC.typeOf(method) === SC.T_STRING) {
-		  method = target[method] ;
-		}
-		
+    // normalize the target/method
+    if (method===undefined && SC.typeOf(target) === SC.T_FUNCTION) {
+      method = target; target = null ;
+    } else if (SC.typeOf(method) === SC.T_STRING) {
+      method = target[method] ;
+    }
+    
     var parts = route.split('/') ;
-    if (!this._routes) this._routes = SC.Routes._Route.create() ;
+    if (!this._routes) this._routes = SC.routes._Route.create() ;
     this._routes.addRoute(parts, target, method) ;
-		return this;
+    return this;
   },
-
   
-  // eval routes.
+  /**
+    Eval routes.
+    
+    @param {String} route
+  */
   gotoRoute: function(route) {
-    var params = {} ; var parts, route, routeHandler, target, method ;
-
+    var params = {},
+        parts, routeHandler, target, method ;
+    
     // save this route for window location sensing
     this._lastRoute = route ;
     
     // step 1: split out parameters
-    var parts = route.split('&') ;
+    parts = route.split('&') ;
     if (parts && parts.length > 0) {
       route = parts.shift() ;
       parts.forEach(function(part) {
@@ -156,20 +170,19 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     parts = route.split('/') ;
     
     // step 3: evaluate route.
-    if (!this._routes) this._routes = SC.Routes._Route.create() ;
-
+    if (!this._routes) this._routes = SC.routes._Route.create() ;
+    
     routeHandler = this._routes.functionForRoute(parts,params) ;
     
     if (routeHandler) {
-  		target = routeHandler._target;
-  		method = routeHandler._method;
-  		method.call(target, params);
-  	}
-
-    //else console.log('could not find route for: "'+route+'"') ;
+      target = routeHandler._target;
+      method = routeHandler._method;
+      method.call(target, params);
+    }
+      //else console.log('could not find route for: "'+route+'"') ;
   },
   
-  
+  /** @private */
   init: function() {
     arguments.callee.base.call(this) ;
     if (SC.browser.isSafari && !(SC.browser.safari >= 3)) {
@@ -180,28 +193,42 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     this._didSetupHistory = false ;
   },
   
-  // _checkWindowLocation and _setWindowLocation are implemented separately for
-  // each browser.  Below are the implementations, which get copied during init.
+  // use this method instead of invokeLater() to check windowLocation since
+  // we don't want to trigger runLoops.
+  invokeCheckWindowLocation: function(after) {
+    var f = this.__checkWindowLocation, that = this;
+    if (!f) {
+      f = this.__checkWindowLocation = function() {
+        that._checkWindowLocation();
+      };
+    }
+    setTimeout(f, after);
+  },
+  
+  /** @private
+    _checkWindowLocation and _setWindowLocation are implemented separately for
+    each browser.  Below are the implementations, which get copied during init.
+  */
   browserFuncs: {
     
     // for Safari2 and earlier.
     safari: {
-
+      
       _setupHistory: function() {
         // get initial cloc.
         var cloc = location.hash ;
         cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
         this._cloc = cloc ;
-
+        
         // create back stack.
         this._backStack = [] ;
         this._backStack.length = history.length ;
         this._backStack.push(cloc) ;
-
+        
         // create forward stack.
         this._forwardStack = [] ;
-
-        this.invokeLater(this._checkWindowLocation, 1000) ;
+        
+        this.invokeCheckWindowLocation(1000) ;
       },
       
       _checkWindowLocation: function() { 
@@ -211,10 +238,10 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
         // takes a little while for Safari to catch up.  So what we do instead 
         // is first check to see if Safari's length has changed from its last 
         // known length and only then check for a delta.
-        var historyDidChange = (history.length - this._lastLength) != 0;
+        var historyDidChange = (history.length - this._lastLength) !== 0;
         var delta = (historyDidChange) ? (history.length - this._backStack.length) : 0 ;
         this._lastLength = history.length ;
-
+        
         if (historyDidChange) console.log('historyDidChange') ;
         
         // if the history length has changed, then we need to move forward or 
@@ -239,13 +266,13 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
             // shift out the current loc.
             this._backStack.push(this._cloc) ;
             
-            for(var i=0; i < (delta-1); i++) {
+            for(i=0; i < (delta-1); i++) {
               this._backStack.push(this._forwardStack.pop()) ;
             }
             
             this._cloc = this._forwardStack.pop() ;
           }
-
+          
         // if the history has changed but the delta hasn't, then that means
         // a new location was set via _setWindowLocation().  Normally we would
         // call gotoRoute in that method, but doing so will crash Safari.
@@ -255,7 +282,7 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
           this.gotoRoute(this._cloc) ;
           this._locationDidChange = false ;
         }
-
+        
         var cloc = this._cloc ;
         var loc = this.get('location') ;
         if (cloc != loc) {
@@ -263,10 +290,10 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
           this.gotoRoute(cloc) ;
         }
         
-        this.invokeLater(this._checkWindowLocation, 50) ;
+        this.invokeCheckWindowLocation(50) ;
       },
-
-      _setWindowLocation: function(loc) {        
+      
+      _setWindowLocation: function(loc) {
         var cloc = this._cloc ;
         if (cloc != loc) {
           this._backStack.push(this._cloc) ;
@@ -275,24 +302,24 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
           location.hash = (loc && loc.length > 0) ? loc : '' ;
           this._locationDidChange = true ;
         }
-      }            
+      }
       
     },
     
     // for IE.
     ie: {
       _setupHistory: function() {
-        this.invokeLater(this._checkWindowLocation, 1000) ;
+        this.invokeCheckWindowLocation(1000) ;
       },
-
+      
       _checkWindowLocation: function() {
         var loc = this.get('location') ;
         var cloc = location.hash ;
         cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
         if (cloc != loc) this.set('location',(cloc) ? cloc : '') ;
-        this.invokeLater(this._checkWindowLocation, 100) ;
+        this.invokeCheckWindowLocation(100) ;
       },
-
+      
       _setWindowLocation: function(loc) {
         //console.log('_setWindowLocation('+loc+')') ;
         var cloc = location.hash ;
@@ -305,23 +332,27 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     }
   },
   
+  /** @private */
   _setupHistory: function() {
     var that = this ;
-    this._checkWindowLocation.invokeLater(this, 1000) ;
+    this.invokeCheckWindowLocation(1000) ;
   },
   
+  /** @private */
   _checkWindowLocation: function() {
     var loc = this.get('location') ;
     var cloc = location.hash ;
     cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
     if (cloc != loc) {
-			SC.RunLoop.begin();
-			this.set('location',(cloc) ? cloc : '') ;
-			SC.RunLoop.end();
-		}
-    // this.invokeLater(this._checkWindowLocation, 100) ;
+      SC.RunLoop.begin();
+      this.set('location',(cloc) ? cloc : '') ;
+      SC.RunLoop.end();
+    }
+    
+    this.invokeCheckWindowLocation(150) ;
   },
   
+  /** @private */
   _setWindowLocation: function(loc) {
     //console.log('_setWindowLocation('+loc+')') ;
     var cloc = location.hash ;
@@ -332,16 +363,17 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     this.gotoRoute(loc) ;
   },
   
+  /** @private */
   _routes: null,
   
-  // This object handles a single route level.  
+  /** @private This object handles a single route level. */
   _Route: SC.Object.extend({
     
     // route handler class.
-		_target: null,
-		
-		// route handler
-		_method: null,
+    _target: null,
+    
+    // route handler
+    _method: null,
     
     // staticly named routes.
     _static: null,
@@ -353,11 +385,11 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     _wildcard: null,
     
     addRoute: function(parts, target, method) {
-
-      if (!parts || parts.length == 0) {
-				this._target = target;
-				this._method = method;
-				
+      
+      if (!parts || parts.length === 0) {
+        this._target = target;
+        this._method = method;
+        
       // add to route table.
       } else {
         var part = parts.shift() ; // get next route.
@@ -368,7 +400,7 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
           case ':':
             part = part.slice(1,part.length) ;
             var routes = this._dynamic[part] || [] ;
-            nextRoute = SC.Routes._Route.create() ;
+            nextRoute = SC.routes._Route.create() ;
             routes.push(nextRoute) ;
             this._dynamic[part] = routes ;
             break ;
@@ -377,14 +409,14 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
           case '*':
             part = part.slice(1,part.length) ;
             this._wildcard = part ;
-						this._target = target;				
-						this._method = method;
+            this._target = target;        
+            this._method = method;
             break ;
             
           // setup a normal static route.
           default:
-            var routes = this._static[part] || [] ;
-            nextRoute = SC.Routes._Route.create() ;
+            routes = this._static[part] || [] ;
+            nextRoute = SC.routes._Route.create() ;
             routes.push(nextRoute) ;
             this._static[part] = routes ;
         }
@@ -396,41 +428,50 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     
     // process the next level of the route and pass on.
     functionForRoute: function(parts, params) {
-
+      
       // if parts it empty, then we are here, so return func
-      if (!parts || parts.length == 0) {
-        return this ;				
+      if (!parts || parts.length === 0) {
+        return this ;        
         
       // process the next part
       } else {
-        var part = parts.shift() ;
-        var routes, nextRoute, ret, loc ;
+        var part = parts.shift(),
+            ret  = null,
+           routes, nextRoute, loc ;
         
         // try to match to static
         routes = this._static[part] ;
-        if (routes) for(loc=0;(loc < routes.length) && (ret==null);loc++) {
-          var clone = parts.slice() ;
-          ret = routes[loc].functionForRoute(clone, params) ;
+        if (routes) {
+          for(loc=0;(loc < routes.length) && (ret===null);loc++) {
+            var clone = parts.slice() ;
+            ret = routes[loc].functionForRoute(clone, params) ;
+          }
         }
         
         // try to match dynamic if no static match was found.
-        if (ret == null) for(var key in this._dynamic) {
-          routes = this._dynamic[key] ;
-          if (routes) for(loc=0;(loc<routes.length) && (ret == null);loc++) {
-            var clone = parts.slice() ;
-            ret = routes[loc].functionForRoute(clone,params) ;
+        if (ret === null) {
+          for(var key in this._dynamic) {
+            routes = this._dynamic[key] ;
+            if (routes) {
+              for(loc=0;(loc<routes.length) && (ret === null);loc++) {
+                clone = parts.slice() ;
+                ret = routes[loc].functionForRoute(clone,params) ;
             
-            // if a route was found, save the current part in params.
-            if (ret && params) params[key] = part ;
+                // if a route was found, save the current part in params.
+                if (ret && params) params[key] = part ;
+              }
+            }
+
+            if (ret) break ; 
           }
-          if (ret) break ; 
         }
         
+        
         // if nothing still found, and there is a wildcard, match that.
-        if ((ret == null) && this._wildcard) {
+        if ((ret === null) && this._wildcard) {
           parts.unshift(part) ;
           if (params) params[this._wildcard] = parts.join('/') ;
-					ret = this;
+          ret = this;
         }
         
         return ret ;
@@ -443,4 +484,4 @@ SC.routes = SC.Object.create(/** @scope SC.routes.prototype */ {
     }
   })
   
-}) ;
+});