sproutcore 1.0.1037 → 1.0.1042

data/frameworks/sproutcore/frameworks/runtime/core.js

@@ -71,10 +71,10 @@ var SproutCore = SproutCore || SC ;
 */
 SC.mixin = function() {
   // copy reference to target object
-  var target = arguments[0] || {};
-  var idx = 1;
-  var length = arguments.length ;
-  var options ;
+  var target = arguments[0] || {},
+      idx = 1,
+      length = arguments.length ,
+      options, copy , key;
 
   // Handle case where we have only one item...extend SC
   if (length === 1) {
@@ -84,9 +84,9 @@ SC.mixin = function() {
 
   for ( ; idx < length; idx++ ) {
     if (!(options = arguments[idx])) continue ;
-    for(var key in options) {
+    for(key in options) {
       if (!options.hasOwnProperty(key)) continue ;
-      var copy = options[key] ;
+      copy = options[key] ;
       if (target===copy) continue ; // prevent never-ending loop
       if (copy !== undefined) target[key] = copy ;
     }
@@ -424,11 +424,30 @@ SC.mixin(/** @scope SC */ {
 
   */
   compare: function (v, w) {
+    // Doing a '===' check is very cheap, so in the case of equality, checking
+    // this up-front is a big win.
+    if (v === w) return 0;
     
     var type1 = SC.typeOf(v);
     var type2 = SC.typeOf(w);
-    var type1Index = SC.ORDER_DEFINITION.indexOf(type1);
-    var type2Index = SC.ORDER_DEFINITION.indexOf(type2);
+    
+    // If we haven't yet generated a reverse-mapping of SC.ORDER_DEFINITION,
+    // do so now.
+    var mapping = SC.ORDER_DEFINITION_MAPPING;
+    if (!mapping) {
+      var order = SC.ORDER_DEFINITION;
+      mapping = SC.ORDER_DEFINITION_MAPPING = {};
+      var idx, len;
+      for (idx = 0, len = order.length;  idx < len;  ++idx) {
+        mapping[order[idx]] = idx;
+      }
+      
+      // We no longer need SC.ORDER_DEFINITION.
+      delete SC.ORDER_DEFINITION;
+    }
+    
+    var type1Index = mapping[type1];
+    var type2Index = mapping[type2];
     
     if (type1Index < type2Index) return -1;
     if (type1Index > type2Index) return 1;
@@ -442,24 +461,28 @@ SC.mixin(/** @scope SC */ {
         return 0;
 
       case SC.T_STRING:
-        if (v.localeCompare(w)<0) return -1;
-        if (v.localeCompare(w)>0) return 1;
+        var comp = v.localeCompare(w);
+        if (comp<0) return -1;
+        if (comp>0) return 1;
         return 0;
 
       case SC.T_ARRAY:
-        var l = Math.min(v.length,w.length);
+        var vLen = v.length;
+        var wLen = w.length;
+        var l = Math.min(vLen, wLen);
         var r = 0;
         var i = 0;
+        var thisFunc = arguments.callee;
         while (r===0 && i < l) {
-          r = arguments.callee(v[i],w[i]);
-          if ( r !== 0 ) return r;
+          r = thisFunc(v[i],w[i]);
           i++;
         }
+        if (r !== 0) return r;
       
         // all elements are equal now
         // shorter array should be ordered first
-        if (v.length < w.length) return -1;
-        if (v.length > w.length) return 1;
+        if (vLen < wLen) return -1;
+        if (vLen > wLen) return 1;
         // arrays are equal now
         return 0;
         
@@ -956,8 +979,8 @@ SC.mixin(Function.prototype,
 */
 String.prototype.fmt = function() {
   // first, replace any ORDERED replacements.
-  var args = arguments;
-  var idx  = 0; // the current index for non-numerical replacements
+  var args = arguments,
+      idx  = 0; // the current index for non-numerical replacements
   return this.replace(/%@([0-9]+)?/g, function(s, argIndex) {
     argIndex = (argIndex) ? parseInt(argIndex,0)-1 : idx++ ;
     s =args[argIndex];
@@ -988,12 +1011,10 @@ String.prototype.loc = function() {
   @returns {Array} an array of non-empty strings
 */
 String.prototype.w = function() { 
-  var ary = [], ary2 = this.split(' '), len = ary2.length ;
-  for (var idx=0; idx<len; ++idx) {
-    var str = ary2[idx] ;
+  var ary = [], ary2 = this.split(' '), len = ary2.length, str, idx=0;
+  for (idx=0; idx<len; ++idx) {
+    str = ary2[idx] ;
     if (str.length !== 0) ary.push(str) ; // skip empty strings
   }
   return ary ;
 };
-
-

data/frameworks/sproutcore/frameworks/runtime/mixins/array.js

@@ -351,6 +351,12 @@ SC.Array = {
   addRangeObserver: function(indexes, target, method, context) {
     var rangeob = this._array_rangeObservers;
     if (!rangeob) rangeob = this._array_rangeObservers = SC.CoreSet.create() ;
+
+    // The first time a range observer is added, cache the current length so
+    // we can properly notify observers the first time through
+    if (this._array_oldLength===undefined) {
+      this._array_oldLength = this.get('length') ;
+    }
     
     var C = this.rangeObserverClass ;
     var isDeep = NO; //disable this feature for now

data/frameworks/sproutcore/frameworks/runtime/mixins/copyable.js

@@ -54,7 +54,7 @@ SC.Copyable = {
   frozenCopy: function() {
     var isFrozen = this.get ? this.get('isFrozen') : this.isFrozen;
     if (isFrozen === YES) return this;
-    else if (isFrozen === undefined) throw "%@ does not support freezing";
+    else if (isFrozen === undefined) throw "%@ does not support freezing".fmt(this);
     else return this.copy().freeze();
   }
 };

data/frameworks/sproutcore/frameworks/runtime/mixins/observable.js

@@ -275,8 +275,9 @@ SC.Observable = {
         cachedep, cache, idx, dfunc ;
 
     // if there are any dependent keys and they use caching, then clear the
-    // cache.
-    if (this._kvo_cacheable && (cache = this._kvo_cache)) {
+    // cache.  (If we're notifying, then propertyDidChange will do this for
+    // us.)
+    if (!notify && this._kvo_cacheable && (cache = this._kvo_cache)) {
       // lookup the cached dependents for this key.  if undefined, compute.
       // note that if cachdep is set to null is means we figure out it has no
       // cached dependencies already.  this is different from undefined.
@@ -720,7 +721,7 @@ SC.Observable = {
     }
     if (!target) target = this ;
     if (SC.typeOf(method) === SC.T_STRING) method = target[method] ;
-    if (!method) throw "You must pass a method to addObserver()" ;
+    if (!method) throw "You must pass a method to removeObserver()" ;
 
     // if the key contains a '.', this is a chained observer.
     key = key.toString() ;
@@ -808,18 +809,19 @@ SC.Observable = {
     if (this._observableInited) return ;
     this._observableInited = YES ;
     
-    var loc, keys, key, value, observer, propertyPaths, propertyPathsLength ;
+    var loc, keys, key, value, observer, propertyPaths, propertyPathsLength,
+        len, ploc, path, dotIndex, root, propertyKey, keysLen;
     
     // Loop through observer functions and register them
     if (keys = this._observers) {
-      var len = keys.length ;
+      len = keys.length ;
       for(loc=0;loc<len;loc++) {
         key = keys[loc]; observer = this[key] ;
         propertyPaths = observer.propertyPaths ;
         propertyPathsLength = (propertyPaths) ? propertyPaths.length : 0 ;
-        for(var ploc=0;ploc<propertyPathsLength;ploc++) {
-          var path = propertyPaths[ploc] ;
-          var dotIndex = path.indexOf('.') ;
+        for(ploc=0;ploc<propertyPathsLength;ploc++) {
+          path = propertyPaths[ploc] ;
+          dotIndex = path.indexOf('.') ;
           // handle most common case, observing a local property
           if (dotIndex < 0) {
             this.addObserver(path, this, observer) ;
@@ -832,7 +834,7 @@ SC.Observable = {
           // will add the observer now or later when the named path becomes
           // available.
           } else {
-            var root = null ;
+            root = null ;
             
             // handle special cases for observers that look to the local root
             if (dotIndex === 0) {
@@ -852,17 +854,17 @@ SC.Observable = {
     // Add Bindings
     this.bindings = []; // will be filled in by the bind() method.
     if (keys = this._bindings) {
-      for(loc=0;loc<keys.length;loc++) {
+      for(loc=0, keysLen = keys.length; loc < keysLen;loc++) {
         // get propertyKey
         key = keys[loc] ; value = this[key] ;
-        var propertyKey = key.slice(0,-7) ; // contentBinding => content
+        propertyKey = key.slice(0,-7) ; // contentBinding => content
         this[key] = this.bind(propertyKey, value) ;
       }
     }
 
     // Add Properties
     if (keys = this._properties) {
-      for(loc=0;loc<keys.length;loc++) {
+      for(loc=0, keysLen = keys.length; loc<keysLen;loc++) {
         key = keys[loc];
         if (value = this[key]) {
 
@@ -904,10 +906,10 @@ SC.Observable = {
     
     SC.Observers.flush(this) ; // hookup as many observers as possible.
 
-    var log = SC.LOG_OBSERVERS && !(this.LOG_OBSERVING===NO) ;
-    var observers, changes, dependents, starObservers, idx, keys, rev ;
-    var members, membersLength, member, memberLoc, target, method, loc, func ;
-    var context, spaces, cache ;
+    var log = SC.LOG_OBSERVERS && !(this.LOG_OBSERVING===NO),
+        observers, changes, dependents, starObservers, idx, keys, rev,
+        members, membersLength, member, memberLoc, target, method, loc, func,
+        context, spaces, cache ;
 
     if (log) {
       spaces = SC.KVO_SPACES = (SC.KVO_SPACES || '') + '  ';
@@ -1068,14 +1070,14 @@ SC.Observable = {
   */
   bind: function(toKey, target, method) {
 
-    var binding ;
+    var binding , pathType;
 
     // normalize...
     if (method !== undefined) target = [target, method];
 
     // if a string or array (i.e. tuple) is passed, convert this into a
     // binding.  If a binding default was provided, use that.
-    var pathType = SC.typeOf(target) ;
+    pathType = SC.typeOf(target) ;
     if (pathType === SC.T_STRING || pathType === SC.T_ARRAY) {
       binding = this[toKey + 'BindingDefault'] || SC.Binding;
       binding = binding.beget().from(target) ;
@@ -1098,30 +1100,31 @@ SC.Observable = {
     }
   */  
   didChangeFor: function(context) { 
-    
+    var valueCache, revisionCache, seenValues, seenRevisions, ret,
+        currentRevision, idx, key, value;
     context = SC.hashFor(context) ; // get a hash key we can use in caches.
     
     // setup caches...
-    var valueCache = this._kvo_didChange_valueCache ;
+    valueCache = this._kvo_didChange_valueCache ;
     if (!valueCache) valueCache = this._kvo_didChange_valueCache = {};
-    var revisionCache = this._kvo_didChange_revisionCache;
+    revisionCache = this._kvo_didChange_revisionCache;
     if (!revisionCache) revisionCache=this._kvo_didChange_revisionCache={};
 
     // get the cache of values and revisions already seen in this context
-    var seenValues = valueCache[context] || {} ;
-    var seenRevisions = revisionCache[context] || {} ;
+    seenValues = valueCache[context] || {} ;
+    seenRevisions = revisionCache[context] || {} ;
     
     // prepare too loop!
-    var ret = false ;
-    var currentRevision = this._kvo_revision || 0  ;
-    var idx = arguments.length ;
+    ret = false ;
+    currentRevision = this._kvo_revision || 0  ;
+    idx = arguments.length ;
     while(--idx >= 1) {  // NB: loop only to 1 to ignore context arg.
-      var key = arguments[idx];
+      key = arguments[idx];
       
       // has the kvo revision changed since the last time we did this?
       if (seenRevisions[key] != currentRevision) {
         // yes, check the value with the last seen value
-        var value = this.get(key) ;
+        value = this.get(key) ;
         if (seenValues[key] !== value) {
           ret = true ; // did change!
           seenValues[key] = value;
@@ -1206,9 +1209,9 @@ SC.Observable = {
     @returns {Array} Values of property keys.
   */
   getEach: function() {
-    var keys = SC.A(arguments) ;
-    var ret = [];
-    for(var idx=0; idx<keys.length;idx++) {
+    var keys = SC.A(arguments),
+        ret = [], idx, idxLen;
+    for(idx=0, idxLen = keys.length; idx < idxLen;idx++) {
       ret[ret.length] = this.getPath(keys[idx]);
     }
     return ret ;
@@ -1298,9 +1301,10 @@ SC.Observable = {
     @param {String...} propertyNames one or more property names
   */
   logProperty: function() {
-    var props = SC.$A(arguments) ;
-    for(var idx=0;idx<props.length; idx++) {
-      var prop = props[idx] ;
+    var props = SC.$A(arguments),
+        prop, propsLen, idx;
+    for(idx=0, propsLen = props.length; idx<propsLen; idx++) {
+      prop = props[idx] ;
       console.log('%@:%@: '.fmt(SC.guidFor(this), prop), this.get(prop)) ;
     }
   },
@@ -1314,5 +1318,20 @@ SC.logChange = function logChange(target, key, value) {
   console.log("CHANGE: %@[%@] => %@".fmt(target, key, target.get(key))) ;
 };
 
+/**
+  Retrieves a property from an object, using get() if the
+  object implements SC.Observable.
+
+  @param  {Object}  object  the object to query
+  @param  {String}  key the property to retrieve
+*/
+SC.mixin(SC, {
+  get: function(object, key) {
+    if (!object) return undefined;
+    if (object.get) return object.get(key);
+    return object[key];
+  }
+});
+
 // Make all Array's observable
 SC.mixin(Array.prototype, SC.Observable) ;

data/frameworks/sproutcore/frameworks/runtime/private/observer_set.js

@@ -28,8 +28,12 @@ SC.ObserverSet = {
   _membersCacheIsValid: NO,
   
   /**
-    adds the named target/method observer to the set.  The method must be
-    a function, not a string..
+    Adds the named target/method observer to the set.  The method must be
+    a function, not a string.
+    
+    Note that in debugging mode only, this method is overridden to also record
+    the name of the object and function that resulted in the target/method
+    being added.
   */
   add: function(target, method, context) {
     var targetGuid = (target) ? SC.guidFor(target) : "__this__";
@@ -48,7 +52,7 @@ SC.ObserverSet = {
     // implementation is intentionally lazy.
     if (context !== undefined) {
       var contexts = methods.contexts ;
-      if (!context) contexts = {};
+      if (!context) context = methods.contexts = {} ;
       contexts[SC.guidFor(method)] = context ;
     }
     

data/frameworks/sproutcore/frameworks/runtime/system/binding.js

@@ -296,8 +296,8 @@ SC.Binding = {
     Returns a builder function for compatibility.  
   */
   builder: function() {
-    var binding = this ;
-    var ret = function(fromProperty) { return binding.beget().from(fromProperty); };
+    var binding = this,
+        ret = function(fromProperty) { return binding.beget().from(fromProperty); };
     ret.beget = function() { return binding.beget(); } ;
     return ret ;
   },
@@ -376,8 +376,8 @@ SC.Binding = {
     if (!this._connectionPending) return; //nothing to do
     this._connectionPending = NO ;
 
-    var path, root ;
-    var bench = SC.BENCHMARK_BINDING_SETUP;
+    var path, root,
+        bench = SC.BENCHMARK_BINDING_SETUP;
 
     if (bench) SC.Benchmark.start("SC.Binding.connect()");
     
@@ -507,7 +507,7 @@ SC.Binding = {
   _computeBindingValue: function() {
     var source = this._bindingSource,
         key    = this._bindingKey,
-        v;
+        v, idx;
         
     if (!source) return ; // nothing to do
     this._bindingValue = v = source.getPath(key);
@@ -515,9 +515,10 @@ SC.Binding = {
     // apply any transforms to get the to property value also
     var transforms = this._transforms;
     if (transforms) {
-      var len = transforms.length ;
-      for(var idx=0;idx<len;idx++) {
-        var transform = transforms[idx] ;
+      var len = transforms.length,
+          transform;
+      for(idx=0;idx<len;idx++) {
+        transform = transforms[idx] ;
         v = transform(v, this) ;
       }
     }
@@ -547,11 +548,10 @@ SC.Binding = {
     this._isFlushing = YES ;
     SC.Observers.suspendPropertyObserving();
 
-    var didFlush = NO ;
-    var log = SC.LOG_BINDINGS ;
-    
-    // connect any bindings
-    var queue, binding ;
+    var didFlush = NO,
+        log = SC.LOG_BINDINGS,
+        // connect any bindings
+        queue, binding ;
     while((queue = this._connectQueue).length >0) {
       this._connectQueue = this._alternateConnectQueue ;
       this._alternateConnectQueue = queue ;
@@ -598,10 +598,10 @@ SC.Binding = {
     this._computeBindingTargets() ;
     this._computeBindingValue();
     
-    var v = this._bindingValue ;
-    var tv = this._transformedBindingValue ;
-    var bench = SC.BENCHMARK_BINDING_NOTIFICATIONS ;
-    var log = SC.LOG_BINDINGS ; 
+    var v = this._bindingValue,
+        tv = this._transformedBindingValue,
+        bench = SC.BENCHMARK_BINDING_NOTIFICATIONS,
+        log = SC.LOG_BINDINGS ; 
     
     // the from property value will always be the binding value, update if 
     // needed.
@@ -642,8 +642,8 @@ SC.Binding = {
     // we are connected, go ahead and sync
     } else {
       this._computeBindingTargets() ;
-      var target = this._fromTarget ;
-      var key = this._fromPropertyKey ;
+      var target = this._fromTarget,
+          key = this._fromPropertyKey ;
       if (!target || !key) return this ; // nothing to do
 
       // get the new value

data/frameworks/sproutcore/frameworks/runtime/system/logger.js

@@ -5,7 +5,7 @@
 
 /**
   If {@link SC.Logger.format} is true, this delimiter will be put between arguments.
-  
+
   @property {String}
 */
 SC.LOGGER_LOG_DELIMITER = ", ";
@@ -13,7 +13,7 @@ SC.LOGGER_LOG_DELIMITER = ", ";
 /**
   If {@link SC.Logger.error} falls back onto {@link SC.Logger.log}, this will be
   prepended to the output.
-  
+
   @property {String}
 */
 SC.LOGGER_LOG_ERROR = "ERROR: ";
@@ -21,7 +21,7 @@ SC.LOGGER_LOG_ERROR = "ERROR: ";
 /**
   If {@link SC.Logger.info} falls back onto {@link SC.Logger.log}, this will be
   prepended to the output.
-  
+
   @property {String}
 */
 SC.LOGGER_LOG_INFO = "INFO: ";
@@ -29,86 +29,102 @@ SC.LOGGER_LOG_INFO = "INFO: ";
 /**
   If {@link SC.Logger.warn} falls back onto {@link SC.Logger.log}, this will be
   prepended to the output.
-  
+
   @property {String}
 */
 SC.LOGGER_LOG_WARN = "WARNING: ";
 
+/**
+  If {@link SC.Logger.debug} falls back onto {@link SC.Logger.log}, this will be
+  prepended to the output.
+
+  @property {String}
+*/
+SC.LOGGER_LOG_DEBUG = "DEBUG: ";
+
 /** @class
-  
+
   Object to allow for safe logging actions, such as using the browser console.
-  
+
   The FireFox plugin Firebug was used as a function reference. Please see
   {@link <a href="http://getfirebug.com/logging.html">Firebug Logging Reference</a>}
   for further information.
-  
+
   @author Colin Campbell
+  @author Benedikt Böhm
   @extends SC.Object
   @since Sproutcore 1.0
   @see <a href="http://getfirebug.com/logging.html">Firebug Logging Reference</a>
 */
-SC.Logger = SC.Object.create({ 
-  
+SC.Logger = SC.Object.create({
+
   // ..........................................................
   // PROPERTIES
-  //   
-  
+  //
+
+  /**
+    Whether or not to enable debug logging.
+
+    @property: {Boolean}
+  */
+  debugEnabled: NO,
+
   /**
     Computed property that checks for the existence of the reporter object.
-    
+
     @property {Boolean}
   */
   exists: function() {
     return typeof(this.get('reporter')) !== 'undefined' && this.get('reporter') != null;
   }.property('reporter').cacheable(),
-  
+
   /**
     If console.log does not exist, SC.Logger will use window.alert instead.
-    
+
     This property is only used inside {@link SC.Logger.log}. If fallBackOnLog is
     false and you call a different function, an alert will not be opened.
-    
+
     @property {Boolean}
   */
   fallBackOnAlert: NO,
-  
+
   /**
     If some function, such as console.dir, does not exist,
     SC.Logger will try console.log if this is true.
-    
+
     @property {Boolean}
   */
   fallBackOnLog: YES,
-  
+
   /**
     Whether or not to format multiple arguments together
     or let the browser deal with that.
-    
+
     @property {Boolean}
   */
   format: YES,
-  
+
   /**
     The reporter is the object which implements the actual logging functions.
-    
+
     @default The browser's console
     @property {Object}
   */
   reporter: console,
-  
+
   // ..........................................................
   // METHODS
-  // 
+  //
 
   /**
     Log output to the console, but only if it exists.
-    
+
     @param {String|Array|Function|Object}
     @returns {Boolean} true if reporter.log exists, false otherwise
   */
   log: function() {
     var reporter = this.get('reporter');
-    
+
     // log through the reporter
     if (this.get('exists') && typeof(reporter.log) === "function") {
       if (this.get('format')) {
@@ -119,7 +135,7 @@ SC.Logger = SC.Object.create({
       }
       return true;
     }
-    
+
     // log through alert
     else if (this.fallBackOnAlert) {
       var s = this.get('format') ? this._argumentsToString.apply(this, arguments) : arguments;
@@ -135,40 +151,68 @@ SC.Logger = SC.Object.create({
     }
     return false;
   },
-  
+
+  /**
+    Log a debug message to the console.
+
+    Logs the response using {@link SC.Logger.log} if reporter.debug does not exist and
+    {@link SC.Logger.fallBackOnLog} is true.
+
+    @param {String|Array|Function|Object}
+    @returns {Boolean} true if logged to reporter, false if not
+  */
+  debug: function() {
+    var reporter = this.get('reporter');
+
+    if (this.get('debugEnabled') !== YES) {
+      return false;
+    }
+
+    if (this.get('exists') && (typeof reporter.debug === "function")) {
+      reporter.debug.apply(reporter, arguments);
+      return true;
+    }
+    else if (this.fallBackOnLog) {
+      var a = this._argumentsToArray(arguments);
+      if (typeof(a.unshift) === "function") a.unshift(SC.LOGGER_LOG_DEBUG);
+      return this.log.apply(this, a);
+    }
+    return false;
+  },
+
   /**
     Prints the properties of an object.
-    
+
     Logs the object using {@link SC.Logger.log} if the reporter.dir function does not exist and
     {@link SC.Logger.fallBackOnLog} is true.
-    
+
     @param {Object}
     @returns {Boolean} true if logged to console, false if not
   */
   dir: function() {
     var reporter = this.get('reporter');
-    
-  	if (this.get('exists') && typeof(reporter.dir) === "function") {
+
+    if (this.get('exists') && typeof(reporter.dir) === "function") {
       // Firebug's console.dir doesn't support multiple objects here
       // but maybe custom reporters will
-  	  reporter.dir.apply(reporter, arguments);
-  	  return true;
-	  }
-  	return (this.fallBackOnLog) ? this.log.apply(this, arguments) : false;
+      reporter.dir.apply(reporter, arguments);
+      return true;
+    }
+    return (this.fallBackOnLog) ? this.log.apply(this, arguments) : false;
   },
-  
+
   /**
     Prints an XML outline for any HTML or XML object.
-    
+
     Logs the object using {@link SC.Logger.log} if reporter.dirxml function does not exist and
     {@lnk SC.Logger.fallBackOnLog} is true.
-    
+
     @param {Object}
     @returns {Boolean} true if logged to reporter, false if not
   */
   dirxml: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.dirxml) === "function") {
       // Firebug's console.dirxml doesn't support multiple objects here
       // but maybe custom reporters will
@@ -177,19 +221,19 @@ SC.Logger = SC.Object.create({
     }
     return (this.fallBackOnLog) ? this.log.apply(this, arguments) : false;
   },
-  
+
   /**
     Log an error to the console
-    
+
     Logs the error using {@link SC.Logger.log} if reporter.error does not exist and
     {@link SC.Logger.fallBackOnLog} is true.
-    
+
     @param {String|Array|Function|Object}
     @returns {Boolean} true if logged to reporter, false if not
   */
   error: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.error) === "function") {
       reporter.error.apply(reporter, arguments);
       return true;
@@ -201,53 +245,53 @@ SC.Logger = SC.Object.create({
     }
     return false;
   },
-  
+
   /**
     Every log after this call until {@link SC.Logger.groupEnd} is called
     will be indented for readability. You can create as many levels
     as you want.
-    
+
     @param {String} [title] An optional title to display above the group
     @returns {Boolean} true if reporter.group exists, false otherwise
   */
   group: function(s) {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.group) === "function") {
       reporter.group(s);
       return true;
     }
     return false;
   },
-  
+
   /**
     Ends a group declared with {@link SC.Logger.group}.
-    
+
     @returns {Boolean} true if the reporter.groupEnd exists, false otherwise
     @see SC.Logger.group
   */
   groupEnd: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.groupEnd) === "function") {
       reporter.groupEnd();
       return true;
     }
     return false;
   },
-  
+
   /**
     Log an information response to the reporter.
-    
+
     Logs the response using {@link SC.Logger.log} if reporter.info does not exist and
     {@link SC.Logger.fallBackOnLog} is true.
-    
+
     @param {String|Array|Function|Object}
     @returns {Boolean} true if logged to reporter, false if not
   */
   info: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.info) === "function") {
       reporter.info.apply(reporter, arguments);
       return true;
@@ -259,101 +303,101 @@ SC.Logger = SC.Object.create({
     }
     return false;
   },
-  
+
   /**
     Begins the JavaScript profiler, if it exists. Call {@link SC.Logger.profileEnd}
     to end the profiling process and receive a report.
-    
+
     @returns {Boolean} true if reporter.profile exists, false otherwise
   */
   profile: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.profile) === "function") {
       reporter.profile();
       return true;
     }
     return false;
   },
-  
+
   /**
     Ends the JavaScript profiler, if it exists.
-    
+
     @returns {Boolean} true if reporter.profileEnd exists, false otherwise
     @see SC.Logger.profile
   */
   profileEnd: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.profileEnd) === "function") {
       reporter.profileEnd();
       return true;
     }
     return false;
   },
-  
+
   /**
     Measure the time between when this function is called and
     {@link SC.Logger.timeEnd} is called.
-    
+
     @param {String} name The name of the profile to begin
     @returns {Boolean} true if reporter.time exists, false otherwise
     @see SC.Logger.timeEnd
   */
   time: function(name) {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.time) === "function") {
       reporter.time(name);
       return true;
     }
     return false;
   },
-  
+
   /**
     Ends the profile specified.
-    
+
     @param {String} name The name of the profile to end
     @returns {Boolean} true if reporter.timeEnd exists, false otherwise
     @see SC.Logger.time
   */
   timeEnd: function(name) {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.timeEnd) === "function") {
       reporter.timeEnd(name);
       return true;
     }
     return false;
   },
-  
+
   /**
     Prints a stack-trace.
-    
+
     @returns {Boolean} true if reporter.trace exists, false otherwise
   */
   trace: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.trace) === "function") {
       reporter.trace();
       return true;
     }
     return false;
   },
-  
+
   /**
     Log a warning to the console.
-    
+
     Logs the warning using {@link SC.Logger.log} if reporter.warning does not exist and
     {@link SC.Logger.fallBackOnLog} is true.
-    
+
     @param {String|Array|Function|Object}
     @returns {Boolean} true if logged to reporter, false if not
   */
   warn: function() {
     var reporter = this.get('reporter');
-    
+
     if (this.get('exists') && typeof(reporter.warn) === "function") {
       reporter.warn.apply(reporter, arguments);
       return true;
@@ -365,17 +409,17 @@ SC.Logger = SC.Object.create({
     }
     return false;
   },
-  
+
   // ..........................................................
   // INTERNAL SUPPORT
-  // 
-  
+  //
+
   /**
     @private
-    
+
     The arguments function property doesn't support Array#unshift. This helper
     copies the elements of arguments to a blank array.
-    
+
     @param {Array} arguments The arguments property of a function
     @returns {Array} An array containing the elements of arguments parameter
   */
@@ -387,22 +431,22 @@ SC.Logger = SC.Object.create({
     }
     return a;
   },
-  
+
   /**
     @private
-    
+
     Formats the arguments array of a function by creating a string
     with SC.LOGGER_LOG_DELIMITER between the elements.
-    
+
     @returns {String} A string of formatted arguments
   */
   _argumentsToString: function() {
-  	var s = "";
-  	for (var i = 0; i<arguments.length - 1; i++) {
-  		s += arguments[i] + SC.LOGGER_LOG_DELIMITER;
-  	}
-  	s += arguments[arguments.length-1];
-  	return s;
+    var s = "";
+    for (var i = 0; i<arguments.length - 1; i++) {
+      s += arguments[i] + SC.LOGGER_LOG_DELIMITER;
+    }
+    s += arguments[arguments.length-1];
+    return s;
   }
-  
-});
+
+});