Fix bug caused when invoking $digest directly on a scope

rather than on root scope.  Any child scope of
sly-prevent-evaluation-when-hidden would return incorrect results.

Author: czerwingithub

scalyr.js

@@ -747,6 +747,7 @@ defineScalyrAngularModule('gatedScope', [])
       // We just have to do the work that normally a child class's
       // constructor would perform -- initializing our instance vars.
       result.$$gatingFunction = this.$$gatingFunction;
+      result.$$parentGatingFunction = this.$$gatingFunction;
       result.$$shouldGateFunction = this.$$shouldGateFunction;
       result.$$gatedWatchers = [];
 
@@ -848,7 +849,39 @@ defineScalyrAngularModule('gatedScope', [])
         return scopePrototype.$watch.call(this, watchExpression, listener, objectEquality);
       }
     };
-    
+
+    /**
+     * @inherited $digest
+     */
+    methodsToAdd.$digest = function gatedDigest() {
+      // We have to take care if a scope's digest method was invoked that has a
+      // gating function in the parent scope.  In this case, the watcher for that
+      // gating function is registered in the parent (the one added in gatedWatch),
+      // and will not be evaluated here.  So, we have to manually see if the gating
+      // function is true and if so, evaluate any gated watchers for that function on
+      // this scope.  This needs to happen to properly support invoking $digest on a
+      // scope with a parent scope with a gating function.
+      // NOTE:  It is arguable that we are not correctly handling nested gating functions
+      // here since we do not know if the parent gating function was nested in other gating
+      // functions and should be evaluated at all.  However, if a caller is invoking
+      // $digest on a particular scope, we assume the caller is doing that because it
+      // knows the watchers should be evaluated.
+      if (!isNull(this.$$parentGatingFunction) && this.$$parentGatingFunction()) {
+        var dirty = false;
+        var ttl = 5;
+        do {
+          dirty = this.$digestGated(this.$$parentGatingFunction);
+          ttl--;
+
+          if (dirty && !(ttl--)) {
+            throw Error(TTL + ' $digest() iterations reached for gated watcher. Aborting!\n' +
+                'Watchers fired in the last 5 iterations.');
+          }
+        } while (dirty);
+      }
+      return scopePrototype.$digest.call(this) || dirty;
+    }
+
     /**
      * Modifies this scope so that all future watchers registered by $watch will
      * only be evaluated if gatingFunction returns true.  Optionally, you may specify
@@ -916,6 +949,7 @@ defineScalyrAngularModule('gatedScope', [])
     angular.extend($rootScope, methodsToAdd);
 
     $rootScope.$$gatingFunction = null;
+    $rootScope.$$parentGatingFunction = null;
     $rootScope.$$shouldGateFunction = null;
     $rootScope.$$gatedWatchers = [];
 

src/js/lib/gatedScope.js

@@ -49,6 +49,7 @@ defineScalyrAngularModule('gatedScope', [])
       // We just have to do the work that normally a child class's
       // constructor would perform -- initializing our instance vars.
       result.$$gatingFunction = this.$$gatingFunction;
+      result.$$parentGatingFunction = this.$$gatingFunction;
       result.$$shouldGateFunction = this.$$shouldGateFunction;
       result.$$gatedWatchers = [];
 
@@ -150,7 +151,39 @@ defineScalyrAngularModule('gatedScope', [])
         return scopePrototype.$watch.call(this, watchExpression, listener, objectEquality);
       }
     };
-    
+
+    /**
+     * @inherited $digest
+     */
+    methodsToAdd.$digest = function gatedDigest() {
+      // We have to take care if a scope's digest method was invoked that has a
+      // gating function in the parent scope.  In this case, the watcher for that
+      // gating function is registered in the parent (the one added in gatedWatch),
+      // and will not be evaluated here.  So, we have to manually see if the gating
+      // function is true and if so, evaluate any gated watchers for that function on
+      // this scope.  This needs to happen to properly support invoking $digest on a
+      // scope with a parent scope with a gating function.
+      // NOTE:  It is arguable that we are not correctly handling nested gating functions
+      // here since we do not know if the parent gating function was nested in other gating
+      // functions and should be evaluated at all.  However, if a caller is invoking
+      // $digest on a particular scope, we assume the caller is doing that because it
+      // knows the watchers should be evaluated.
+      if (!isNull(this.$$parentGatingFunction) && this.$$parentGatingFunction()) {
+        var dirty = false;
+        var ttl = 5;
+        do {
+          dirty = this.$digestGated(this.$$parentGatingFunction);
+          ttl--;
+
+          if (dirty && !(ttl--)) {
+            throw Error(TTL + ' $digest() iterations reached for gated watcher. Aborting!\n' +
+                'Watchers fired in the last 5 iterations.');
+          }
+        } while (dirty);
+      }
+      return scopePrototype.$digest.call(this) || dirty;
+    }
+
     /**
      * Modifies this scope so that all future watchers registered by $watch will
      * only be evaluated if gatingFunction returns true.  Optionally, you may specify
@@ -218,6 +251,7 @@ defineScalyrAngularModule('gatedScope', [])
     angular.extend($rootScope, methodsToAdd);
 
     $rootScope.$$gatingFunction = null;
+    $rootScope.$$parentGatingFunction = null;
     $rootScope.$$shouldGateFunction = null;
     $rootScope.$$gatedWatchers = [];
 

src/tests/lib/gatedScopeTest.js

@@ -122,6 +122,40 @@ describe('GatedScope', function() {
     expect(counter).toEqual(6);
   });
 
+  it('should only evaluate gated watches on scope whose digest was invoked', function() {
+    var gateClosed = false;
+
+    var childA = $rootScope.$new();
+    childA.$addWatcherGate(function() {
+      return !gateClosed;
+    });
+
+    var childB = childA.$new();
+
+    var counter = 0;
+    var watchedVal = 1;
+    function watcher() {
+      ++counter;
+      return watchedVal;
+    }
+
+    childA.$watch(watcher);
+    childB.$watch(watcher);
+
+    childB.$digest();
+
+    // Only the watcher on B should fire since we invoked its digest.
+    expect(counter).toEqual(2);
+
+    counter = 0;
+    watchedValue = 2;
+    
+    childA.$digest();
+    // Both watches should evaluate twice (twice since the first time
+    // will indicate it is is dirty).
+    expect(counter).toEqual(4);
+  });
+
   it('should only evaluate gated watchers for gating function that returned true', function() {
     var counter1 = 0;
     function watcher1() {