FilterFilter nested expression support renders strict option useless

[shineli-not-used-anymore]

Since https://github.com/angular/angular.js/pull/6215/files#r9626594, passing true to strict in the filterFilter is no longer working when nested predicate object is used to filter nested properties of an object.

<div ng-repeat="it in items | filter:{ address: { country: 'Canuckistan'} }"></div>

is working

<div ng-repeat="it in items | filter:{ address: { country: 'Canuckistan'} }:true"></div>

is not.

[albertboada]

Would it work as you expect with a simple POJO predicate (not nested) like this one below, assuming it wasn't nested either?

<div ng-repeat="it in items | filter:{ country: 'Canuckistan' }:true"></div>

I don't think this would work as you expect, either. This is because (I think) nested objects are not the ones to blame here.

The strict comparator compares the whole it object with the predicate object. Im sure
it !== { address: { country: 'Canuckistan'} } in your application (it sure has more fields, so the objects are not equal). This is why the filter doesn't work as you expect. https://github.com/angular/angular.js/blob/master/src/ng/filter/filter.js#L134

Should this continue this way? Should this logic be changed for a more intuitive approach? I say you better write your own comparator for the moment.

[shineli-not-used-anymore]

Hey @albertboada ,

I agree with you that the bottom of the problem is not the nested objects. Apparently, I have different interpretation of what the strict means when it comes to playing with nested predicate.

BTW, <div ng-repeat="it in items | filter:{ country: 'Canuckistan' }:true"></div> had been working before the nested predicate was introduced.

So I went back to the doc https://docs.angularjs.org/api/ng/filter/filter. the expression parameter is described as:

The predicate to be used for selecting items from array.

And the comparator is as:

is used in determining if the expected value (from the filter expression) and actual value (from the object in the array) should be considered a match

While I understand it !== { address: { country: 'Canuckistan'} }, should the condition to be predicate(it) === 'Canuckistan' ---pseud code when strict is true since the purpose of predicate is to select the value from it instead of being the value to be compared to.

From the source code I can see that when strict is true, the code to handle the nested predicate is not effective since it is in the comparator not predicate. The author of that pull request @caitp left a comment:

It would be nicer to add these nested checks as predicates to avoid a stack overflow, but this would be a much more complicated fix

If my understanding is correct, the existence of this bug is because the nested predicate support is done in the comparator instead of predicate.

I indeed wrote my own filter to handle this. However, IMHO, the code to handle nested predicate should be in the predicate not comparator.

[albertboada]

Not sure why I'm coming back to this, but, some months later, I absolutely agree the strict option on object predicates should check for exact properties values, instead of equality of the whole predicate object. It is scary, tho, that not even @caitp wanted to go thru all this when she did the tweaks. I would not know where to start, but +1 👍.