sproutcore 1.9.2 → 1.10.0.rc.1

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

@@ -20,11 +20,11 @@ function iter(s) {
 
 // ..........................................................
 // BASIC ADDS
-// 
+//
 
 test("add range to end of set", function() {
   set.add(1000,5);
-  equals(set.get('length'), 5, 'should have correct index count');  
+  equals(set.get('length'), 5, 'should have correct index count');
   equals(set.get('max'), 1005, 'max should return 1 past last index');
   same(iter(set), [1000,1001,1002,1003,1004]);
 });
@@ -32,7 +32,7 @@ test("add range to end of set", function() {
 test("add range into middle of empty range", function() {
   set.add(100,2); // add initial set.
   equals(iter(set)[0], 100, 'precond - first index is 100');
-  
+
   // now add second range
   set.add(10,1);
   equals(set.get('length'), 3, 'should have extra length');
@@ -43,7 +43,7 @@ test("add range into middle of empty range", function() {
 test("add range overlapping front edge of range", function() {
   set.add(100,2); // add initial set.
   equals(iter(set)[0], 100, 'precond - first index is 100');
-  
+
   // now add second range
   set.add(99,2);
   equals(set.get('length'), 3, 'should have extra length');
@@ -54,7 +54,7 @@ test("add range overlapping front edge of range", function() {
 test("add range overlapping last edge of range", function() {
   set.add(100,2).add(200,2);
   same(iter(set), [100,101,200,201], 'should have two sets');
-  
+
   // now add overlapping range
   set.add(101,2);
   equals(set.get('length'), 5, 'new set.length');
@@ -65,7 +65,7 @@ test("add range overlapping last edge of range", function() {
 test("add range overlapping two ranges, merging into one", function() {
   set.add(100,2).add(110,2);
   same(iter(set), [100,101,110,111], 'should have two sets');
-  
+
   // now add overlapping range
   set.add(101,10);
   equals(set.get('length'), 12, 'new set.length');
@@ -76,7 +76,7 @@ test("add range overlapping two ranges, merging into one", function() {
 test("add range overlapping three ranges, merging into one", function() {
   set.add(100,2).add(105,2).add(110,2);
   same(iter(set), [100,101,105,106,110,111], 'should have two sets');
-  
+
   // now add overlapping range
   set.add(101,10);
   equals(set.get('length'), 12, 'new set.length');
@@ -84,10 +84,10 @@ test("add range overlapping three ranges, merging into one", function() {
   same(iter(set), [100,101,102,103,104,105,106,107,108,109,110,111], 'should include one range 100-111');
 });
 
-test("add range partially overlapping one range and replaing another range, merging into one", function() {
+test("add range partially overlapping one range and replacing another range, merging into one", function() {
   set.add(100,2).add(105,2);
   same(iter(set), [100,101,105,106], 'should have two sets');
-  
+
   // now add overlapping range
   set.add(101,10);
   equals(set.get('length'), 11, 'new set.length');
@@ -99,7 +99,7 @@ test("add range partially overlapping one range and replaing another range, merg
 test("add range overlapping last index", function() {
   set.add(100,2); // add initial set.
   equals(iter(set)[0], 100, 'precond - first index is 100');
-  
+
   // now add second range
   set.add(101,2);
   equals(set.get('length'), 3, 'should have extra length');
@@ -110,17 +110,17 @@ test("add range overlapping last index", function() {
 test("add range matching existing range", function() {
   set.add(100,5); // add initial set.
   equals(iter(set)[0], 100, 'precond - first index is 100');
-  
+
   // now add second range
   set.add(100,5);
   equals(set.get('length'), 5, 'should not change');
   equals(set.get('max'), 105, 'max should return 1 past last index');
-  same(iter(set), [100, 101, 102, 103, 104]);  
+  same(iter(set), [100, 101, 102, 103, 104]);
 });
 
 // ..........................................................
 // NORMALIZED PARAMETER CASES
-// 
+//
 
 test("add with no params should do nothing", function() {
   set.add();
@@ -144,7 +144,7 @@ test("add with index set should add indexes in set", function() {
 
 // ..........................................................
 // OTHER BEHAVIORS
-// 
+//
 
 test("adding a range should trigger an observer notification", function() {
   var callCnt = 0;
@@ -171,7 +171,7 @@ test("appending a range to end should merge into last range", function() {
   equals(set.rangeStartForIndex(3990), 2000, 'last two range should merge together (%@)'.fmt(set.inspect()));
   equals(set.get('max'), 4000, 'should have max');
   equals(set.get('length'), 2000, 'should have length');
-  
+
 });
 
 test("appending range to start of empty set should create a single range", function() {
@@ -179,34 +179,34 @@ test("appending range to start of empty set should create a single range", funct
   equals(set.rangeStartForIndex(1), 0, 'should have single range (%@)'.fmt(set.inspect()));
   equals(set.get('length'), 2, 'should have length');
   equals(set.get('max'), 2, 'should have max');
-  
+
   set = SC.IndexSet.create().add(0,2000);
   equals(set.rangeStartForIndex(1998), 0, 'should have single range (%@)'.fmt(set.inspect()));
   equals(set.get('length'), 2000, 'should have length');
   equals(set.get('max'), 2000, 'should have max');
-  
+
 });
 
 test("add raises exception when frozen", function() {
   should_throw(function() {
-    set.freeze().add(0,2);    
-  }, SC.FROZEN_ERROR);  
+    set.freeze().add(0,2);
+  }, SC.FROZEN_ERROR);
 });
 
 // ..........................................................
 // SPECIAL CASES
-// 
+//
 // demonstrate fixes for specific bugs here.
 
 test("adding in the same range should keep length consistent", function() {
   set = SC.IndexSet.create();
   set.add(1,4);
   equals(set.length, 4, 'set length should be 4');
-  
+
   set.add(1,3); // should be like a no-op
   equals(set.length, 4, 'set length should remain 4 after set.add(1,3)');
 
   set.add(1,2); // should be like a no-op
   equals(set.length, 4, 'set length should remain 4 after set.add(1,2)');
-  
+
 });

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

@@ -0,0 +1,184 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*global module test equals ok */
+
+
+var set;
+
+module("SC.IndexSet Infinite Ranges", {
+  setup: function () {
+    set = SC.IndexSet.create();
+  }
+});
+
+
+test("Able to add an infinite range.", function () {
+  set.add(100, Infinity);
+
+  equals(set.get('length'), Infinity, 'The length should be');
+  equals(set.get('max'), Infinity, 'The max index should be');
+});
+
+test("The infinite range contains all indexes.", function () {
+  set.add(100, 2000);
+  set.add(5000, Infinity);
+
+  ok(!set.contains(99), "The set does not contain 99.");
+  ok(set.contains(100), "The set does contain 100.");
+  ok(set.contains(2099), "The set does contain 2099.");
+  ok(!set.contains(4999), "The set does not contain 4999.");
+  ok(set.contains(5000), "The set does contain 5000.");
+  ok(set.contains(99999999999), "The set does contain 99999999999.");
+  ok(set.contains(Number.MAX_VALUE), "The set does contain Number.MAX_VALUE.");
+  ok(set.contains(Infinity), "The set does contain Infinity.");
+});
+
+test("Able to remove an infinite range.", function () {
+  set.add(100, Infinity);
+  set.remove(1000, Infinity);
+
+  ok(set.contains(900), "The set does contain 900.");
+  ok(!set.contains(1000), "The set does not contain 1000.");
+  ok(!set.contains(Infinity), "The set does not contain Infinity.");
+});
+
+test("Attempting to iterate over an infinite range throws an exception.", function () {
+  set.add(0, Infinity);
+
+  try {
+    set.forEach(function () { });
+  } catch (ex) {
+    ok(true, 'forEach threw an exception.');
+  }
+});
+
+test("Able to add an infinite range over an existing range.", function () {
+  set.add(100, 2); // add initial set.
+  equals(set.firstObject(), 100, 'The first index is');
+  equals(set.get('length'), 2, 'The length should be');
+  equals(set.get('max'), 102, 'The max index should be');
+
+  set.add(50, Infinity);
+  equals(set.firstObject(), 50, 'The first index is now');
+  equals(set.get('length'), Infinity, 'The length should now be');
+  equals(set.get('max'), Infinity, 'The max index should now be');
+});
+
+test("Infinite ranges may be equal.", function () {
+  var secondSet = SC.IndexSet.create();
+
+  set.add(50, Infinity);
+  secondSet.add(50, Infinity);
+  ok(set.isEqual(secondSet), 'The two infinite sets are equal.');
+
+  secondSet.add(10, 10);
+  ok(!set.isEqual(secondSet), 'The two infinite sets are no longer equal.');
+});
+
+test("The range start for the infinite range is correct.", function () {
+  set.add(100, 2000);
+
+  equals(set.rangeStartForIndex(1234), 100, "The range for 1234 starts at");
+  equals(set.rangeStartForIndex(2234), 2100, "The range for 2234 starts at");
+  equals(set.rangeStartForIndex(99999999999), 2100, "The range for 99999999999 starts at");
+  equals(set.rangeStartForIndex(Number.MAX_VALUE), 2100, "The range for Number.MAX_VALUE starts at");
+  equals(set.rangeStartForIndex(Infinity), 2100, "The range for Infinity starts at");
+
+  set.add(5000, Infinity);
+
+  equals(set.rangeStartForIndex(1234), 100, "The range for 1234 starts at");
+  equals(set.rangeStartForIndex(2234), 2100, "The range for 2234 starts at");
+  equals(set.rangeStartForIndex(99999999999), 5000, "The range for 99999999999 starts at");
+  equals(set.rangeStartForIndex(Number.MAX_VALUE), 5000, "The range for Number.MAX_VALUE starts at");
+  equals(set.rangeStartForIndex(Infinity), Infinity, "The range for Infinity starts at");
+});
+
+test("The indexBefore for the infinite range is correct.", function () {
+  set.add(10, 10);
+
+  equals(set.indexBefore(100), 19, "The indexBefore 100 is");
+  equals(set.indexBefore(Infinity), 19, "The indexBefore Infinity is");
+
+  set.add(50, Infinity);
+
+  equals(set.indexBefore(100), 99, "The indexBefore 100 is");
+  equals(set.indexBefore(Infinity), Infinity, "The indexBefore Infinity is");
+});
+
+test("The indexAfter for the infinite range is correct.", function () {
+  set.add(10, 1000);
+
+  equals(set.indexAfter(100), 101, "The indexAfter 100 is");
+  equals(set.indexAfter(2000), -1, "The indexAfter 2000 is");
+  equals(set.indexAfter(Infinity), -1, "The indexAfter Infinity is");
+
+  set.add(5000, Infinity);
+
+  equals(set.indexAfter(100), 101, "The indexAfter 100 is");
+  equals(set.indexAfter(2000), 5000, "The indexAfter 2000 is");
+  equals(set.indexAfter(Infinity), -1, "The indexAfter Infinity is");
+});
+
+test("The infinite range intersects all indexes.", function () {
+  set.add(100, 2000);
+  set.add(5000, Infinity);
+
+  ok(!set.intersects(0, 99), "The set does not intersect 0 - 99.");
+  ok(set.intersects(99, 2), "The set does intersect 99 - 101.");
+  ok(!set.intersects(2100, 99), "The set does not intersect 2100 - 2199.");
+  ok(set.intersects(4999, 2), "The set does intersect 4999 - 5001.");
+  ok(set.intersects(99999999999, 900000000000), "The set does intersect 99999999999 - 999999999999.");
+  ok(set.intersects(0, Number.MAX_VALUE), "The set does intersect 0 - Number.MAX_VALUE.");
+  ok(set.intersects(0, Infinity), "The set does intersect 0 - Infinity.");
+});
+
+test("The infinite range works with without().", function () {
+  set.add(100, 2000);
+  set.add(5000, Infinity);
+
+  set = set.without(10000, 1000);
+
+  ok(set.contains(9999), "The set does contain 9999.");
+  ok(!set.contains(10000), "The set does not contain 10000.");
+  ok(set.contains(11000), "The set does contain 11000.");
+
+  set = set.without(99999, 900000);
+
+  ok(set.contains(99998), "The set does contain 99998.");
+  ok(!set.contains(99999), "The set does not contain 99999.");
+  ok(set.contains(10000000), "The set does contain 10000000.");
+
+  // Hinting makes this too slow to use.
+  // set = set.without(0, Number.MAX_VALUE);
+  //
+  // ok(!set.contains(Number.MAX_VALUE), "The set does not contain Number.MAX_VALUE.");
+  // ok(set.contains(Infinity), "The set does contain Infinity.");
+
+  set = set.without(0, Infinity);
+
+  ok(!set.contains(Number.MAX_VALUE), "The set does not contain Number.MAX_VALUE.");
+  ok(!set.contains(Infinity), "The set does not contain Infinity.");
+});
+
+test("The infinite range works with replace().", function () {
+  set.add(100, 2000);
+  set.add(5000, Infinity);
+
+  set = set.replace(10000, 1000);
+
+  ok(!set.contains(9999), "The set does not contain 9999.");
+  ok(set.contains(10000), "The set does contain 10000.");
+  ok(!set.contains(11000), "The set does not contain 11000.");
+  ok(!set.contains(Infinity), "The set does not contain Infinity.");
+
+  set = set.replace(10000, Infinity);
+
+  ok(!set.contains(9999), "The set does not contain 9999.");
+  ok(set.contains(10000), "The set does contain 10000.");
+  ok(set.contains(Number.MAX_VALUE), "The set does contain Number.MAX_VALUE.");
+  ok(set.contains(Infinity), "The set does contain Infinity.");
+});
+

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/observer_set.js

@@ -17,7 +17,7 @@ module("Problematic SC.ObserverSet.getMethods() removal", {
   }
 });
 
-// This test succeeds using master up to commit 5826c745874f903f1e4765e5a2bcb5244ff72113 and using the 1-4-stable HEAD 
+// This test succeeds using master up to commit 5826c745874f903f1e4765e5a2bcb5244ff72113 and using the 1-4-stable HEAD
 // This test fails using subsequent master commit c78e1bf25087a3ebd553dbc513923e0d32d09f7b
 // It triggers an error at line 987 of frameworks/system/runtime/mixins/observable.js (in the method
 // SC.Observable._notifyPropertyObservers()) as of current master commit, 789fe805cd08976b7aab1c346c71cf22b78b7285
@@ -54,3 +54,65 @@ test("Observers that remove themselves should fire at least once, and shouldn't
   ok(observerFired, "At least one observer should have fired.");
 });
 
+/**
+  This test highlights a problem with SC.ObserverSet.  It would clear out the
+  method tracking on the target tracking hash, but when the number of methods
+  tracked went to zero, it never cleared out the target.
+
+  This is bad if a core object is bound to repeatedly by dynamically created
+  objects.  Each new object tracking creates a new hash in the observer set
+  that is never reclaimed.
+
+  Here's an example that would create 3,000 empty hashes in
+  coreOb._kvo_observers_key._members:
+
+    obs = [];
+    window.coreOb = SC.Object.create({ key: '1' });
+    SC.run(function() {
+      for (var i = 2999; i >= 0; i--) {
+        obs.push(SC.Object.create({ myKeyBinding: SC.Binding.from('coreOb.key') }));
+      }
+    });
+
+    SC.run(function() {
+      for (var i = obs.length - 1; i >= 0; i--) {
+        obs.pop().destroy();
+      }
+    });
+
+
+  The fix is to have SC.ObserverSet remove the target hash when the number of
+  methods for the target goes to zero.
+*/
+test("Removing all the methods on a target should clear the internal tracking of that target", function() {
+  var methodGuid1, methodGuid2,
+    target = {},
+    method1 = function () { }, method2 = function () { },
+    observerSet,
+    targetGuid;
+
+  observerSet = SC.ObserverSet.create();
+
+  targetGuid = SC.guidFor(target);
+  methodGuid1 = SC.guidFor(method1);
+  methodGuid2 = SC.guidFor(method2);
+
+  equals(observerSet.members.length, 0, "The ObserverSet should have a members length of");
+
+  observerSet.add(target, method1);
+  observerSet.add(target, method2);
+  equals(observerSet.members.length, 2, "The ObserverSet should have a members length of");
+  ok(observerSet._members[targetGuid], "The ObserverSet should be tracking methods for the target: %@".fmt(targetGuid));
+  ok(!SC.none(observerSet._members[targetGuid][methodGuid1]), "The ObserverSet should be tracking method: %@ for the target: %@".fmt(methodGuid1, targetGuid));
+  ok(!SC.none(observerSet._members[targetGuid][methodGuid2]), "The ObserverSet should be tracking method: %@ for the target: %@".fmt(methodGuid2, targetGuid));
+
+  observerSet.remove(target, method1);
+  equals(observerSet.members.length, 1, "The ObserverSet should have a members length of");
+  ok(observerSet._members[targetGuid], "The ObserverSet should be tracking methods for the target: %@".fmt(targetGuid));
+  ok(SC.none(observerSet._members[targetGuid][methodGuid1]), "The ObserverSet should not be tracking method: %@ for the target: %@".fmt(methodGuid1, targetGuid));
+  ok(!SC.none(observerSet._members[targetGuid][methodGuid2]), "The ObserverSet should be tracking method: %@ for the target: %@".fmt(methodGuid2, targetGuid));
+
+  observerSet.remove(target, method2);
+  equals(observerSet.members.length, 0, "The ObserverSet should have a members length of");
+  ok(!observerSet._members[targetGuid], "The ObserverSet should not be tracking methods for the target: %@".fmt(targetGuid));
+});

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/run_loop.js

@@ -6,22 +6,22 @@
 // ==========================================================================
 module("System:run_loop() - chained binding", {
   setup: function() {
-    first = SC.Object.create({ 
-		output: 'first' 
+    first = SC.Object.create({
+		output: 'first'
 	}) ;
-    
-	second = SC.Object.create({ 
+
+	second = SC.Object.create({
       input: 'second',
       output: 'second',
-      
+
       inputDidChange: function() {
         this.set("output", this.get("input")) ;
-      }.observes("input") 
+      }.observes("input")
 
     }) ;
-    
-    third = SC.Object.create({ 
-		input: "third" 
+
+    third = SC.Object.create({
+		input: "third"
 	}) ;
   }
 });
@@ -30,26 +30,26 @@ test("Should propagate bindings after the RunLoop completes (using SC.RunLoop)",
 	SC.RunLoop.begin();
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
-    	
+
 		//Binding of output of second object to input of third object
 		binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
-		
+
 		SC.Binding.flushPendingChanges() ; // actually sets up the connection
-		
+
 		//Based on the above binding if you change the output of first object it should
 		//change the all the variable of first,second and third object
 		first.set("output", "change") ;
-		
+
 		//Changes the output of the first object
 		equals(first.get("output"), "change") ;
-		
+
 		//since binding has not taken into effect the value still remains as change.
 		equals(second.get("output"), "first") ;
 	SC.RunLoop.end(); // allows bindings to trigger...
-	
+
 	//Value of the output variable changed to 'change'
 	equals(first.get("output"), "change") ;
-	
+
 	//Since binding triggered after the end loop the value changed to 'change'.
 	equals(second.get("output"), "change") ;
 });
@@ -58,27 +58,27 @@ test("Should propagate bindings after the RunLoop completes (using SC.beginRunLo
 	SC.beginRunLoop;
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
-    	
+
 		//Binding of output of second object to input of third object
 		binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
-		
+
 		SC.Binding.flushPendingChanges() ; // actually sets up the connection
-		
+
 		//Based on the above binding if you change the output of first object it should
 		//change the all the variable of first,second and third object
 		first.set("output", "change") ;
-		
+
 		//Changes the output of the first object
 		equals(first.get("output"), "change") ;
-		
+
 		//since binding has not taken into effect the value still remains as change.
 		equals(second.get("output"), "first") ;
 	SC.endRunLoop; // allows bindings to trigger...
 	SC.Binding.flushPendingChanges() ; // actually sets up the connection
-	
+
 	//Value of the output variable changed to 'change'
 	equals(first.get("output"), "change") ;
-	
+
 	//Since binding triggered after the end loop the value changed to 'change'.
 	equals(second.get("output"), "change") ;
 });
@@ -87,42 +87,42 @@ test("Should propagate bindings after the RunLoop completes (checking invokeOnce
 	SC.RunLoop.begin();
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
-    	
+
 		//Binding of output of second object to input of third object
 		binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
-		
+
 		SC.Binding.flushPendingChanges() ; // actually sets up the connection
-		
+
 		//Based on the above binding if you change the output of first object it should
 		//change the all the variable of first,second and third object
 		first.set("output", "change") ;
-		
+
 		//Changes the output of the first object
 		equals(first.get("output"), "change") ;
-		
+
 		//since binding has not taken into effect the value still remains as change.
 		equals(second.get("output"), "first") ;
-		
+
 		// Call the invokeOnce function to set the function which needs to be called once
 		second.invokeOnce('second','inputDidChange');
-		
+
 	SC.RunLoop.end(); // allows bindings to trigger...
-	
+
 	//Value of the output variable changed to 'change'
 	equals(first.get("output"), "change") ;
-	
+
 	//Since binding triggered after the end loop the value changed to 'change'.
 	equals(second.get("output"), "change") ;
-	
+
 	//Set the output for the first so that the 'inputDidChange' function in the second object is called again
 	first.set("output", "againChanged") ;
-	
+
 	//Value of the output variable changed to 'change'
 	equals(first.get("output"), "againChanged") ;
-	
+
 	//Since the invoker function is called only once the value of output did not change.
 	equals(second.get("output"), "change") ;
-	
+
 });
 
 test("Should flush the invoke last queue at the end of the current run loop", function () {
@@ -194,4 +194,41 @@ test("Calling invokeNext inside an invokeNext invocation will schedule for the f
     SC.RunLoop.begin();
   }
   equals(iCalled, 5, "should have flushed the invokeNext queue 5 times");
+  SC.RunLoop.end();
+});
+
+/**
+  The previous implementation of invokeNext never actually caused the next run
+  of the run loop and would only work if another run loop happened to occur.
+  So if you were using invokeNext to do rendering, it would not really work
+  unless the mouse moved or some other timer was firing.
+*/
+test("Using invokeNext should result in an additional run of the run loop immediately after it ends.", function () {
+  stop(2000);
+
+  expect(1);
+  SC.run(function () {
+    SC.RunLoop.currentRunLoop.invokeNext(function () {
+      ok(YES, "should have started another run of the run loop");
+      start();
+    });
+  });
+});
+
+/**
+  There was a regression where unscheduling a run loop failed to clear out the
+  internal state and therefore further scheduling of the run loop failed.
+*/
+test("Using unscheduleRunLoop should not prevent scheduleRunLoop from working.", function () {
+  SC.run(function () {
+    var now = new Date(),
+      newTimeoutID,
+      timeoutID;
+
+    timeoutID = SC.RunLoop.currentRunLoop.scheduleRunLoop(now);
+    SC.RunLoop.currentRunLoop.unscheduleRunLoop();
+    newTimeoutID = SC.RunLoop.currentRunLoop.scheduleRunLoop(now);
+
+    ok(timeoutID !== newTimeoutID, "should not be the same timeout id after unscheduling");
+  });
 });