feat(Scope): add $watchSet method for observing a set of expressions

It any one expression changes then the listener function fires
Port of dart-archive/angular.dart@a3c31ce

Author: rodyhaddad

src/ng/rootScope.js

@@ -354,6 +354,68 @@ function $RootScopeProvider(){
         };
       },
 
+      /**
+       * @ngdoc method
+       * @name $rootScope.Scope#$watchSet
+       * @function
+       *
+       * @description
+       * A variant of {@link ng.$rootScope.Scope#$watch $watch()} where it watches an array of `watchExpressions`.
+       * If any one expression in the collection changes the `listener` is executed.
+       *
+       * - The items in the `watchCollection` array are observed via standard $watch operation and are examined on every
+       *   call to $digest() to see if any items changes.
+       * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
+       *
+       * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+       * watched using {@link ng.$rootScope.Scope#$watch $watch()}
+       *
+       * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+       *    expression in `watchExpressions` changes
+       *    The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
+       *    those of `watchExpression`
+       *    and the `oldValues` array contains the previous values of the `watchExpressions`, with the indexes matching
+       *    those of `watchExpression`
+       *    The `scope` refers to the current scope.
+       *
+       * @returns {function()} Returns a de-registration function for all listeners.
+       */
+      $watchSet: function (watchExpressions, listener) {
+        if (watchExpressions.length === 0) return noop;
+
+        var oldValues = new Array(watchExpressions.length),
+            newValues = new Array(watchExpressions.length);
+
+        if (watchExpressions.length === 1) {
+          // Special case size of one
+          return this.$watch(watchExpressions[0], function (value, oldValue, scope) {
+            newValues[0] = value;
+            oldValues[0] = oldValue;
+            listener.call(this, newValues, oldValues, scope);
+          });
+        }
+        var deregisterFns = [],
+            changeCount = 0;
+
+        forEach(watchExpressions, function (expr, i) {
+          deregisterFns.push(this.$watch(expr, function (value, oldValue) {
+            newValues[i] = value;
+            oldValues[i] = oldValue;
+            changeCount++;
+          }));
+        }, this);
+
+        deregisterFns.push(this.$watch(function () {return changeCount;}, function (c, o, scope) {
+          listener.call(this, newValues, oldValues, scope);
+        }));
+
+        return function () {
+          forEach(deregisterFns, function (fn) {
+            fn();
+          });
+        };
+      },
+
 
       /**
        * @ngdoc method

test/ng/rootScopeSpec.js

@@ -733,6 +733,76 @@ describe('Scope', function() {
     });
   });
 
+  describe('$watchSet', function() {
+    var scope;
+    beforeEach(inject(function($rootScope) {
+      scope = $rootScope.$new();
+    }));
+
+    it('should skip empty sets', function() {
+      expect(scope.$watchSet([], null)()).toBeUndefined();
+    });
+
+    it('should treat set of 1 as direct watch', function() {
+      var lastValues = ['foo'];
+      var log = '';
+      var clean = scope.$watchSet(['a'], function(values, oldValues, s) {
+        log += values.join(',') + ';';
+        expect(s).toBe(scope);
+        expect(oldValues).toEqual(lastValues);
+        lastValues = values.slice();
+      });
+
+      scope.a = 'foo';
+      scope.$digest();
+      expect(log).toEqual('foo;');
+
+      scope.$digest();
+      expect(log).toEqual('foo;');
+
+      scope.a = 'bar';
+      scope.$digest();
+      expect(log).toEqual('foo;bar;');
+
+      clean();
+      scope.a = 'xxx';
+      scope.$digest();
+      expect(log).toEqual('foo;bar;');
+    });
+
+    it('should detect a change to any one in a set', function() {
+      var lastValues = ['foo', 'bar'];
+      var log = '';
+      var clean = scope.$watchSet(['a', 'b'], function(values, oldValues, s) {
+        log += values.join(',') + ';';
+        expect(s).toBe(scope);
+        expect(oldValues).toEqual(lastValues);
+        lastValues = values.slice();
+      });
+
+      scope.a = 'foo';
+      scope.b = 'bar';
+      scope.$digest();
+      expect(log).toEqual('foo,bar;');
+
+      scope.$digest();
+      expect(log).toEqual('foo,bar;');
+
+      scope.a = 'a';
+      scope.$digest();
+      expect(log).toEqual('foo,bar;a,bar;');
+
+      scope.a = 'A';
+      scope.b = 'B';
+      scope.$digest();
+      expect(log).toEqual('foo,bar;a,bar;A,B;');
+
+      clean();
+      scope.a = 'xxx';
+      scope.$digest();
+      expect(log).toEqual('foo,bar;a,bar;A,B;');
+    });
+  });
 
   describe('$destroy', function() {
     var first = null, middle = null, last = null, log = null;