fix($parse): one-time binding for literal expressions works as expected

Meaning the watcher is only removed when all the properties of the object, or
all the elements of the array, are defined.

Author: rodyhaddad

src/ng/parse.js

@@ -1017,8 +1017,12 @@ function $ParseProvider() {
             var parser = new Parser(lexer, $filter, $parseOptions);
             parsedExpression = parser.parse(exp);
 
-            if (oneTime) parsedExpression.$$beWatched = oneTimeWatch;
-            if (parsedExpression.constant) parsedExpression.$$beWatched = constantWatch;
+            if (parsedExpression.constant) {
+              parsedExpression.$$beWatched = constantWatch;
+            } else if (oneTime) {
+              parsedExpression.$$beWatched = parsedExpression.literal ?
+                oneTimeLiteralWatch : oneTimeWatch;
+            }
 
             if (cacheKey !== 'hasOwnProperty') {
             // Only cache the value if it's not going to mess up the cache object
@@ -1054,6 +1058,30 @@ function $ParseProvider() {
       }, objectEquality, deregisterNotifier);
     }
 
+    function oneTimeLiteralWatch(scope, listener, objectEquality, deregisterNotifier, parsedExpression) {
+      var unwatch;
+      return unwatch = scope.$watch(function oneTimeWatch(scope) {
+        return parsedExpression(scope);
+      }, function oneTimeListener(value, old, scope) {
+        if (isFunction(listener)) {
+          listener.call(this, value, old, scope);
+        }
+        if (!hasUndefined(value)) {
+          scope.$$postDigest(function () {
+            if(!hasUndefined(value)) unwatch();
+          });
+        }
+      }, objectEquality, deregisterNotifier);
+
+      function hasUndefined(value) {
+        var hasUndefined = false;
+        forEach(value, function (val) {
+          if (!isDefined(val)) hasUndefined = true;
+        });
+        return hasUndefined;
+      }
+    }
+
     function constantWatch(scope, listener, objectEquality, deregisterNotifier, parsedExpression) {
       var unwatch;
       return unwatch = scope.$watch(function constantWatch(scope) {

test/ng/parseSpec.js

@@ -1023,6 +1023,64 @@ describe('parser', function() {
           expect($rootScope.$$watchers.length).toBe(1);
           expect(log).toEqual('; man');
         }));
+
+        describe('literal expressions', function () {
+          it('should only become stable when all the properties of an object have defined values', inject(function ($parse, $rootScope, log){
+            var fn = $parse('::{foo: foo, bar: bar}');
+            $rootScope.$watch(fn, function(value) { log(value); }, true);
+
+            expect(log.empty()).toEqual([]);
+            expect($rootScope.$$watchers.length).toBe(1);
+
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(1);
+            expect(log.empty()).toEqual([{foo: undefined, bar: undefined}]);
+
+            $rootScope.foo = 'foo';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(1);
+            expect(log.empty()).toEqual([{foo: 'foo', bar: undefined}]);
+
+            $rootScope.foo = 'foobar';
+            $rootScope.bar = 'bar';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(0);
+            expect(log.empty()).toEqual([{foo: 'foobar', bar: 'bar'}]);
+
+            $rootScope.foo = 'baz';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(0);
+            expect(log.empty()).toEqual([]);
+          }));
+
+          it('should only become stable when all the elements of an array have defined values', inject(function ($parse, $rootScope, log){
+            var fn = $parse('::[foo,bar]');
+            $rootScope.$watch(fn, function(value) { log(value); }, true);
+
+            expect(log.empty()).toEqual([]);
+            expect($rootScope.$$watchers.length).toBe(1);
+
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(1);
+            expect(log.empty()).toEqual([[undefined, undefined]]);
+
+            $rootScope.foo = 'foo';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(1);
+            expect(log.empty()).toEqual([['foo', undefined]]);
+
+            $rootScope.foo = 'foobar';
+            $rootScope.bar = 'bar';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(0);
+            expect(log.empty()).toEqual([['foobar', 'bar']]);
+
+            $rootScope.foo = 'baz';
+            $rootScope.$digest();
+            expect($rootScope.$$watchers.length).toBe(0);
+            expect(log.empty()).toEqual([]);
+          }));
+        });
       });
 
       describe('locals', function() {