sproutcore 1.7.1.beta → 1.8.0

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

@@ -12,35 +12,95 @@
   applications.
 */
 SC.String = /** @scope SC.String.prototype */ {
+  
+  /**
+    This finds the value for a key in a formatting string.
+    
+    Keys take the form:
+    
+        key[:argument to formatter]
+  */
+  _scs_valueForKey: function(key, data, /* for debugging purposes: */ string) {
+    var arg, value, formatter, argsplit = key.indexOf(':');
+    if (argsplit > -1) {
+      arg = key.substr(argsplit + 1);
+      key = key.substr(0, argsplit);
+    }
+    
+    value = data[key];
+    formatter = data[key + 'Formatter'];
+    
+    // formatters are optional
+    if (formatter) value = formatter(value, arg);
+    else if (arg) {
+      throw "String.fmt was given a formatting string, but key `" + key + "` has no formatter! String: " + string;
+    }
+    
+    return value;
+  },
 
-  // Interpolate string. looks for %@ or %@1; to control the order of params.
   /**
-    Apply formatting options to the string.  This will look for occurrences
-    of %@ in your string and substitute them with the arguments you pass into
-    this method.  If you want to control the specific order of replacement,
-    you can add a number after the key as well to indicate which argument
-    you want to insert.
+    Formats a string. You can format either with named parameters or
+    indexed, but not both.
+
+    Indexed Parameters
+    --------------------
+    Indexed parameters are just arguments you pass into format.
 
-    Ordered insertions are most useful when building loc strings where values
-    you need to insert may appear in different orders.
+    For example, if you call fmt("%@1 %3 %2", 1, 2, 3), you'll get "1 3 2" as output.
+    
+    If you don't supply a number, it will use them in the order you supplied. For instance:
+    
+        "abc".fmt("%@, %@", "Iskander", "Alex")  would return "Iskander, Alex".
 
-    Examples
-    -----
+    Named Paramters
+    --------------------
+    You can use named parameters like this:
 
-        "Hello %@ %@".fmt('John', 'Doe') => "Hello John Doe"
-        "Hello %@2, %@1".fmt('John', 'Doe') => "Hello Doe, John"
+        "Value: %{key_name}".fmt({ key_name: "A Value" })
+        
+        // -> "Value: A Value"
+    
+    You can supply formatters for each field. A formatter is a method to get applied
+    to the parameter:
+    
+        Currency = function(v) { return "$" + v; };
+        "Value: %{val}".fmt({ val: 12.00, valFormatter: Currency })
+        
+        // -> $12.00
+    
+    Formatters can also use arguments:
+    
+        Currency = function(v, sign) { return sign + v; };
+        "Value: %{val:£}".fmt({ val: 12.00, valFormatter: Currency })
+        
+        // -> £12.00
 
-    @param {Object...} args optional arguments
-    @returns {String} formatted string
+    You can supply a different formatter for each named parameter. Formatters can ONLY be
+    used with named parameters (not indexed parameters).
+        
   */
-  fmt: function(str, formats) {
-    // first, replace any ORDERED replacements.
-    var idx  = 0; // the current index for non-numerical replacements
-    return str.replace(/%@([0-9]+)?/g, function(s, argIndex) {
-      argIndex = (argIndex) ? parseInt(argIndex,0) - 1 : idx++ ;
-      s = formats[argIndex];
-      return ((s === null) ? '(null)' : (s === undefined) ? '' : s).toString();
-    }) ;
+  fmt: function(string, args) {
+    var i = 0, data = undefined, hasHadNamedArguments;
+    if (args) {
+      data = args[0];
+    }
+    
+    return string.replace(/%\{(.*?)\}/g, function(match, propertyPath) {
+      hasHadNamedArguments = YES;
+      if (!data) {
+        throw "Cannot use named parameters with `fmt` without a data hash. String: '" + string + "'";
+      }
+
+      return SC.String._scs_valueForKey(propertyPath, data, string);
+    }).replace(/%@([0-9]+)?/g, function(match, index) {
+      if (hasHadNamedArguments) {
+        throw "Invalid attempt to use both named parameters and indexed parameters. String: '" + string + "'";
+      }
+      index = index ? parseInt(index, 10) - 1 : i++;
+      if(args[index]!==undefined) return args[index];
+      else return "";
+    });
   },
   
   /**

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/chained.js

@@ -42,3 +42,23 @@ test("chained observers on enumerable properties are triggered when the observed
   equals(observerFiredCount, 0, "observer did not fire after removing changing property on a removed object");
 });
 
+test("content observers are removed correctly", function() {
+  var child1 = SC.Object.create({ name: "Bartholomew", age: 15 });
+  var child2 = SC.Object.create({ name: "Agnes", age: 12 });
+  var children = [child1, child2];
+
+  var observerFiredCount = 0;
+  var observerFunc = function() { observerFiredCount++; }
+
+  children.addObserver('@each.name', this, observerFunc);
+  children.removeObserver('@each.name', this, observerFunc);
+  observerFiredCount = 0;
+  SC.run(function() { children.setEach('name', "Hanna"); });
+  equals(observerFiredCount, 0, "name observer did not fire after it was removed");
+
+  children.addObserver('@each.age', this, observerFunc);
+  children.removeObserver('@each.age', this, observerFunc);
+  observerFiredCount = 0;
+  SC.run(function() { children.setEach('age', 14); });
+  equals(observerFiredCount, 0, "age observer did not fire after it was removed");
+});

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

@@ -307,7 +307,7 @@ module("Computed properties", {
         return 'dependentCached';
       }.property('changer').cacheable(),
 
-      // everytime it is recomputed, increments call
+      // every time it is recomputed, increments call
       incCallCount: 0,
       inc: function() {
         return this.incCallCount++;
@@ -587,10 +587,14 @@ test("cacheable nested dependent keys should clear after their dependencies upda
 module("Observable objects & object properties ", {
 
   setup: function() {
+    window.NormalArray = [1,2,3,4,5];
+    
     object = SC.Object.create({
 
       normal: 'value',
       abnormal: 'zeroValue',
+      abnormal2: 'zeroValue',
+      abnormal3: 'zeroValue',
       numberVal: 24,
       toggleVal: true,
       observedProperty: 'beingWatched',
@@ -620,9 +624,21 @@ module("Observable objects & object properties ", {
 
       testArrayObserver:function(){
         this.abnormal = 'notifiedObserver';
-      }.observes('*normalArray.[]')
+      }.observes('*normalArray.[]'),
+
+      testArrayObserver2:function(){
+        this.abnormal2 = 'notifiedObserver';
+      }.observes('normalArray.[]'),
+
+      testArrayObserver3:function(){
+        this.abnormal3 = 'notifiedObserver';
+      }.observes('NormalArray.[]')
 
     });
+  },
+
+  teardown: function() {
+    window.NormalArray = null;
   }
 
 });
@@ -652,9 +668,18 @@ test('should not notify the observers of a property automatically',function(){
   equals(object.abnormal,'zeroValue')  ;
 });
 
-test('should notify array observer when array changes',function(){
+test('should notify array observer when object\'s array changes',function(){
   object.normalArray.replace(0,0,6);
-  equals(object.abnormal, 'notifiedObserver', 'observer should be notified');
+  equals(object.abnormal, 'notifiedObserver', 'testArrayObserver should be notified');
+  equals(object.abnormal2, 'notifiedObserver', 'testArrayObserver2 should be notified');
+  equals(object.abnormal3, 'zeroValue', 'testArrayObserver3 should not be notified');
+});
+
+test('should notify array observer when NormalArray array changes',function(){
+  window.NormalArray.replace(0,0,6);
+  equals(object.abnormal, 'zeroValue', 'testArrayObserver should not be notified');
+  equals(object.abnormal2, 'zeroValue', 'testArrayObserver2 should not be notified');
+  equals(object.abnormal3, 'notifiedObserver', 'testArrayObserver3 should be notified');
 });
 
 
@@ -866,3 +891,99 @@ test("changing chained observer object to null should not raise exception", func
   equals(callCount, 1, 'changing bar should trigger observer');
   expect(3);
 });
+
+module("addObservesHandler and removeObservesHandler functions", {
+
+  setup: function() {
+    window.TestNS = SC.Object.create({
+      value: 0
+    });
+    
+    objectA = SC.Object.create({
+      
+      value: 0,
+      arrayValue: [],
+      
+      handler1NotifiedCount: 0,
+      handler2NotifiedCount: 0,
+      arrayHandlerNotifiedCount: 0,
+      
+      handler1: function() {
+        this.handler1NotifiedCount++;
+      },
+      
+      handler2: function() {
+        this.handler2NotifiedCount++;
+      },
+      
+      arrayHandler: function() {
+        this.arrayHandlerNotifiedCount++;
+      }
+      
+    });
+  },
+  
+  teardown: function() {
+    objectA = null;
+    window.TestNS = null;
+  }
+  
+});
+
+test("add and remove observer handler1", function() {
+  objectA.addObservesHandler(objectA.handler1, 'value');
+  objectA.set('value', 100);
+  equals(objectA.handler1NotifiedCount, 1, "observes handler1 should be notified");
+  
+  objectA.removeObservesHandler(objectA.handler1, 'value');
+  objectA.set('value', 200);
+  equals(objectA.handler1NotifiedCount, 1, "observes handler1 should not be notified");
+});
+
+test("add and remove observer handler2", function() {
+  objectA.addObservesHandler(objectA.handler2, 'TestNS.value');
+  window.TestNS.set('value', 1000);
+  equals(objectA.handler2NotifiedCount, 1, "observes handler2 should be notified");
+  
+  objectA.removeObservesHandler(objectA.handler2, 'TestNS.value');
+  window.TestNS.set('value', 2000);
+  equals(objectA.handler2NotifiedCount, 1, "observes handler1 should not be notified");
+});
+
+test("add and remove observer array handler without chain observes", function() {
+  objectA.addObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
+  objectA.arrayValue.pushObject(SC.Object.create());
+  ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified aftering pushing object to array");
+  
+  objectA.arrayHandlerNotifiedCount = 0;
+  
+  objectA.removeObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
+  objectA.arrayValue.pushObject(SC.Object.create());
+  equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified after removing observes handler");
+  
+  objectA.addObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
+  objectA.set('arrayValue', []);
+  equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified after assigning new array");
+  objectA.arrayValue.pushObject(SC.Object.create());
+  equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified after pushing object to new array");
+});
+
+test("add and remove observer array handler with chain observes", function() {
+  objectA.addObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
+  objectA.arrayValue.pushObject(SC.Object.create());
+  ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified aftering pushing object to array");
+  
+  objectA.arrayHandlerNotifiedCount = 0;
+  
+  objectA.removeObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
+  objectA.arrayValue.pushObject(SC.Object.create());
+  equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified of push after removing observes handler");
+  objectA.set('arrayValue', []);
+  equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified of new array after removing observes handler");
+  
+  objectA.addObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
+  objectA.set('arrayValue', []);
+  ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified after assigning new array");
+  objectA.arrayValue.pushObject(SC.Object.create());
+  ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified after pushing object to new array");
+});

data/lib/frameworks/sproutcore/frameworks/runtime/tests/private/observer_queue.js

@@ -85,7 +85,7 @@ test("Object not yet instantiated", function() {
   SC.Observers.flush(garage);
   ok(SC.Observers.queue.some(function(el) { return el[1] === observer; }), "The observer should still be in the queue.");
 
-  // 3. After we instantiate the class, a call to SC.Observers.flush shoud remove the object from the queue...
+  // 3. After we instantiate the class, a call to SC.Observers.flush should remove the object from the queue...
   car = garage.car = car.create({ make: 'Renault' });
   SC.Observers.flush(garage);
   ok(!SC.Observers.queue.some(function(el) { return el[1] === observer; }), "The observer should have been removed from the queue.");

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

@@ -186,7 +186,7 @@ module("chained binding", {
   
 });
 
-test("changing first output should propograte to third after flush", function() {
+test("changing first output should propagate to third after flush", function() {
   first.set("output", "change") ;
   equals("change", first.get("output"), "first.output") ;
   ok("change" !== third.get("input"), "third.input") ;
@@ -230,7 +230,7 @@ module("Custom Binding", {
   }
 });
 
-test("Binding value1 such that it will recieve only single values", function() {
+test("Binding value1 such that it will receive only single values", function() {
 	var bon1 = Bon1.create({
 		value1Binding: SC.Binding.single("TestNamespace.bon2.val1"),
 		array1Binding: SC.Binding.single("TestNamespace.bon2.arr")

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

@@ -33,4 +33,41 @@ test("index past last index", function() {
   equals(set.rangeStartForIndex(start+len+20), start+len, 'should return end of range');
 });
 
+test("creating holes by appending to an existing range should not affect the range start", function () {
+  var hintSize = SC.IndexSet.HINT_SIZE,
+      start, set;
 
+  set = SC.IndexSet.create();
+
+  set.add(1);
+  set.add(hintSize + 1);
+
+  // Before adding 2,
+  // the internal data structure looks like:
+  // {
+  //   0  : -  1,   // Hole until 1
+  //   1  :    2,   // End of range is 2
+  //   2  : -257,   // Hole until 257
+  //   256:    2,   // Hint points at index 2, which is ok.
+  //   257:  258,   // End of range is 258
+  //   258:    0    // End of index set
+  // }
+  equals(set.rangeStartForIndex(hintSize),
+         set.rangeStartForIndex(hintSize - 1));
+
+  set.add(2);
+
+  // Assuming SC.IndexSet.HINT_SIZE is 256,
+  // the internal data structure looks like:
+  // {
+  //   0  : -  1,   // Hole until 1
+  //   1  :    3,   // End of range is 3
+  //   3  : -257,   // Hole until 257
+  //   256:    2,   // Hint points at index 2, which is invalid.
+  //   257:  258,   // End of range is 258
+  //   258:    0    // End of index set
+  // }
+
+  equals(set.rangeStartForIndex(hintSize),
+         set.rangeStartForIndex(hintSize - 1));
+});

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

@@ -156,7 +156,7 @@ test("remove a range should trigger an observer notification", function() {
   equals(callCnt, 1, 'should have called observer once');
 });
 
-test("removing a non-existant range should not trigger observer notification", function() {
+test("removing a non-existent range should not trigger observer notification", function() {
   var callCnt = 0;
   
   set.addObserver('[]', function() { callCnt++; });
@@ -176,7 +176,7 @@ test("removing an index range outside of target range (specific bug)", function(
   var set = SC.IndexSet.create(10,3);
   var set2 = SC.IndexSet.create(0,3);
   
-  // removing set2 from set should not changed set at all beceause it is 
+  // removing set2 from set should not changed set at all because it is 
   // before the first range, but it causes a problem with the length.
   set.remove(set2);
   equals(set.get('length'), 3, 'length should not change');

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

@@ -263,3 +263,19 @@ test("Ensure that log messages via the “will not format” methods don’t for
   equals(SC.Logger.getPath('recordedLogMessages.3').originalArguments[1], null, "errorWithoutFmt() should record all the arguments (1)");
   equals(SC.Logger.getPath('recordedLogMessages.3').originalArguments[2], 1, "errorWithoutFmt() should record all the arguments (2)");
 });
+
+
+
+// ..........................................................
+// LOG MESSAGE PREFIX
+//
+test("Ensure that the log message prefix is respected", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_DEBUG);
+
+  SC.Logger.set('messagePrefix', "prefix: ");
+  SC.Logger.debug("message");
+
+  equals(SC.Logger.getPath('recordedLogMessages.0').message, "prefix: message", "The message should have the specified prefix");
+});

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

@@ -26,7 +26,7 @@ module("System:run_loop() - chained binding", {
   }
 });
 
-test("Should propograte bindings after the RunLoop completes (using SC.RunLoop)", function() {
+test("Should propagate bindings after the RunLoop completes (using SC.RunLoop)", function() {
 	SC.RunLoop.begin();
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
@@ -54,7 +54,7 @@ test("Should propograte bindings after the RunLoop completes (using SC.RunLoop)"
 	equals(second.get("output"), "change") ;
 });
 
-test("Should propograte bindings after the RunLoop completes (using SC.beginRunLoop)", function() {
+test("Should propagate bindings after the RunLoop completes (using SC.beginRunLoop)", function() {
 	SC.beginRunLoop;
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
@@ -83,7 +83,7 @@ test("Should propograte bindings after the RunLoop completes (using SC.beginRunL
 	equals(second.get("output"), "change") ;
 });
 
-test("Should propograte bindings after the RunLoop completes (checking invokeOnce() function)", function() {
+test("Should propagate bindings after the RunLoop completes (checking invokeOnce() function)", function() {
 	SC.RunLoop.begin();
 		//Binding of output of first object to input of second object
   		binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
@@ -123,4 +123,75 @@ test("Should propograte bindings after the RunLoop completes (checking invokeOnc
 	//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 () {
+  var iCalled = 0;
+  SC.RunLoop.begin();
+
+  SC.RunLoop.currentRunLoop.invokeLast(function () {
+    iCalled++;
+  });
+
+  ok(!iCalled, "should not have flushed the invokeLast queue");
+  SC.RunLoop.end();
+  ok(iCalled, "should have flushed the invokeLast queue");
+
+  SC.RunLoop.begin();
+  SC.RunLoop.end();
+  equals(iCalled, 1, "should have flushed the invokeLast queue only once");
+});
+
+test("Should repeatedly flush the invoke last queue until there are no more items", function () {
+  var iCalled = 0;
+  SC.RunLoop.begin();
+
+  SC.RunLoop.currentRunLoop.invokeLast(function () {
+    iCalled++;
+    if (iCalled < 5) {
+      SC.RunLoop.currentRunLoop.invokeLast(arguments.callee);
+    }
+  });
+
+  ok(!iCalled, "should not have flushed the invokeLast queue");
+  SC.RunLoop.end();
+  ok(iCalled, "should have flushed the invokeLast queue");
+  equals(iCalled, 5, "should have flushed the invokeLast queue 5 times");
+});
+
+test("Should flush the invoke next queue at the beginning of the next run loop", function () {
+  var iCalled = 0;
+  SC.RunLoop.begin();
+
+  SC.RunLoop.currentRunLoop.invokeNext(function () {
+    iCalled++;
+  });
+
+  SC.RunLoop.end();
+  ok(!iCalled, "should not have flushed the invokeNext queue");
+
+  SC.RunLoop.begin();
+  ok(iCalled, "should have flushed the invokeNext queue");
+
+  SC.RunLoop.end();
+  equals(iCalled, 1, "should have flushed the invokeNext queue only once");
+});
+
+test("Calling invokeNext inside an invokeNext invocation will schedule for the function to run in the next run loop", function () {
+  var iCalled = 0;
+  SC.RunLoop.begin();
+
+  SC.RunLoop.currentRunLoop.invokeNext(function () {
+    if (iCalled < 5) {
+      SC.RunLoop.currentRunLoop.invokeNext(arguments.callee);
+    }
+    iCalled++;
+  });
+
+  for (var i = 0; i < 5; i++) {
+    equals(iCalled, i, "should have flushed the invokeNext queue " + i + " time" + (i !== 1 ? 's' : ''));
+    SC.RunLoop.end();
+    SC.RunLoop.begin();
+  }
+  equals(iCalled, 5, "should have flushed the invokeNext queue 5 times");
+});