sproutcore 1.9.2 → 1.10.0.rc.1

data/lib/frameworks/sproutcore/frameworks/runtime/system/function.js

@@ -13,64 +13,64 @@ SC.Function = /** @scope SC.Function.prototype */{
   /**
     @see Function.prototype.property
   */
-  property: function(fn, keys) {
-    fn.dependentKeys = SC.$A(keys) ;
-    var guid = SC.guidFor(fn) ;
-    fn.cacheKey = "__cache__" + guid ;
-    fn.lastSetValueKey = "__lastValue__" + guid ;
-    fn.isProperty = true ;
-    return fn ;
+  property: function (fn, keys) {
+    fn.dependentKeys = SC.$A(keys);
+    var guid = SC.guidFor(fn);
+    fn.cacheKey = "__cache__" + guid;
+    fn.lastSetValueKey = "__lastValue__" + guid;
+    fn.isProperty = true;
+    return fn;
   },
 
   /**
     @see Function.prototype.cacheable
   */
-  cacheable: function(fn, aFlag) {
-    fn.isProperty = true ;  // also make a property just in case
-    if (!fn.dependentKeys) fn.dependentKeys = [] ;
-    fn.isCacheable = (aFlag === undefined) ? true : aFlag ;
-    return fn ;
+  cacheable: function (fn, aFlag) {
+    fn.isProperty = true;  // also make a property just in case
+    if (!fn.dependentKeys) fn.dependentKeys = [];
+    fn.isCacheable = (aFlag === undefined) ? true : aFlag;
+    return fn;
   },
 
   /**
     @see Function.prototype.idempotent
   */
-  idempotent: function(fn, aFlag) {
+  idempotent: function (fn, aFlag) {
     fn.isProperty = true;  // also make a property just in case
-    if (!fn.dependentKeys) this.dependentKeys = [] ;
-    fn.isVolatile = (aFlag === undefined) ? true : aFlag ;
-    return fn ;
+    if (!fn.dependentKeys) this.dependentKeys = [];
+    fn.isVolatile = (aFlag === undefined) ? true : aFlag;
+    return fn;
   },
 
   /**
     @see Function.prototype.enhance
   */
-  enhance: function(fn) {
+  enhance: function (fn) {
     fn.isEnhancement = true;
-    return fn ;
+    return fn;
   },
 
   /**
     @see Function.prototype.observes
   */
-  observes: function(fn, propertyPaths) {
+  observes: function (fn, propertyPaths) {
     // sort property paths into local paths (i.e just a property name) and
     // full paths (i.e. those with a . or * in them)
-    var loc = propertyPaths.length, local = null, paths = null ;
-    while(--loc >= 0) {
-      var path = propertyPaths[loc] ;
+    var loc = propertyPaths.length, local = null, paths = null;
+    while (--loc >= 0) {
+      var path = propertyPaths[loc];
       // local
-      if ((path.indexOf('.')<0) && (path.indexOf('*')<0)) {
-        if (!local) local = fn.localPropertyPaths = [] ;
+      if ((path.indexOf('.') < 0) && (path.indexOf('*') < 0)) {
+        if (!local) local = fn.localPropertyPaths = [];
         local.push(path);
 
       // regular
       } else {
-        if (!paths) paths = fn.propertyPaths = [] ;
-        paths.push(path) ;
+        if (!paths) paths = fn.propertyPaths = [];
+        paths.push(path);
       }
     }
-    return fn ;
+    return fn;
   }
 
 };

data/lib/frameworks/sproutcore/frameworks/runtime/system/index_set.js

@@ -5,8 +5,8 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-sc_require('mixins/enumerable') ;
-sc_require('mixins/observable') ;
+sc_require('mixins/enumerable');
+sc_require('mixins/observable');
 sc_require('mixins/freezable');
 sc_require('mixins/copyable');
 
@@ -20,16 +20,16 @@ sc_require('mixins/copyable');
   Examples
   ---
 
-        var set = SC.IndexSet.create(ranges) ;
+        var set = SC.IndexSet.create(ranges);
         set.contains(index);
         set.add(index, length);
         set.remove(index, length);
 
         // uses a backing SC.Array object to return each index
-        set.forEach(function(object) { .. })
+        set.forEach(function (object) { .. })
 
         // returns ranges
-        set.forEachRange(function(start, length) { .. });
+        set.forEachRange(function (start, length) { .. });
 
   Implementation Notes
   ---
@@ -46,24 +46,25 @@ sc_require('mixins/copyable');
   @since SproutCore 1.0
 */
 SC.IndexSet = SC.mixin({},
-  SC.Enumerable, SC.Observable, SC.Freezable, SC.Copyable,
+  SC.Observable, SC.Enumerable, SC.Freezable, SC.Copyable,
 /** @scope SC.IndexSet.prototype */ {
 
   /** @private
     Walks a content array and copies its contents to a new array.  For large
     content arrays this is faster than using slice()
   */
-  _sc_sliceContent: function(c) {
+  _sc_sliceContent: function (c) {
     if (c.length < 1000) return c.slice(); // use native when faster
     var cur = 0, ret = [], next = c[0];
     while(next !== 0) {
-      ret[cur] = next ;
-      cur = (next<0) ? (0-next) : next ;
+      ret[cur] = next;
+      cur = (next<0) ? (0-next) : next;
       next = c[cur];
     }
     ret[cur] = 0;
+
     this._hint(0, cur, ret); // hints are not copied manually - add them
-    return ret ;
+    return ret;
   },
 
   /**
@@ -73,7 +74,7 @@ SC.IndexSet = SC.mixin({},
     @param {Number} [length] The length of the range (by default set to 1 if start is a Number)
     @returns {SC.IndexSet}
   */
-  create: function(start, length) {
+  create: function (start, length) {
     var ret = SC.beget(this);
     ret.initObservable();
     ret.registerDependentKey('min', '[]');
@@ -84,7 +85,7 @@ SC.IndexSet = SC.mixin({},
     // This is here because `create` doesn't follow the
     // idiomatic SC convention of passing in an object literal to `create`.
     if (start && !(SC.typeOf(start) === SC.T_NUMBER || start.isIndexSet)) {
-      throw "SC.IndexSet does not accept `%@` as a parameter to `create`. Take a look at the function signature for proper usage.".fmt(start);
+      throw new Error("SC.IndexSet does not accept `%@` as a parameter to `create`. Take a look at the function signature for proper usage.".fmt(start));
     }
     // @endif
 
@@ -93,14 +94,14 @@ SC.IndexSet = SC.mixin({},
       ret._content = this._sc_sliceContent(start._content);
       ret.max = start.max;
       ret.length = start.length;
-      ret.source = start.source ;
+      ret.source = start.source;
 
     // otherwise just do a regular add
     } else {
       ret._content = [0];
       if (start !== undefined) ret.add(start, length);
     }
-    return ret ;
+    return ret;
   },
 
   /**
@@ -138,7 +139,7 @@ SC.IndexSet = SC.mixin({},
 
     @type Number
   */
-  min: function() {
+  min: function () {
     var content = this._content,
         cur = content[0];
     return (cur === 0) ? -1 : (cur>0) ? 0 : Math.abs(cur);
@@ -150,7 +151,7 @@ SC.IndexSet = SC.mixin({},
 
     @type Number
   */
-  firstObject: function() {
+  firstObject: function () {
     return (this.get('length')>0) ? this.get('min') : undefined;
   }.property(),
 
@@ -161,18 +162,22 @@ SC.IndexSet = SC.mixin({},
     @param {Number} index
     @returns {Number} starting index
   */
-  rangeStartForIndex: function(index) {
+  rangeStartForIndex: function (index) {
     var content = this._content,
         max     = this.get('max'),
         ret, next, accel;
 
     // fast cases
-    if (index >= max) return max ;
-    if (Math.abs(content[index]) > index) return index ; // we hit a border
+    if (index >= max) return max;
+    if (Math.abs(content[index]) > index) return index; // we hit a border
 
     // use accelerator to find nearest content range
     accel = index - (index % SC.IndexSet.HINT_SIZE);
     ret = content[accel];
+
+    // If there are no hints, we are in the infinite range.
+    if (SC.none(ret)) { ret = this._infRange; }
+
     if (ret<0 || ret>index) ret = accel;
     next = content[ret];
 
@@ -186,10 +191,10 @@ SC.IndexSet = SC.mixin({},
     // now step forward through ranges until we find one that includes the
     // index.
     while (next < index) {
-      ret = next ;
+      ret = next;
       next = Math.abs(content[ret]);
     }
-    return ret ;
+    return ret;
   },
 
   /**
@@ -199,10 +204,10 @@ SC.IndexSet = SC.mixin({},
     @param {Object} obj another object.
     @returns {Boolean}
   */
-  isEqual: function(obj) {
+  isEqual: function (obj) {
 
     // optimize for some special cases
-    if (obj === this) return YES ;
+    if (obj === this) return YES;
     if (!obj || !obj.isIndexSet || (obj.max !== this.max) || (obj.length !== this.length)) return NO;
 
     // ok, now we need to actually compare the ranges of the two.
@@ -212,11 +217,11 @@ SC.IndexSet = SC.mixin({},
         next     = lcontent[cur];
 
     do {
-      if (rcontent[cur] !== next) return NO ;
-      cur = Math.abs(next) ;
+      if (rcontent[cur] !== next) return NO;
+      cur = Math.abs(next);
       next = lcontent[cur];
     } while (cur !== 0);
-    return YES ;
+    return YES;
   },
 
   /**
@@ -226,9 +231,9 @@ SC.IndexSet = SC.mixin({},
     @param {Number} index index to check
     @returns {Number} index or -1
   */
-  indexBefore: function(index) {
+  indexBefore: function (index) {
 
-    if (index===0) return -1; // fast path
+    if (index === 0) return -1; // fast path
     index--; // start with previous index
 
     var content = this._content,
@@ -236,10 +241,12 @@ SC.IndexSet = SC.mixin({},
         start   = this.rangeStartForIndex(index);
     if (!content) return null;
 
+    if (!isFinite(start)) return index; // fast path
+
     // loop backwards until we find a range that is in the set.
     while((start===max) || (content[start]<0)) {
-      if (start === 0) return -1 ; // nothing before; just quit
-      index = start -1 ;
+      if (start === 0) return -1; // nothing before; just quit
+      index = start - 1;
       start = this.rangeStartForIndex(index);
     }
 
@@ -253,19 +260,19 @@ SC.IndexSet = SC.mixin({},
     @param {Number} index index to check
     @returns {Number} index or -1
   */
-  indexAfter: function(index) {
+  indexAfter: function (index) {
     var content = this._content,
         max     = this.get('max'),
-        start, next ;
-    if (!content || (index>=max)) return -1; // fast path
-    index++; // start with next index
+        start, next;
 
+    if (!content || (index >= max)) return -1; // fast path
+    index++; // start with next index
 
     // loop forwards until we find a range that is in the set.
     start = this.rangeStartForIndex(index);
     next  = content[start];
     while(next<0) {
-      if (next === 0) return -1 ; //nothing after; just quit
+      if (next === 0) return -1; //nothing after; just quit
       index = start = Math.abs(next);
       next  = content[start];
     }
@@ -280,29 +287,29 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional range length
     @returns {Boolean}
   */
-  contains: function(start, length) {
+  contains: function (start, length) {
     var content, cur, next, rstart, rnext;
 
     // normalize input
     if (length === undefined) {
-      if (start === null || start === undefined) return NO ;
+      if (start === null || start === undefined) return NO;
 
       if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
 
       // if passed an index set, check each receiver range
       } else if (start && start.isIndexSet) {
-        if (start === this) return YES ; // optimization
+        if (start === this) return YES; // optimization
 
-        content = start._content ;
-        cur = 0 ;
+        content = start._content;
+        cur = 0;
         next = content[cur];
         while (next !== 0) {
-          if ((next>0) && !this.contains(cur, next-cur)) return NO ;
+          if ((next>0) && !this.contains(cur, next-cur)) return NO;
           cur = Math.abs(next);
           next = content[cur];
         }
-        return YES ;
+        return YES;
 
       } else {
         length = start.length;
@@ -311,9 +318,13 @@ SC.IndexSet = SC.mixin({},
     }
 
     rstart = this.rangeStartForIndex(start);
-    rnext  = this._content[rstart];
+    if (isFinite(rstart)) {
+      rnext  = this._content[rstart];
 
-    return (rnext>0) && (rstart <= start) && (rnext >= (start+length));
+      return (rnext>0) && (rstart <= start) && (rnext >= (start+length));
+    } else {
+      return true;
+    }
   },
 
   /**
@@ -324,27 +335,27 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional range length
     @returns {Boolean}
   */
-  intersects: function(start, length) {
+  intersects: function (start, length) {
     var content, cur, next, lim;
 
     // normalize input
     if (length === undefined) {
       if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
 
       // if passed an index set, check each receiver range
       } else if (start && start.isIndexSet) {
-        if (start === this) return YES ; // optimization
+        if (start === this) return YES; // optimization
 
-        content = start._content ;
-        cur = 0 ;
+        content = start._content;
+        cur = 0;
         next = content[cur];
         while (next !== 0) {
-          if ((next>0) && this.intersects(cur, next-cur)) return YES ;
+          if ((next>0) && this.intersects(cur, next-cur)) return YES;
           cur = Math.abs(next);
           next = content[cur];
         }
-        return NO ;
+        return NO;
 
       } else {
         length = start.length;
@@ -358,11 +369,11 @@ SC.IndexSet = SC.mixin({},
     lim     = start + length;
     while (cur < lim) {
       if (next === 0) return NO; // no match and at end!
-      if ((next > 0) && (next > start)) return YES ; // found a match
+      if ((next > 0) && (next > start)) return YES; // found a match
       cur = Math.abs(next);
       next = content[cur];
     }
-    return NO ; // no match
+    return NO; // no match
   },
 
   /**
@@ -373,7 +384,7 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional range length
     @returns {SC.IndexSet} new index set
   */
-  without: function(start, length) {
+  without: function (start, length) {
     if (start === this) return SC.IndexSet.create(); // just need empty set
     return this.clone().remove(start, length);
   },
@@ -386,11 +397,11 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional length of range.
     @returns {SC.IndexSet} receiver
   */
-  replace: function(start, length) {
+  replace: function (start, length) {
 
     if (length === undefined) {
       if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
       } else if (start && start.isIndexSet) {
         this._content = this._sc_sliceContent(start._content);
         this.beginPropertyChanges()
@@ -399,7 +410,7 @@ SC.IndexSet = SC.mixin({},
           .set('source', start.source)
           .enumerableContentDidChange();
         this.endPropertyChanges();
-        return this ;
+        return this;
 
       } else {
         length = start.length;
@@ -410,7 +421,7 @@ SC.IndexSet = SC.mixin({},
     var oldlen = this.length;
     this._content.length=1;
     this._content[0] = 0;
-    this.length = this.max = 0 ; // reset without notifying since add()
+    this.length = this.max = 0; // reset without notifying since add()
     return this.add(start, length);
   },
 
@@ -418,11 +429,11 @@ SC.IndexSet = SC.mixin({},
     Adds the specified range of indexes to the set.  You can also pass another
     IndexSet to union the contents of the index set with the receiver.
 
-    @param {Number} start index, Range, or another IndexSet
-    @param {Number} length optional length of range.
+    @param {Number} start Start index, Range, or another IndexSet
+    @param {Number} [length=1] The length of range.
     @returns {SC.IndexSet} receiver
   */
-  add: function(start, length) {
+  add: function (start, length) {
 
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
@@ -435,26 +446,26 @@ SC.IndexSet = SC.mixin({},
 
       if (!content) return this; // nothing to do
 
-      cur = 0 ;
+      cur = 0;
       next = content[0];
       while(next !== 0) {
         if (next>0) this.add(cur, next-cur);
         cur = next<0 ? 0-next : next;
         next = content[cur];
       }
-      return this ;
+      return this;
 
     } else if (length === undefined) {
 
       if (start === null || start === undefined) {
         return this; // nothing to do
       } else if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
       } else {
         length = start.length;
         start = start.start;
       }
-    } else if (length === null) length = 1 ;
+    } else if (length === null) length = 1;
 
     // if no length - do nothing.
     if (length <= 0) return this;
@@ -462,9 +473,9 @@ SC.IndexSet = SC.mixin({},
     // special case - appending to end of set
     var max     = this.get('max'),
         oldmax  = max,
-        delta, value ;
+        delta, value;
 
-    content = this._content ;
+    content = this._content;
 
     if (start === max) {
 
@@ -476,8 +487,8 @@ SC.IndexSet = SC.mixin({},
         // just extend range at end
         if (next > 0) {
           delete content[max]; // no 0
-          content[cur] = max = start + length ;
-          start = cur ;
+          content[cur] = max = start + length;
+          start = cur;
 
         // previous range was not in set, just tack onto the end
         } else {
@@ -487,21 +498,21 @@ SC.IndexSet = SC.mixin({},
         content[start] = max = length;
       }
 
-      content[max] = 0 ;
+      content[max] = 0;
       this.set('max', max);
-      this.set('length', this.length + length) ;
-      length = max - start ;
+      this.set('length', this.length + length);
+      length = max - start;
 
     } else if (start > max) {
       content[max] = 0-start; // empty!
-      content[start] = start+length ;
+      content[start] = start+length;
       content[start+length] = 0; // set end
-      this.set('max', start + length) ;
-      this.set('length', this.length + length) ;
+      this.set('max', start + length);
+      this.set('length', this.length + length);
 
       // affected range goes from starting range to end of content.
-      length = start + length - max ;
-      start = max ;
+      length = start + length - max;
+      start = max;
 
     // otherwise, merge into existing range
     } else {
@@ -509,32 +520,32 @@ SC.IndexSet = SC.mixin({},
       // find nearest starting range.  split or join that range
       cur   = this.rangeStartForIndex(start);
       next  = content[cur];
-      max   = start + length ;
-      delta = 0 ;
+      max   = start + length;
+      delta = 0;
 
       // we are right on a boundary and we had a range or were the end, then
       // go back one more.
       if ((start>0) && (cur === start) && (next <= 0)) {
         cur = this.rangeStartForIndex(start-1);
-        next = content[cur] ;
+        next = content[cur];
       }
 
       // previous range is not in set.  splice it here
       if (next < 0) {
-        content[cur] = 0-start ;
+        content[cur] = 0-start;
 
         // if previous range extends beyond this range, splice afterwards also
         if (Math.abs(next) > max) {
           content[start] = 0-max;
-          content[max] = next ;
+          content[max] = next;
         } else content[start] = next;
 
       // previous range is in set.  merge the ranges
       } else {
-        start = cur ;
+        start = cur;
         if (next > max) {
-          // delta -= next - max ;
-          max = next ;
+          // delta -= next - max;
+          max = next;
         }
       }
 
@@ -548,21 +559,21 @@ SC.IndexSet = SC.mixin({},
         value = content[cur];
         if (value === 0) {
           content[max] = 0;
-          next = max ;
-          delta += max - cur ;
+          next = max;
+          delta += max - cur;
         } else {
           next  = Math.abs(value);
           if (next > max) {
-            content[max] = value ;
-            next = max ;
+            content[max] = value;
+            next = max;
           }
 
           // ok, cur range is entirely inside top range.
           // add to delta if needed
-          if (value < 0) delta += next - cur ;
+          if (value < 0) delta += next - cur;
         }
 
-        delete content[cur] ; // and remove range
+        delete content[cur]; // and remove range
         cur = next;
       }
 
@@ -570,18 +581,18 @@ SC.IndexSet = SC.mixin({},
       // merge in also - don't adjust delta because these aren't new indexes
       if ((cur = content[max]) > 0) {
         delete content[max];
-        max = cur ;
+        max = cur;
       }
 
       // finally set my own range.
-      content[start] = max ;
-      if (max > oldmax) this.set('max', max) ;
+      content[start] = max;
+      if (max > oldmax) this.set('max', max);
 
       // adjust length
       this.set('length', this.get('length') + delta);
 
       // compute hint range
-      length = max - start ;
+      length = max - start;
     }
 
     this._hint(start, length);
@@ -596,7 +607,7 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional length of range.
     @returns {SC.IndexSet} receiver
   */
-  remove: function(start, length) {
+  remove: function (start, length) {
 
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
@@ -606,7 +617,7 @@ SC.IndexSet = SC.mixin({},
         return this; // nothing to do
 
       } else if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
 
       // if passed an index set, just add each range in the index set.
       } else if (start.isIndexSet) {
@@ -625,7 +636,7 @@ SC.IndexSet = SC.mixin({},
     var max     = this.get('max'),
         oldmax  = max,
         content = this._content,
-        cur, next, delta, value, last ;
+        cur, next, delta, value, last;
 
     // if we're past the end, do nothing.
     if (start >= max) return this;
@@ -633,35 +644,44 @@ SC.IndexSet = SC.mixin({},
     // find nearest starting range.  split or join that range
     cur   = this.rangeStartForIndex(start);
     next  = content[cur];
-    last  = start + length ;
-    delta = 0 ;
+    last  = start + length;
+    delta = 0;
 
     // we are right on a boundary and we had a range or were the end, then
     // go back one more.
-    if ((start>0) && (cur === start) && (next > 0)) {
+    if ((start > 0) && (cur === start) && (next > 0)) {
       cur = this.rangeStartForIndex(start-1);
-      next = content[cur] ;
+      next = content[cur];
     }
 
     // previous range is in set.  splice it here
     if (next > 0) {
-      content[cur] = start ;
+      content[cur] = start;
 
       // if previous range extends beyond this range, splice afterwards also
       if (next > last) {
         content[start] = last;
-        content[last] = next ;
+        content[last] = next;
       } else content[start] = next;
 
     // previous range is not in set.  merge the ranges
     } else {
-      start = cur ;
+      start = cur;
       next  = Math.abs(next);
       if (next > last) {
-        last = next ;
+        last = next;
       }
     }
 
+    // If splicing into the infinite range, we have to add hints up to the start
+    // of the splice and adjust our pointer to the start of the infinite range.
+    if (!isFinite(next)) {
+      this._hint(cur, start - cur);
+
+      // Infinite range
+      this._infRange = last;
+    }
+
     // at this point there should be clean starting point for the range.
     // just walk the ranges, adding up the length delta and then removing
     // the range until we find a range that passes last
@@ -672,21 +692,21 @@ SC.IndexSet = SC.mixin({},
       value = content[cur];
       if (value === 0) {
         content[last] = 0;
-        next = last ;
+        next = last;
 
       } else {
         next  = Math.abs(value);
         if (next > last) {
-          content[last] = value ;
-          next = last ;
+          content[last] = value;
+          next = last;
         }
 
         // ok, cur range is entirely inside top range.
         // add to delta if needed
-        if (value > 0) delta += next - cur ;
+        if (value > 0) delta += next - cur;
       }
 
-      delete content[cur] ; // and remove range
+      delete content[cur]; // and remove range
       cur = next;
     }
 
@@ -694,24 +714,28 @@ SC.IndexSet = SC.mixin({},
     // merge in also - don't adjust delta because these aren't new indexes
     if ((cur = content[last]) < 0) {
       delete content[last];
-      last = Math.abs(cur) ;
+      last = Math.abs(cur);
     }
 
     // set my own range - if the next item is 0, then clear it.
     if (content[last] === 0) {
       delete content[last];
-      content[start] = 0 ;
+      content[start] = 0;
       this.set('max', start); //max has changed
 
     } else {
-      content[start] = 0-last ;
+      content[start] = 0-last;
     }
 
     // adjust length
-    this.set('length', this.get('length') - delta);
+    if (isFinite(delta)) {
+      this.set('length', this.get('length') - delta);
+    } else {
+      this.set('length', 0);
+    }
 
-    // compute hint range
-    length = last - start ;
+    // compute hint range.  Constrain it to the length of the content.
+    length = Math.min(content.length, last - start);
 
     this._hint(start, length);
     if (delta !== 0) this.enumerableContentDidChange();
@@ -723,28 +747,35 @@ SC.IndexSet = SC.mixin({},
     pointing to the nearest range start.  The passed range must start on a
     range boundary.  It can end anywhere.
   */
-  _hint: function(start, length, content) {
+  _hint: function (start, length, content) {
     if (content === undefined) content = this._content;
 
     var skip    = SC.IndexSet.HINT_SIZE,
         next    = Math.abs(content[start]), // start of next range
         loc     = start - (start % skip) + skip, // next hint loc
-        lim     = start + length ; // stop
+        lim     = start + length; // stop
 
     while (loc < lim) {
-      // make sure we are in current rnage
+      // make sure we are in current range
       while ((next !== 0) && (next <= loc)) {
-        start = next ;
-        next  = Math.abs(content[start]) ;
+        start = next;
+        next  = Math.abs(content[start]);
       }
 
       // past end
       if (next === 0) {
         delete content[loc];
 
+      } else if (!isFinite(next)) {
+        // We can't hint the infinite range the normal way.  Instead we have a
+        // single pointer to the start of the infinite range that we use when
+        // no hints exist.
+        this._infRange = start;
+        loc = Infinity;
+
       // do not change if on actual boundary
       } else if (loc !== start) {
-        content[loc] = start ;  // set hint
+        content[loc] = start;  // set hint
       }
 
       loc += skip;
@@ -754,12 +785,13 @@ SC.IndexSet = SC.mixin({},
   /**
     Clears the set
   */
-  clear: function() {
+  clear: function () {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
     var oldlen = this.length;
-    this._content.length=1;
+    this._content.length = 1;
     this._content[0] = 0;
+    this._infRange = null;
     this.set('length', 0).set('max', 0);
     if (oldlen > 0) this.enumerableContentDidChange();
   },
@@ -769,19 +801,19 @@ SC.IndexSet = SC.mixin({},
 
     @param {Enumerable} objects The list of ranges you want to add
   */
-  addEach: function(objects) {
+  addEach: function (objects) {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
     this.beginPropertyChanges();
-    var idx = objects.get('length') ;
+    var idx = objects.get('length');
     if (objects.isSCArray) {
-      while(--idx >= 0) this.add(objects.objectAt(idx)) ;
+      while(--idx >= 0) this.add(objects.objectAt(idx));
     } else if (objects.isEnumerable) {
-      objects.forEach(function(idx) { this.add(idx); }, this);
+      objects.forEach(function (idx) { this.add(idx); }, this);
     }
     this.endPropertyChanges();
 
-    return this ;
+    return this;
   },
 
   /**
@@ -789,27 +821,27 @@ SC.IndexSet = SC.mixin({},
 
     @param {Object...} objects The list of objects you want to remove
   */
-  removeEach: function(objects) {
+  removeEach: function (objects) {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
     this.beginPropertyChanges();
 
-    var idx = objects.get('length') ;
+    var idx = objects.get('length');
     if (objects.isSCArray) {
-      while(--idx >= 0) this.remove(objects.objectAt(idx)) ;
+      while(--idx >= 0) this.remove(objects.objectAt(idx));
     } else if (objects.isEnumerable) {
-      objects.forEach(function(idx) { this.remove(idx); }, this);
+      objects.forEach(function (idx) { this.remove(idx); }, this);
     }
 
     this.endPropertyChanges();
 
-    return this ;
+    return this;
   },
 
   /**
    Clones the set into a new set.
   */
-  clone: function() {
+  clone: function () {
     return SC.IndexSet.create(this);
   },
 
@@ -819,7 +851,7 @@ SC.IndexSet = SC.mixin({},
 
     @returns {String}
   */
-  inspect: function() {
+  inspect: function () {
     var content = this._content,
         len     = content.length,
         idx     = 0,
@@ -847,20 +879,20 @@ SC.IndexSet = SC.mixin({},
     @param {Object} target the object to call the callback on
     @returns {SC.IndexSet} receiver
   */
-  forEachRange: function(callback, target) {
+  forEachRange: function (callback, target) {
     var content = this._content,
         cur     = 0,
         next    = content[cur],
         source  = this.source;
 
-    if (target === undefined) target = null ;
+    if (target === undefined) target = null;
     while (next !== 0) {
       if (next > 0) callback.call(target, cur, next - cur, this, source);
       cur  = Math.abs(next);
       next = content[cur];
     }
 
-    return this ;
+    return this;
   },
 
   /**
@@ -873,7 +905,7 @@ SC.IndexSet = SC.mixin({},
     @param {Object} target
     @returns {SC.IndexSet} receiver
   */
-  forEachIn: function(start, length, callback, target) {
+  forEachIn: function (start, length, callback, target) {
     var content = this._content,
         cur     = 0,
         idx     = 0,
@@ -881,21 +913,21 @@ SC.IndexSet = SC.mixin({},
         source  = this.source,
         next    = content[cur];
 
-    if (target === undefined) target = null ;
+    if (target === undefined) target = null;
     while (next !== 0) {
-      if (cur < start) cur = start ; // skip forward
+      if (cur < start) cur = start; // skip forward
       while((cur < next) && (cur < lim)) {
         callback.call(target, cur++, idx++, this, source);
       }
 
       if (cur >= lim) {
-        cur = next = 0 ;
+        cur = next = 0;
       } else {
         cur  = Math.abs(next);
         next = content[cur];
       }
     }
-    return this ;
+    return this;
   },
 
   /**
@@ -905,9 +937,9 @@ SC.IndexSet = SC.mixin({},
     @param {Number} length optional range length
     @returns {Number} count of indexes
   */
-  lengthIn: function(start, length) {
+  lengthIn: function (start, length) {
 
-    var ret = 0 ;
+    var ret = 0;
 
     // normalize input
     if (length === undefined) {
@@ -915,11 +947,11 @@ SC.IndexSet = SC.mixin({},
         return 0; // nothing to do
 
       } else if (typeof start === SC.T_NUMBER) {
-        length = 1 ;
+        length = 1;
 
       // if passed an index set, just add each range in the index set.
       } else if (start.isIndexSet) {
-        start.forEachRange(function(start, length) {
+        start.forEachRange(function (start, length) {
           ret += this.lengthIn(start, length);
         }, this);
         return ret;
@@ -936,7 +968,7 @@ SC.IndexSet = SC.mixin({},
     var content = this._content,
         cur     = 0,
         next    = content[cur],
-        lim     = start + length ;
+        lim     = start + length;
 
     while (cur<lim && next !== 0) {
       if (next>0) {
@@ -946,7 +978,7 @@ SC.IndexSet = SC.mixin({},
       next = content[cur];
     }
 
-    return ret ;
+    return ret;
   },
 
   // ..........................................................
@@ -968,20 +1000,20 @@ SC.IndexSet = SC.mixin({},
     @param {Number} startAt optional starting point
     @returns {Number} found index or -1 if not in set
   */
-  indexOf: function(object, startAt) {
+  indexOf: function (object, startAt) {
     var source  = this.source;
-    if (!source) throw "%@.indexOf() requires source".fmt(this);
+    if (!source) throw new Error("%@.indexOf() requires source".fmt(this));
 
     var len     = source.get('length'),
 
         // start with the first index in the set
         content = this._content,
         cur     = content[0]<0 ? Math.abs(content[0]) : 0,
-        idx ;
+        idx;
 
     while(cur>=0 && cur<len) {
       idx = source.indexOf(object, cur);
-      if (idx<0) return -1 ; // not found in source
+      if (idx<0) return -1; // not found in source
       if (this.contains(idx)) return idx; // found in source and in set.
       cur = idx+1;
     }
@@ -997,19 +1029,19 @@ SC.IndexSet = SC.mixin({},
     @param {Number} startAt optional starting point
     @returns {Number} found index or -1 if not in set
   */
-  lastIndexOf: function(object, startAt) {
+  lastIndexOf: function (object, startAt) {
     var source  = this.source;
-    if (!source) throw "%@.lastIndexOf() requires source".fmt(this);
+    if (!source) throw new Error("%@.lastIndexOf() requires source".fmt(this));
 
     // start with the last index in the set
     var len     = source.get('length'),
         cur     = this.max-1,
-        idx ;
+        idx;
 
     if (cur >= len) cur = len-1;
     while (cur>=0) {
       idx = source.lastIndexOf(object, cur);
-      if (idx<0) return -1 ; // not found in source
+      if (idx<0) return -1; // not found in source
       if (this.contains(idx)) return idx; // found in source and in set.
       cur = idx+1;
     }
@@ -1030,16 +1062,16 @@ SC.IndexSet = SC.mixin({},
     @param {Object} target optional content. otherwise uses window
     @returns {SC.IndexSet} receiver
   */
-  forEachObject: function(callback, target) {
+  forEachObject: function (callback, target) {
     var source  = this.source;
-    if (!source) throw "%@.forEachObject() requires source".fmt(this);
+    if (!source) throw new Error("%@.forEachObject() requires source".fmt(this));
 
     var content = this._content,
         cur     = 0,
         idx     = 0,
         next    = content[cur];
 
-    if (target === undefined) target = null ;
+    if (target === undefined) target = null;
     while (next !== 0) {
 
       while(cur < next) {
@@ -1050,7 +1082,7 @@ SC.IndexSet = SC.mixin({},
       cur  = Math.abs(next);
       next = content[cur];
     }
-    return this ;
+    return this;
   },
 
   /**
@@ -1066,9 +1098,9 @@ SC.IndexSet = SC.mixin({},
        match is the only one
     @returns {SC.IndexSet} receiver
   */
-  addObject: function(object, firstOnly) {
+  addObject: function (object, firstOnly) {
     var source  = this.source;
-    if (!source) throw "%@.addObject() requires source".fmt(this);
+    if (!source) throw new Error("%@.addObject() requires source".fmt(this));
 
     var len = source.get('length'),
         cur = 0, idx;
@@ -1077,11 +1109,11 @@ SC.IndexSet = SC.mixin({},
       idx = source.indexOf(object, cur);
       if (idx >= 0) {
         this.add(idx);
-        if (firstOnly) return this ;
+        if (firstOnly) return this;
         cur = idx++;
-      } else return this ;
+      } else return this;
     }
-    return this ;
+    return this;
   },
 
   /**
@@ -1093,8 +1125,8 @@ SC.IndexSet = SC.mixin({},
        match is the only one
     @returns {SC.IndexSet} receiver
   */
-  addObjects: function(objects, firstOnly) {
-    objects.forEach(function(object) {
+  addObjects: function (objects, firstOnly) {
+    objects.forEach(function (object) {
       this.addObject(object, firstOnly);
     }, this);
     return this;
@@ -1113,9 +1145,9 @@ SC.IndexSet = SC.mixin({},
        match is the only one
     @returns {SC.IndexSet} receiver
   */
-  removeObject: function(object, firstOnly) {
+  removeObject: function (object, firstOnly) {
     var source  = this.source;
-    if (!source) throw "%@.removeObject() requires source".fmt(this);
+    if (!source) throw new Error("%@.removeObject() requires source".fmt(this));
 
     var len = source.get('length'),
         cur = 0, idx;
@@ -1124,11 +1156,11 @@ SC.IndexSet = SC.mixin({},
       idx = source.indexOf(object, cur);
       if (idx >= 0) {
         this.remove(idx);
-        if (firstOnly) return this ;
+        if (firstOnly) return this;
         cur = idx+1;
-      } else return this ;
+      } else return this;
     }
-    return this ;
+    return this;
   },
 
   /**
@@ -1140,8 +1172,8 @@ SC.IndexSet = SC.mixin({},
        match is the only one
     @returns {SC.IndexSet} receiver
   */
-  removeObjects: function(objects, firstOnly) {
-    objects.forEach(function(object) {
+  removeObjects: function (objects, firstOnly) {
+    objects.forEach(function (object) {
       this.removeObject(object, firstOnly);
     }, this);
     return this;
@@ -1161,37 +1193,41 @@ SC.IndexSet = SC.mixin({},
   LOG_OBSERVING: NO,
 
   /** @private - optimized call to forEach() */
-  forEach: function(callback, target) {
+  forEach: function (callback, target) {
     var content = this._content,
         cur     = 0,
         idx     = 0,
         source  = this.source,
         next    = content[cur];
 
-    if (target === undefined) target = null ;
+    if (target === undefined) target = null;
     while (next !== 0) {
-      while(cur < next) {
-        callback.call(target, cur++, idx++, this, source);
+      if (isFinite(next)) {
+        while(cur < next) {
+          callback.call(target, cur++, idx++, this, source);
+        }
+        cur  = Math.abs(next);
+        next = content[cur];
+      } else {
+        throw new Error("Developer Error: You may not iterate an infinite range in SC.IndexSet.");
       }
-      cur  = Math.abs(next);
-      next = content[cur];
     }
-    return this ;
+    return this;
   },
 
   /** @private - support iterators */
-  nextObject: function(ignore, idx, context) {
+  nextObject: function (ignore, idx, context) {
     var content = this._content,
         next    = context.next,
         max     = this.get('max'); // next boundary
 
     // seed.
     if (idx === null) {
-      idx = next = 0 ;
+      idx = next = 0;
 
     } else if (idx >= max) {
       delete context.next; // cleanup context
-      return null ; // nothing left to do
+      return null; // nothing left to do
 
     } else idx++; // look on next index
 
@@ -1207,17 +1243,17 @@ SC.IndexSet = SC.mixin({},
     return idx;
   },
 
-  toString: function() {
+  toString: function () {
     var str = [];
-    this.forEachRange(function(start, length) {
+    this.forEachRange(function (start, length) {
       str.push(length === 1 ? start : "%@..%@".fmt(start, start + length - 1));
     }, this);
-    return "SC.IndexSet<%@>".fmt(str.join(',')) ;
+    return "SC.IndexSet<%@>".fmt(str.join(','));
   },
 
   max: 0
 
-}) ;
+});
 
-SC.IndexSet.slice = SC.IndexSet.copy = SC.IndexSet.clone ;
+SC.IndexSet.slice = SC.IndexSet.copy = SC.IndexSet.clone;
 SC.IndexSet.EMPTY = SC.IndexSet.create().freeze();