Added onInvalid / onValid callbacks to Table, Selection, Ordering on …

…the client

client/lib/monarch/model/local_field.js

@@ -42,7 +42,10 @@ _.constructor("Monarch.Model.LocalField", Monarch.Model.ConcreteField, {
   clearValidationErrors: function() {
     var wasInvalid = !this.fieldset.valid();
     this.validationErrors = [];
-    if (this.record.onValidNode && wasInvalid && this.fieldset.valid()) this.record.onValidNode.publish();
+    if (wasInvalid && this.fieldset.valid()) {
+      if (this.record.onValidNode) this.record.onValidNode.publish();
+      this.record.table.recordMadeValid(this.record);
+    }
   },
 
   notModifiedAfter: function(date) {

client/lib/monarch/model/record.js

@@ -233,6 +233,7 @@ _.constructor("Monarch.Model.Record", {
   assignValidationErrors: function(errorsByFieldName) {
     this.local.assignValidationErrors(_.camelizeKeys(errorsByFieldName));
     if (this.onInvalidNode) this.onInvalidNode.publish();
+    this.table.recordMadeInvalid(this);
   },
 
   allValidationErrors: function() {

client/lib/monarch/model/relations/ordering.js

@@ -103,13 +103,10 @@ _.constructor("Monarch.Model.Relations.Ordering", Monarch.Model.Relations.Relati
       this.tupleUpdatedRemotely(record, changedFields);
     }, this));
 
-    this.operandsSubscriptionBundle.add(this.operand.onDirty(function(record) {
-      this.recordMadeDirty(record);
-    }, this));
-
-    this.operandsSubscriptionBundle.add(this.operand.onClean(function(record) {
-      this.recordMadeClean(record);
-    }, this));
+    this.operandsSubscriptionBundle.add(this.operand.onDirty(this.hitch('recordMadeDirty')));
+    this.operandsSubscriptionBundle.add(this.operand.onClean(this.hitch('recordMadeClean')));
+    this.operandsSubscriptionBundle.add(this.operand.onInvalid(this.hitch('recordMadeInvalid')));
+    this.operandsSubscriptionBundle.add(this.operand.onValid(this.hitch('recordMadeValid')));
   }
 })
 

client/lib/monarch/model/relations/relation.js

@@ -11,6 +11,8 @@ _.constructor("Monarch.Model.Relations.Relation", {
     this.onRemoteRemoveNode = new Monarch.SubscriptionNode();
     this.onDirtyNode = new Monarch.SubscriptionNode();
     this.onCleanNode = new Monarch.SubscriptionNode();
+    this.onInvalidNode = new Monarch.SubscriptionNode();
+    this.onValidNode = new Monarch.SubscriptionNode();
     if (this.hasOperands) {
       this.operandsSubscriptionBundle = new Monarch.SubscriptionBundle();
       this.unsubscribeFromOperandsWhenThisNoLongerHasSubscribers();
@@ -194,6 +196,16 @@ _.constructor("Monarch.Model.Relations.Relation", {
     return this.onCleanNode.subscribe(callback, context);
   },
 
+  onInvalid: function(callback, context) {
+    this.subscribeToOperandsIfNeeded();
+    return this.onInvalidNode.subscribe(callback, context);
+  },
+
+  onValid: function(callback, context) {
+    this.subscribeToOperandsIfNeeded();
+    return this.onValidNode.subscribe(callback, context);
+  },
+
   recordMadeDirty: function(record) {
     this.onDirtyNode.publish(record);
   },
@@ -202,6 +214,14 @@ _.constructor("Monarch.Model.Relations.Relation", {
     this.onCleanNode.publish(record);
   },
 
+  recordMadeInvalid: function(record) {
+    this.onInvalidNode.publish(record)
+  },
+
+  recordMadeValid: function(record) {
+    this.onValidNode.publish(record);
+  },
+
   hasSubscribers: function() {
     return !(this.onRemoteInsertNode.empty() && this.onRemoteRemoveNode.empty()
         && this.onRemoteUpdateNode.empty() && this.onDirtyNode.empty() && this.onCleanNode.empty());

client/lib/monarch/model/relations/selection.js

@@ -86,6 +86,14 @@ _.constructor("Monarch.Model.Relations.Selection", Monarch.Model.Relations.Relat
     this.operandsSubscriptionBundle.add(this.operand.onClean(function(record) {
       if (this.contains(record)) this.recordMadeClean(record);
     }, this));
+
+    this.operandsSubscriptionBundle.add(this.operand.onInvalid(function(record) {
+      if (this.contains(record)) this.recordMadeInvalid(record);
+    }, this));
+
+    this.operandsSubscriptionBundle.add(this.operand.onValid(function(record) {
+      if (this.contains(record)) this.recordMadeValid(record);
+    }, this));
   }
 });
 

client/spec/monarch/model/relations/difference_spec.js

@@ -198,18 +198,6 @@ Screw.Unit(function(c) { with(c) {
           });
         });
 
-        scenario("for onClean callbacks", function() {
-          init(function() {
-            eventType = "onClean";
-          });
-        });
-
-        scenario("for onDirty callbacks", function() {
-          init(function() {
-            eventType = "onDirty";
-          });
-        });
-
         it("subscribes to its #operand and memoizes tuples, then unsubscribes and clears the memoization, then resubscribes and rememoizes", function() {
           var rightOperand = User.where({age: 28});
           var difference = User.difference(rightOperand);

client/spec/monarch/model/relations/selection_spec.js

@@ -368,6 +368,37 @@ Screw.Unit(function(c) { with(c) {
           });
         });
       });
+
+      context("when a record is made invalid or valid in the selection's operand", function() {
+        var invalidCallback, validCallback;
+        before(function() {
+          invalidCallback = mockFunction('invalidCallback');
+          validCallback = mockFunction('validCallback');
+          selection.onInvalid(invalidCallback);
+          selection.onValid(validCallback);
+        });
+
+        context("when the record matches the selection's predicate", function() {
+          it("triggers onValid / onInvalid callbacks on the selection", function() {
+            var record = selection.first();
+            record.assignValidationErrors({age: ["too young!"]});
+            expect(invalidCallback).to(haveBeenCalled, withArgs(record));
+            record.clearValidationErrors();
+            expect(validCallback).to(haveBeenCalled, withArgs(record));
+          });
+        });
+
+        context("when the record does not match the selection's predicate", function() {
+          it("does not trigger onDirty / onClean callbacks on the selection", function() {
+            var record = User.fixture('mike');
+            expect(selection.contains(record)).to(beFalse);
+            record.assignValidationErrors({age: ["too young!"]});
+            expect(invalidCallback).toNot(haveBeenCalled);
+            record.clearValidationErrors();
+            expect(validCallback).toNot(haveBeenCalled);
+          });
+        });
+      });
     });
 
     describe("subscription propagation", function() {

client/spec/monarch/model/relations/table_spec.js

@@ -203,10 +203,10 @@ Screw.Unit(function(c) { with(c) {
       });
     });
 
-    describe("dirty / clean callback triggering", function() {
+    describe("onDirty / onClean callback triggering", function() {
       useLocalFixtures();
 
-      it("fires dirty / clean callbacks when a record in the table becomes dirty or clean", function() {
+      it("fires onDirty / onClean callbacks when a record in the table becomes dirty or clean", function() {
         var dirtyCallback = mockFunction('dirtyCallback');
         var cleanCallback = mockFunction('cleanCallback');
 
@@ -224,6 +224,26 @@ Screw.Unit(function(c) { with(c) {
       });
     });
 
+    describe("onInvalid / onValid callback triggering", function() {
+      useLocalFixtures();
+
+      it("fires onInvalid / onValid callbacks when a record in the table becomes invalid or valid again", function() {
+        var invalidCallback = mockFunction('invalidCallback');
+        var validCallback = mockFunction('validCallback');
+
+        User.table.onInvalid(invalidCallback);
+        User.table.onValid(validCallback);
+
+        var user = User.fixture('jan');
+        user.assignValidationErrors({fullName: ["some error"]});
+
+        expect(invalidCallback).to(haveBeenCalled, withArgs(user));
+
+        user.clearValidationErrors();
+        expect(validCallback).to(haveBeenCalled, withArgs(user));
+      });
+    });
+
     describe("#pauseEvents and #resumeEvents", function() {
       specify("#pauseEvents delays #onRemoteInsert, #onRemoteRemove, and #onRemoteUpdate triggers until #resumeEvents is called. Then delayed events are flushed and future events are no longer delayed", function() {
         var insertCallback = mockFunction("insert callback");