From a45b1f6661bfeb198aa41b9267e84fdde0df6b6f Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Fri, 10 Oct 2014 19:57:47 -0300 Subject: [PATCH 1/8] enable dirty checking for objects created with Object.create(null) in order not to inherit from Object --- src/ng/parse.js | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/ng/parse.js b/src/ng/parse.js index 58ddca7e1e46..91308e9f81e4 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -1092,7 +1092,8 @@ function $ParseProvider() { // attempt to convert the value to a primitive type // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can // be cheaply dirty-checked - newValue = newValue.valueOf(); + typeof newValue.valueOf !== 'function' && (newValue = Object.valueOf.apply(newValue)) || + (newValue = newValue.valueOf()); if (typeof newValue === 'object') { // objects/arrays are not supported - deep-watching them would be too expensive @@ -1119,7 +1120,8 @@ function $ParseProvider() { var newInputValue = inputExpressions(scope); if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) { lastResult = parsedExpression(scope); - oldInputValue = newInputValue && newInputValue.valueOf(); + oldInputValue = newInputValue && typeof newInputValue.valueOf !== 'function' && + Object.valueOf.apply(newInputValue) || newInputValue.valueOf(); } return lastResult; }, listener, objectEquality); @@ -1136,7 +1138,8 @@ function $ParseProvider() { for (var i = 0, ii = inputExpressions.length; i < ii; i++) { var newInputValue = inputExpressions[i](scope); if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) { - oldInputValueOfValues[i] = newInputValue && newInputValue.valueOf(); + oldInputValueOfValues[i] = newInputValue && typeof newInputValue.valueOf !== 'function' && + Object.valueOf.apply(newInputValue) || newInputValue.valueOf(); } } From 256f29fb308bd81585c1246eb93c16f427c33dfb Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Fri, 10 Oct 2014 20:34:09 -0300 Subject: [PATCH 2/8] Object.valueOf method cached as valueOfObject --- src/Angular.js | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Angular.js b/src/Angular.js index 9b421aca53c4..a49784ec8761 100644 --- a/src/Angular.js +++ b/src/Angular.js @@ -126,6 +126,7 @@ var VALIDITY_STATE_PROPERTY = 'validity'; */ var lowercase = function(string){return isString(string) ? string.toLowerCase() : string;}; var hasOwnProperty = Object.prototype.hasOwnProperty; +var valueOfObject = Object.prototype.valueOf; /** * @ngdoc function From 91235364e548e5ce35387832bda3a1b00f86935f Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Fri, 10 Oct 2014 20:35:38 -0300 Subject: [PATCH 3/8] pr updated with newly cached method on Angular.js --- src/ng/parse.js | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/ng/parse.js b/src/ng/parse.js index 91308e9f81e4..5465d454cab8 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -1092,8 +1092,7 @@ function $ParseProvider() { // attempt to convert the value to a primitive type // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can // be cheaply dirty-checked - typeof newValue.valueOf !== 'function' && (newValue = Object.valueOf.apply(newValue)) || - (newValue = newValue.valueOf()); + newValue = valueOfObject.call(newValue); if (typeof newValue === 'object') { // objects/arrays are not supported - deep-watching them would be too expensive @@ -1120,8 +1119,7 @@ function $ParseProvider() { var newInputValue = inputExpressions(scope); if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) { lastResult = parsedExpression(scope); - oldInputValue = newInputValue && typeof newInputValue.valueOf !== 'function' && - Object.valueOf.apply(newInputValue) || newInputValue.valueOf(); + oldInputValue = newInputValue && valueOfObject.call(newInputValue); } return lastResult; }, listener, objectEquality); @@ -1138,8 +1136,7 @@ function $ParseProvider() { for (var i = 0, ii = inputExpressions.length; i < ii; i++) { var newInputValue = inputExpressions[i](scope); if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) { - oldInputValueOfValues[i] = newInputValue && typeof newInputValue.valueOf !== 'function' && - Object.valueOf.apply(newInputValue) || newInputValue.valueOf(); + oldInputValueOfValues[i] = newInputValue && valueOfObject.call(newInputValue); } } From a0fd09844ebbb48da7f5b29c5f727cb131aba266 Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Fri, 10 Oct 2014 21:37:20 -0300 Subject: [PATCH 4/8] updated to use own valueOf when available --- src/Angular.js | 1 - src/ng/parse.js | 13 ++++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/Angular.js b/src/Angular.js index a49784ec8761..9b421aca53c4 100644 --- a/src/Angular.js +++ b/src/Angular.js @@ -126,7 +126,6 @@ var VALIDITY_STATE_PROPERTY = 'validity'; */ var lowercase = function(string){return isString(string) ? string.toLowerCase() : string;}; var hasOwnProperty = Object.prototype.hasOwnProperty; -var valueOfObject = Object.prototype.valueOf; /** * @ngdoc function diff --git a/src/ng/parse.js b/src/ng/parse.js index 5465d454cab8..1dd6e799a712 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -946,6 +946,13 @@ function getterFn(path, options, fullExp) { return fn; } +function valueOfAgnostic(value){ + if(typeof value.valueOf !== 'function'){ + return Object.prototype.valueOf.call(value); + } + return value.valueOf(); +} + /////////////////////////////////// /** @@ -1092,7 +1099,7 @@ function $ParseProvider() { // attempt to convert the value to a primitive type // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can // be cheaply dirty-checked - newValue = valueOfObject.call(newValue); + newValue = valueOfAgnostic(newValue); if (typeof newValue === 'object') { // objects/arrays are not supported - deep-watching them would be too expensive @@ -1119,7 +1126,7 @@ function $ParseProvider() { var newInputValue = inputExpressions(scope); if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) { lastResult = parsedExpression(scope); - oldInputValue = newInputValue && valueOfObject.call(newInputValue); + oldInputValue = newInputValue && valueOfAgnostic(newInputValue); } return lastResult; }, listener, objectEquality); @@ -1136,7 +1143,7 @@ function $ParseProvider() { for (var i = 0, ii = inputExpressions.length; i < ii; i++) { var newInputValue = inputExpressions[i](scope); if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) { - oldInputValueOfValues[i] = newInputValue && valueOfObject.call(newInputValue); + oldInputValueOfValues[i] = newInputValue && valueOfAgnostic(newInputValue); } } From dc5a43a907b89e42f5d124d313b8a7ced5b326b5 Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Sun, 12 Oct 2014 16:22:02 -0300 Subject: [PATCH 5/8] Test for Object.create(null) parsing added. Special thanks to Julian Mayorga who provided the test case! --- test/ng/parseSpec.js | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/test/ng/parseSpec.js b/test/ng/parseSpec.js index cc36b35a483b..88add734f0db 100644 --- a/test/ng/parseSpec.js +++ b/test/ng/parseSpec.js @@ -1460,6 +1460,32 @@ describe('parser', function() { expect(watcherCalls).toBe(1); })); + it("should always reevaluate filters with non-primitive input created with Object.create(null)", + inject(function($parse) { + var filterCalls = 0; + $filterProvider.register('foo', valueFn(function(input) { + filterCalls++; + return input; + })); + + var parsed = $parse('obj | foo'); + var obj = scope.obj = Object.create(null); + + var watcherCalls = 0; + scope.$watch(parsed, function(input) { + expect(input).toBe(obj); + watcherCalls++; + }); + + scope.$digest(); + expect(filterCalls).toBe(2); + expect(watcherCalls).toBe(1); + + scope.$digest(); + expect(filterCalls).toBe(3); + expect(watcherCalls).toBe(1); + })); + it("should not reevaluate filters with non-primitive input that does support valueOf()", inject(function($parse) { var filterCalls = 0; From cc0c09919e2d3879fb6b1269c5887d1465a494b4 Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Mon, 13 Oct 2014 20:10:17 -0300 Subject: [PATCH 6/8] fix(parse): add support to Object.create(null) based bindings with the changes requested --- src/ng/parse.js | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/ng/parse.js b/src/ng/parse.js index 1dd6e799a712..06a6e98b6c03 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -946,11 +946,10 @@ function getterFn(path, options, fullExp) { return fn; } -function valueOfAgnostic(value){ - if(typeof value.valueOf !== 'function'){ - return Object.prototype.valueOf.call(value); - } - return value.valueOf(); +var objectValueOf = Object.prototype.valueOf; + +function getValueOf(value) { + return isFunction(value.valueOf) ? value.valueOf() : objectValueOf(value); } /////////////////////////////////// @@ -1099,7 +1098,7 @@ function $ParseProvider() { // attempt to convert the value to a primitive type // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can // be cheaply dirty-checked - newValue = valueOfAgnostic(newValue); + newValue = getValueOf(newValue); if (typeof newValue === 'object') { // objects/arrays are not supported - deep-watching them would be too expensive @@ -1126,7 +1125,7 @@ function $ParseProvider() { var newInputValue = inputExpressions(scope); if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) { lastResult = parsedExpression(scope); - oldInputValue = newInputValue && valueOfAgnostic(newInputValue); + oldInputValue = newInputValue && getValueOf(newInputValue); } return lastResult; }, listener, objectEquality); @@ -1143,7 +1142,7 @@ function $ParseProvider() { for (var i = 0, ii = inputExpressions.length; i < ii; i++) { var newInputValue = inputExpressions[i](scope); if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) { - oldInputValueOfValues[i] = newInputValue && valueOfAgnostic(newInputValue); + oldInputValueOfValues[i] = newInputValue && getValueOf(newInputValue); } } From 443a43c1753e1eac7106a75fbaa6c939ff08bfb5 Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Mon, 13 Oct 2014 21:17:52 -0300 Subject: [PATCH 7/8] fix(parse): missing call to get the correct scope --- src/ng/parse.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ng/parse.js b/src/ng/parse.js index 06a6e98b6c03..fd3a8448e520 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -946,7 +946,7 @@ function getterFn(path, options, fullExp) { return fn; } -var objectValueOf = Object.prototype.valueOf; +var objectValueOf = Object.prototype.valueOf.call; function getValueOf(value) { return isFunction(value.valueOf) ? value.valueOf() : objectValueOf(value); From 87f65fd783f2b80694b1ded9d01c55c79ec2211b Mon Sep 17 00:00:00 2001 From: HeberLZ Date: Tue, 14 Oct 2014 00:01:03 -0300 Subject: [PATCH 8/8] fix(parse): support parsing objects created with null prototype --- src/ng/parse.js | 4 ++-- test/ng/parseSpec.js | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ng/parse.js b/src/ng/parse.js index fd3a8448e520..f2bb16617091 100644 --- a/src/ng/parse.js +++ b/src/ng/parse.js @@ -946,10 +946,10 @@ function getterFn(path, options, fullExp) { return fn; } -var objectValueOf = Object.prototype.valueOf.call; +var objectValueOf = Object.prototype.valueOf; function getValueOf(value) { - return isFunction(value.valueOf) ? value.valueOf() : objectValueOf(value); + return isFunction(value.valueOf) ? value.valueOf() : objectValueOf.call(value); } /////////////////////////////////// diff --git a/test/ng/parseSpec.js b/test/ng/parseSpec.js index 88add734f0db..e274c835884f 100644 --- a/test/ng/parseSpec.js +++ b/test/ng/parseSpec.js @@ -1460,7 +1460,7 @@ describe('parser', function() { expect(watcherCalls).toBe(1); })); - it("should always reevaluate filters with non-primitive input created with Object.create(null)", + it("should always reevaluate filters with non-primitive input created with null prototype", inject(function($parse) { var filterCalls = 0; $filterProvider.register('foo', valueFn(function(input) {