WIP: fix valueOf

Author: IgorMinar

src/ng/parse.js

@@ -1080,8 +1080,11 @@ function $ParseProvider() {
       return list;
     }
 
-    function expressionInputDirtyCheck(newValue, oldValue) {
-      if (newValue == null || oldValue == null) return newValue === oldValue; // null/undefined
+    function expressionInputDirtyCheck(newValue, oldValueOfValue) {
+
+      if (newValue == null || oldValueOfValue == null) { // null/undefined
+        return newValue === oldValueOfValue;
+      }
 
       if (typeof newValue === 'object') {
 
@@ -1095,13 +1098,11 @@ function $ParseProvider() {
           return false;
         }
 
-        oldValue = oldValue.valueOf();
-
         // fall-through to the primitive equality check
       }
 
       //Primitive or NaN
-      return newValue === oldValue || (newValue !== newValue && oldValue !== oldValue);
+      return newValue === oldValueOfValue || (newValue !== newValue && oldValueOfValue !== oldValueOfValue);
     }
 
     function inputsWatchDelegate(scope, listener, objectEquality, parsedExpression) {
@@ -1117,24 +1118,24 @@ function $ParseProvider() {
           var newInputValue = inputExpressions(scope);
           if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) {
             lastResult = parsedExpression(scope);
-            oldInputValue = newInputValue;
+            oldInputValue = newInputValue.valueOf();
           }
           return lastResult;
         }, listener, objectEquality);
       }
 
-      var oldInputValues = [];
+      var oldInputValueOfValues = [];
       for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
-        oldInputValues[i] = expressionInputDirtyCheck; // init to something unique so that equals check fails
+        oldInputValueOfValues[i] = expressionInputDirtyCheck; // init to something unique so that equals check fails
       }
 
       return scope.$watch(function expressionInputsWatch(scope) {
         var changed = false;
 
         for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
           var newInputValue = inputExpressions[i](scope);
-          if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValues[i]))) {
-            oldInputValues[i] = newInputValue;
+          if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) {
+            oldInputValueOfValues[i] = newInputValue && newInputValue.valueOf();
           }
         }
 

test/ng/parseSpec.js

@@ -1486,6 +1486,34 @@ describe('parser', function() {
           expect(watcherCalls).toBe(1);
         }));
 
+        it("should reevaluate filters with non-primitive input that does support valueOf() when" +
+           "valueOf() value changes", inject(function($parse) {
+          var filterCalls = 0;
+          $filterProvider.register('foo', valueFn(function(input) {
+            filterCalls++;
+            return input;
+          }));
+
+          var parsed = $parse('date | foo');
+          var date = scope.date = new Date();
+
+          var watcherCalls = 0;
+          scope.$watch(parsed, function(input) {
+            expect(input).toBe(date);
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(filterCalls).toBe(1);
+          expect(watcherCalls).toBe(1);
+
+          date.setYear(1901);
+
+          scope.$digest();
+          expect(filterCalls).toBe(2);
+          expect(watcherCalls).toBe(1);
+        }));
+
         it('should invoke interceptorFns if they are flagged as having externalInput',
             inject(function($parse) {
           var called = false;