sproutcore 1.10.0.rc.2 → 1.10.0.rc.3

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

@@ -7,19 +7,19 @@
 // ========================================================================
 // SC.Binding Tests
 // ========================================================================
-/*globals module test ok isObj equals expects */
+/*globals module, test, ok, isObj, equals, expects */
 
-var fromObject, toObject, binding, Bon1, bon2 ; // global variables
+var fromObject, midObject, toObject, binding, Bon1, bon2, first, second, third, binding1, binding2;
 
 module("basic object binding", {
 
   setup: function () {
-    fromObject = SC.Object.create({ value: 'start' }) ;
+    fromObject = SC.Object.create({ value: 'start' });
     midObject = SC.Object.create({ value: 'middle' });
-    toObject = SC.Object.create({ value: 'end' }) ;
-    binding1 = SC.Binding.from("value", fromObject).to("value", midObject).connect() ;
+    toObject = SC.Object.create({ value: 'end' });
+    binding1 = SC.Binding.from("value", fromObject).to("value", midObject).connect();
     binding2 = SC.Binding.from("value", midObject).to("value", toObject).connect();
-    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+    SC.Binding.flushPendingChanges(); // actually sets up up the connection
   },
 
   teardown: function () {
@@ -30,56 +30,56 @@ module("basic object binding", {
   }
 });
 
-test("binding is connected", function() {
-  equals(binding1.isConnected, YES, "binding1.isConnected") ;
-  equals(binding2.isConnected, YES, "binding2.isConnected") ;
+test("binding is connected", function () {
+  equals(binding1.isConnected, YES, "binding1.isConnected");
+  equals(binding2.isConnected, YES, "binding2.isConnected");
 });
 
-test("binding has actually been setup", function() {
-  equals(binding1._connectionPending, NO, "binding1._connectionPending") ;
-  equals(binding2._connectionPending, NO, "binding2._connectionPending") ;
+test("binding has actually been setup", function () {
+  equals(binding1._connectionPending, NO, "binding1._connectionPending");
+  equals(binding2._connectionPending, NO, "binding2._connectionPending");
 });
 
-test("binding should have synced on connect", function() {
+test("binding should have synced on connect", function () {
   equals(toObject.get("value"), "start", "toObject.value should match fromObject.value");
   equals(midObject.get("value"), "start", "midObject.value should match fromObject.value");
 });
 
-test("changing fromObject should mark binding as dirty", function() {
-  fromObject.set("value", "change") ;
+test("changing fromObject should mark binding as dirty", function () {
+  fromObject.set("value", "change");
   ok(SC.Binding._changeQueue.contains(binding1), "the binding should be in the _changeQueue");
-  SC.Binding.flushPendingChanges() ;
+  SC.Binding.flushPendingChanges();
   ok(SC.Binding._changeQueue.contains(binding2), "the binding should be in the _changeQueue");
 });
 
-test("fromObject change should propogate to toObject only after flush", function() {
-  fromObject.set("value", "change") ;
-  equals(midObject.get("value"), "start") ;
-  equals(toObject.get("value"), "start") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(midObject.get("value"), "change") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(toObject.get("value"), "change") ;
+test("fromObject change should propogate to toObject only after flush", function () {
+  fromObject.set("value", "change");
+  equals(midObject.get("value"), "start");
+  equals(toObject.get("value"), "start");
+  SC.Binding.flushPendingChanges();
+  equals(midObject.get("value"), "change");
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get("value"), "change");
 });
 
-test("changing toObject should mark binding as dirty", function() {
-  toObject.set("value", "change") ;
+test("changing toObject should mark binding as dirty", function () {
+  toObject.set("value", "change");
   ok(SC.Binding._changeQueue.contains(binding2), "the binding should be in the _changeQueue");
-  SC.Binding.flushPendingChanges() ;
+  SC.Binding.flushPendingChanges();
   ok(SC.Binding._changeQueue.contains(binding1), "the binding should be in the _changeQueue");
 });
 
-test("toObject change should propogate to fromObject only after flush", function() {
-  toObject.set("value", "change") ;
-  equals(midObject.get("value"), "start") ;
-  equals(fromObject.get("value"), "start") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(midObject.get("value"), "change") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(fromObject.get("value"), "change") ;
+test("toObject change should propogate to fromObject only after flush", function () {
+  toObject.set("value", "change");
+  equals(midObject.get("value"), "start");
+  equals(fromObject.get("value"), "start");
+  SC.Binding.flushPendingChanges();
+  equals(midObject.get("value"), "change");
+  SC.Binding.flushPendingChanges();
+  equals(fromObject.get("value"), "change");
 });
 
-test("suspended observing during bindings", function() {
+test("suspended observing during bindings", function () {
 
   // setup special binding
   fromObject = SC.Object.create({
@@ -93,7 +93,7 @@ test("suspended observing during bindings", function() {
 
     callCount: 0,
 
-    observer: function() {
+    observer: function () {
       equals(this.get('value1'), 'CHANGED', 'value1 when observer fires');
       equals(this.get('value2'), 'CHANGED', 'value2 when observer fires');
       this.callCount++;
@@ -111,12 +111,12 @@ test("suspended observing during bindings", function() {
   equals(toObject.callCount, 2, 'should call observer twice');
 });
 
-test("binding will disconnect", function() {
+test("binding will disconnect", function () {
   binding1.disconnect();
   equals(binding1.isConnected, NO, "binding1.isConnected");
 });
 
-test("binding disconnection actually works", function() {
+test("binding disconnection actually works", function () {
   binding1.disconnect();
   fromObject.set('value', 'change');
   SC.Binding.flushPendingChanges();
@@ -131,15 +131,15 @@ test("binding disconnection actually works", function() {
   equals(toObject.get('value'), 'change');
 });
 
-test("binding destruction actually works", function() {
-  binding1.destroy()
+test("binding destruction actually works", function () {
+  binding1.destroy();
   ok(binding1.isDestroyed, "binding marks itself as destroyed.");
   ok(!binding1._fromTarget && !binding1._toTarget, "binding destruction removes binding targets.");
 });
 
 module("bindings on classes");
 
-test("should connect when multiple instances of class are created", function() {
+test("should connect when multiple instances of class are created", function () {
   window.TestNamespace = {};
   window.TestNamespace.stubController = SC.Object.create({
     name: 'How to Be Happy'
@@ -152,14 +152,14 @@ test("should connect when multiple instances of class are created", function() {
 
     var myFirstObj;
 
-    SC.run(function() { myFirstObj = myClass.create(); });
+    SC.run(function () { myFirstObj = myClass.create(); });
     equals(myFirstObj.get('foo'), "How to Be Happy");
 
     var mySecondObj;
-    SC.run(function() { mySecondObj = myClass.create() });
+    SC.run(function () { mySecondObj = myClass.create(); });
     equals(mySecondObj.get('foo'), "How to Be Happy");
 
-    SC.run(function() { myFirstObj.destroy(); })
+    SC.run(function () { myFirstObj.destroy(); });
     ok(myFirstObj.fooBinding.isDestroyed, "destroying an object destroys its class bindings.");
 
   } finally {
@@ -168,146 +168,163 @@ test("should connect when multiple instances of class are created", function() {
 });
 
 module("one way binding", {
-  setup: function() {
-    fromObject = SC.Object.create({ value: 'start' }) ;
-    toObject = SC.Object.create({ value: 'end' }) ;
-    binding = SC.Binding.from("value", fromObject).to("value", toObject).oneWay().connect() ;
-    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+  setup: function () {
+    fromObject = SC.Object.create({ value: 'start' });
+    toObject = SC.Object.create({ value: 'end' });
+    binding = SC.Binding.from("value", fromObject).to("value", toObject).oneWay().connect();
+    SC.Binding.flushPendingChanges(); // actually sets up up the connection
   }
 
 });
 
-test("changing fromObject should mark binding as dirty", function() {
-  fromObject.set("value", "change") ;
+test("changing fromObject should mark binding as dirty", function () {
+  fromObject.set("value", "change");
   ok(SC.Binding._changeQueue.contains(binding), "the binding should be in the _changeQueue");
 });
 
-test("fromObject change should propogate after flush", function() {
-  fromObject.set("value", "change") ;
-  equals(toObject.get("value"), "start") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(toObject.get("value"), "change") ;
+test("fromObject change should propogate after flush", function () {
+  fromObject.set("value", "change");
+  equals(toObject.get("value"), "start");
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get("value"), "change");
 });
 
-test("changing toObject should not make binding dirty", function() {
-  toObject.set("value", "change") ;
+test("changing toObject should not make binding dirty", function () {
+  toObject.set("value", "change");
   ok(!SC.Binding._changeQueue.contains(binding), "the binding should not be in the _changeQueue");
 });
 
-test("toObject change should NOT propogate", function() {
-  toObject.set("value", "change") ;
-  equals(fromObject.get("value"), "start") ;
-  SC.Binding.flushPendingChanges() ;
-  equals(fromObject.get("value"), "start") ;
+test("toObject change should NOT propogate", function () {
+  toObject.set("value", "change");
+  equals(fromObject.get("value"), "start");
+  SC.Binding.flushPendingChanges();
+  equals(fromObject.get("value"), "start");
 });
 
-var first, second, third, binding1, binding2 ; // global variables
-
 module("chained binding", {
 
-  setup: function() {
-    first = SC.Object.create({ output: 'first' }) ;
+  setup: function () {
+    first = SC.Object.create({ output: 'first' });
 
     second = SC.Object.create({
       input: 'second',
       output: 'second',
 
-      inputDidChange: function() {
-        this.set("output", this.get("input")) ;
+      inputDidChange: function () {
+        this.set("output", this.get("input"));
       }.observes("input")
-    }) ;
+    });
 
-    third = SC.Object.create({ input: "third" }) ;
+    third = SC.Object.create({ input: "third" });
 
-    binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
-    binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
-    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+    binding1 = SC.Binding.from("output", first).to("input", second).connect();
+    binding2 = SC.Binding.from("output", second).to("input", third).connect();
+    SC.Binding.flushPendingChanges(); // actually sets up up the connection
   }
 
 });
 
-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") ;
+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");
 
   var didChange = YES;
-  while(didChange) didChange = SC.Binding.flushPendingChanges() ;
+  while (didChange) { didChange = SC.Binding.flushPendingChanges(); }
 
   // bindings should not have bending changes
   ok(!SC.Binding._changeQueue.contains(binding1), "the binding should not be in the _changeQueue");
   ok(!SC.Binding._changeQueue.contains(binding2), "the binding should not be in the _changeQueue");
 
-  equals("change", first.get("output"), "first.output") ;
-  equals("change", second.get("input"), "second.input") ;
-  equals("change", second.get("output"), "second.output") ;
-  equals("change", third.get("input"), "third.input") ;
+  equals("change", first.get("output"), "first.output");
+  equals("change", second.get("input"), "second.input");
+  equals("change", second.get("output"), "second.output");
+  equals("change", third.get("input"), "third.input");
 });
 
 module("Custom Binding", {
 
-  setup: function() {
-	Bon1 = SC.Object.extend({
-		value1: "hi",
-		value2: 83,
-		array1: []
-	});
+  setup: function () {
+    Bon1 = SC.Object.extend({
+      value1: "hi",
+      value2: 83,
+      array1: []
+    });
 
-	bon2 = SC.Object.create({
-		val1: "hello",
-		val2: 25,
-		arr: [1,2,3,4]
-	});
+    bon2 = SC.Object.create({
+      val1: "hello",
+      val2: 25,
+      arr: [1, 2, 3, 4]
+    });
 
-	TestNamespace = {
+    window.TestNamespace = {
       bon2: bon2,
       Bon1: Bon1
-    } ;
+    };
   },
 
-  teardown: function() {
+  teardown: function () {
     bon2.destroy();
   }
 });
 
-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")
-	});
-	SC.Binding.flushPendingChanges();
-	var a = [23,31,12,21];
-	bon2.set("arr", a);
-	bon2.set("val1","changed");
-	SC.Binding.flushPendingChanges();
-	equals(bon2.get("val1"),bon1.get("value1"));
-	equals("@@MULT@@",bon1.get("array1"));
-	bon1.destroy();
-});
-
-test("Single binding using notEmpty function.", function() {
-	var bond = Bon1.create ({
-	  array1Binding: SC.Binding.single("TestNamespace.bon2.arr").notEmpty(null,'(EMPTY)')
-	});
-	SC.Binding.flushPendingChanges();
-	bon2.set("arr", []);
-	SC.Binding.flushPendingChanges();
-	equals("(EMPTY)",bond.get("array1"));
-});
-
-test("Binding with transforms, function to check the type of value", function() {
-	var jon = Bon1.create({
-		value1Binding: SC.Binding.transform(function(val1) {
-			return (SC.typeOf(val1) == SC.T_STRING)? val1 : "";
-		}).from("TestNamespace.bon2.val1")
-	});
-	SC.Binding.flushPendingChanges();
-	bon2.set("val1","changed");
-	SC.Binding.flushPendingChanges();
-	equals(jon.get("value1"), bon2.get("val1"));
-});
-
-test("two bindings to the same value should sync in the order they are initialized", 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")
+  });
+  SC.Binding.flushPendingChanges();
+  var a = [23, 31, 12, 21];
+  bon2.set("arr", a);
+  bon2.set("val1", "changed");
+  SC.Binding.flushPendingChanges();
+  equals(bon2.get("val1"), bon1.get("value1"));
+  equals("@@MULT@@", bon1.get("array1"));
+  bon1.destroy();
+});
+
+test("Single binding using notEmpty function.", function () {
+  var bond = Bon1.create({
+    array1Binding: SC.Binding.single("TestNamespace.bon2.arr").notEmpty(null, '(EMPTY)')
+  });
+  SC.Binding.flushPendingChanges();
+  bon2.set("arr", []);
+  SC.Binding.flushPendingChanges();
+  equals("(EMPTY)", bond.get("array1"));
+});
+
+test("Binding with transforms, function to check the type of value", function () {
+  var jon = Bon1.create({
+    value1Binding: SC.Binding.transform(function (val1) {
+      return (SC.typeOf(val1) == SC.T_STRING) ? val1 : "";
+    }).from("TestNamespace.bon2.val1")
+  });
+  SC.Binding.flushPendingChanges();
+  bon2.set("val1", "changed");
+  SC.Binding.flushPendingChanges();
+  equals(jon.get("value1"), bon2.get("val1"));
+});
+
+test("Adding transform does not affect parent binding", function () {
+  var A,
+      a,
+      b;
+
+  A = SC.Object.extend({
+    isEnabledBindingDefault: SC.Binding.oneWay().bool()
+  });
+
+  b = SC.Object.create({
+    isEnabled: YES
+  });
+
+  a = A.create();
+  a.bind('isEnabled', b, 'isEnabled').not();
+
+  ok(A.prototype.isEnabledBindingDefault._transforms !== a.bindings[0]._transforms, "transforms array not shared with parent binding");
+});
+
+test("two bindings to the same value should sync in the order they are initialized", function () {
 
   SC.LOG_BINDINGS = YES;
 
@@ -328,7 +345,7 @@ test("two bindings to the same value should sync in the order they are initializ
       fooBinding: "*owner.foo"
     }),
 
-    init: function() {
+    init: function () {
       sc_super();
       this.set('c', this.C.create({ owner: this }));
     }
@@ -345,13 +362,13 @@ test("two bindings to the same value should sync in the order they are initializ
   equals(b.get('foo'), "bar", 'a.foo should propogate up to b.foo');
   equals(b.c.get('foo'), "bar", 'a.foo should propogate up to b.c.foo');
 
-  window.a = window.b = null ;
+  window.a = window.b = null;
 
 });
 
 module("AND binding", {
 
-  setup: function() {
+  setup: function () {
     // temporarily set up two source objects in the SC namespace so we can
     // use property paths to access them
     SC.testControllerA = SC.Object.create({ value: NO });
@@ -363,14 +380,14 @@ module("AND binding", {
     });
   },
 
-  teardown: function() {
+  teardown: function () {
     SC.testControllerA.destroy();
     SC.testControllerB.destroy();
   }
 
 });
 
-test("toObject.value should be YES if both sources are YES", function() {
+test("toObject.value should be YES if both sources are YES", function () {
   SC.RunLoop.begin();
   SC.testControllerA.set('value', YES);
   SC.testControllerB.set('value', YES);
@@ -380,7 +397,7 @@ test("toObject.value should be YES if both sources are YES", function() {
   equals(toObject.get('value'), YES);
 });
 
-test("toObject.value should be NO if either source is NO", function() {
+test("toObject.value should be NO if either source is NO", function () {
   SC.RunLoop.begin();
   SC.testControllerA.set('value', YES);
   SC.testControllerB.set('value', NO);
@@ -408,7 +425,7 @@ test("toObject.value should be NO if either source is NO", function() {
 
 module("OR binding", {
 
-  setup: function() {
+  setup: function () {
     // temporarily set up two source objects in the SC namespace so we can
     // use property paths to access them
     SC.testControllerA = SC.Object.create({ value: NO });
@@ -420,14 +437,14 @@ module("OR binding", {
     });
   },
 
-  teardown: function() {
+  teardown: function () {
     SC.testControllerA.destroy();
     SC.testControllerB.destroy();
   }
 
 });
 
-test("toObject.value should be first value if first value is truthy", function() {
+test("toObject.value should be first value if first value is truthy", function () {
   SC.RunLoop.begin();
   SC.testControllerA.set('value', 'first value');
   SC.testControllerB.set('value', 'second value');
@@ -437,7 +454,7 @@ test("toObject.value should be first value if first value is truthy", function()
   equals(toObject.get('value'), 'first value');
 });
 
-test("toObject.value should be second value if first is falsy", function() {
+test("toObject.value should be second value if first is falsy", function () {
   SC.RunLoop.begin();
   SC.testControllerA.set('value', NO);
   SC.testControllerB.set('value', 'second value');
@@ -448,16 +465,16 @@ test("toObject.value should be second value if first is falsy", function() {
 });
 
 module("Binding with '[]'", {
-  setup: function() {
+  setup: function () {
     fromObject = SC.Object.create({ value: [] });
     toObject = SC.Object.create({ value: '' });
-    binding = SC.Binding.transform(function(v) {
+    binding = SC.Binding.transform(function (v) {
       return v ? v.join(',') : '';
     }).from("value.[]", fromObject).to("value", toObject).connect();
   }
 });
 
-test("Binding refreshes after a couple of items have been pushed in the array", function() {
+test("Binding refreshes after a couple of items have been pushed in the array", function () {
   fromObject.get('value').pushObjects(['foo', 'bar']);
   SC.Binding.flushPendingChanges();
   equals(toObject.get('value'), 'foo,bar');
@@ -465,7 +482,7 @@ test("Binding refreshes after a couple of items have been pushed in the array",
 
 
 module("propertyNameBinding with longhand", {
-  setup: function(){
+  setup: function () {
     TestNamespace = {
       fromObject: SC.Object.create({
         value: "originalValue"
@@ -477,7 +494,7 @@ module("propertyNameBinding with longhand", {
       })
     };
   },
-  teardown: function(){
+  teardown: function () {
     TestNamespace.fromObject.destroy();
     TestNamespace.toObject.destroy();
     delete TestNamespace.fromObject;
@@ -485,7 +502,7 @@ module("propertyNameBinding with longhand", {
   }
 });
 
-test("works with full path", function(){
+test("works with full path", function () {
   SC.RunLoop.begin();
   TestNamespace.fromObject.set('value', "updatedValue");
   SC.RunLoop.end();
@@ -499,7 +516,7 @@ test("works with full path", function(){
   equals(TestNamespace.toObject.get('value'), "newerValue");
 });
 
-test("works with local path", function(){
+test("works with local path", function () {
   SC.RunLoop.begin();
   TestNamespace.toObject.set('localValue', "updatedValue");
   SC.RunLoop.end();