From 44e5646d55cecd6bff01bbd8c8b860620be13976 Mon Sep 17 00:00:00 2001 From: Marc PYNAERT Date: Tue, 31 Jul 2018 16:49:35 +0200 Subject: [PATCH] Add support of 2 new operators: - ANYOF that matches if 2 arrays have an intersection - NONEOF that matches if 2 arrays have no intersection --- README.md | 46 ++++++------ .../java/com/jayway/jsonpath/Criteria.java | 50 +++++++++++++ .../internal/filter/EvaluatorFactory.java | 75 +++++++++++++++++++ .../internal/filter/RelationalOperator.java | 4 +- .../com/jayway/jsonpath/FilterParseTest.java | 20 ++++- .../java/com/jayway/jsonpath/FilterTest.java | 31 +++++++- 6 files changed, 201 insertions(+), 25 deletions(-) diff --git a/README.md b/README.md index 68fa76a8..f9059332 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ JsonPath is available at the Central Maven Repository. Maven users add this to y com.jayway.jsonpath json-path - 2.3.0 + 2.4.0 ``` @@ -77,13 +77,13 @@ Functions Functions can be invoked at the tail end of a path - the input to a function is the output of the path expression. The function output is dictated by the function itself. -| Function | Description | Output | -| :------------------------ | :----------------------------------------------------------------- |-----------| -| min() | Provides the min value of an array of numbers | Double | -| max() | Provides the max value of an array of numbers | Double | -| avg() | Provides the average value of an array of numbers | Double | -| stddev() | Provides the standard deviation value of an array of numbers | Double | -| length() | Provides the length of an array | Integer | +| Function | Description | Output | +| :------------------------ | :------------------------------------------------------------------ |-----------| +| min() | Provides the min value of an array of numbers | Double | +| max() | Provides the max value of an array of numbers | Double | +| avg() | Provides the average value of an array of numbers | Double | +| stddev() | Provides the standard deviation value of an array of numbers | Double | +| length() | Provides the length of an array | Integer | Filter Operators @@ -91,20 +91,22 @@ Filter Operators Filters are logical expressions used to filter arrays. A typical filter would be `[?(@.age > 18)]` where `@` represents the current item being processed. More complex filters can be created with logical operators `&&` and `||`. String literals must be enclosed by single or double quotes (`[?(@.color == 'blue')]` or `[?(@.color == "blue")]`). -| Operator | Description | -| :----------------------- | :---------------------------------------------------------------- | -| == | left is equal to right (note that 1 is not equal to '1') | -| != | left is not equal to right | -| < | left is less than right | -| <= | left is less or equal to right | -| > | left is greater than right | -| >= | left is greater than or equal to right | -| =~ | left matches regular expression [?(@.name =~ /foo.*?/i)] | -| in | left exists in right [?(@.size in ['S', 'M'])] | -| nin | left does not exists in right | -| subsetof | left is a subset of right [?(@.sizes subsetof ['S', 'M', 'L'])] | -| size | size of left (array or string) should match right | -| empty | left (array or string) should be empty | +| Operator | Description | +| :----------------------- | :-------------------------------------------------------------------- | +| == | left is equal to right (note that 1 is not equal to '1') | +| != | left is not equal to right | +| < | left is less than right | +| <= | left is less or equal to right | +| > | left is greater than right | +| >= | left is greater than or equal to right | +| =~ | left matches regular expression [?(@.name =~ /foo.*?/i)] | +| in | left exists in right [?(@.size in ['S', 'M'])] | +| nin | left does not exists in right | +| subsetof | left is a subset of right [?(@.sizes subsetof ['S', 'M', 'L'])] | +| anyof | left has an intersection with right [?(@.sizes anyof ['M', 'L'])] | +| noneof | left has no intersection with right [?(@.sizes noneof ['M', 'L'])] | +| size | size of left (array or string) should match right | +| empty | left (array or string) should be empty | Path Examples diff --git a/json-path/src/main/java/com/jayway/jsonpath/Criteria.java b/json-path/src/main/java/com/jayway/jsonpath/Criteria.java index 92f9b2bc..b06f4e64 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/Criteria.java +++ b/json-path/src/main/java/com/jayway/jsonpath/Criteria.java @@ -294,6 +294,56 @@ public class Criteria implements Predicate { return this; } + /** + * The anyof operator selects objects for which the specified field is + * an array that contain at least an element in the specified array. + * + * @param o the values to match against + * @return the criteria + */ + public Criteria anyof(Object... o) { + return subsetof(Arrays.asList(o)); + } + + /** + * The anyof operator selects objects for which the specified field is + * an array that contain at least an element in the specified array. + * + * @param c the values to match against + * @return the criteria + */ + public Criteria anyof(Collection c) { + notNull(c, "collection can not be null"); + this.criteriaType = RelationalOperator.ANYOF; + this.right = new ValueNode.ValueListNode(c); + return this; + } + + /** + * The noneof operator selects objects for which the specified field is + * an array that does not contain any of the elements of the specified array. + * + * @param o the values to match against + * @return the criteria + */ + public Criteria noneof(Object... o) { + return subsetof(Arrays.asList(o)); + } + + /** + * The noneof operator selects objects for which the specified field is + * an array that does not contain any of the elements of the specified array. + * + * @param c the values to match against + * @return the criteria + */ + public Criteria noneof(Collection c) { + notNull(c, "collection can not be null"); + this.criteriaType = RelationalOperator.NONEOF; + this.right = new ValueNode.ValueListNode(c); + return this; + } + /** * The all operator is similar to $in, but instead of matching any value * in the specified array all values in the array must be matched. diff --git a/json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java b/json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java index ac47274a..47cd8190 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java +++ b/json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java @@ -30,6 +30,8 @@ public class EvaluatorFactory { evaluators.put(RelationalOperator.MATCHES, new PredicateMatchEvaluator()); evaluators.put(RelationalOperator.TYPE, new TypeEvaluator()); evaluators.put(RelationalOperator.SUBSETOF, new SubsetOfEvaluator()); + evaluators.put(RelationalOperator.ANYOF, new AnyOfEvaluator()); + evaluators.put(RelationalOperator.NONEOF, new NoneOfEvaluator()); } public static Evaluator createEvaluator(RelationalOperator operator){ @@ -295,4 +297,77 @@ public class EvaluatorFactory { } } + private static class AnyOfEvaluator implements Evaluator { + @Override + public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) { + ValueNode.ValueListNode rightValueListNode; + if (right.isJsonNode()) { + ValueNode vn = right.asJsonNode().asValueListNode(ctx); + if (vn.isUndefinedNode()) { + return false; + } else { + rightValueListNode = vn.asValueListNode(); + } + } else { + rightValueListNode = right.asValueListNode(); + } + ValueNode.ValueListNode leftValueListNode; + if (left.isJsonNode()) { + ValueNode vn = left.asJsonNode().asValueListNode(ctx); + if (vn.isUndefinedNode()) { + return false; + } else { + leftValueListNode = vn.asValueListNode(); + } + } else { + leftValueListNode = left.asValueListNode(); + } + + for (ValueNode leftValueNode : leftValueListNode) { + for (ValueNode rightValueNode : rightValueListNode) { + if (leftValueNode.equals(rightValueNode)) { + return true; + } + } + } + return false; + } + } + + private static class NoneOfEvaluator implements Evaluator { + @Override + public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) { + ValueNode.ValueListNode rightValueListNode; + if (right.isJsonNode()) { + ValueNode vn = right.asJsonNode().asValueListNode(ctx); + if (vn.isUndefinedNode()) { + return false; + } else { + rightValueListNode = vn.asValueListNode(); + } + } else { + rightValueListNode = right.asValueListNode(); + } + ValueNode.ValueListNode leftValueListNode; + if (left.isJsonNode()) { + ValueNode vn = left.asJsonNode().asValueListNode(ctx); + if (vn.isUndefinedNode()) { + return false; + } else { + leftValueListNode = vn.asValueListNode(); + } + } else { + leftValueListNode = left.asValueListNode(); + } + + for (ValueNode leftValueNode : leftValueListNode) { + for (ValueNode rightValueNode : rightValueListNode) { + if (leftValueNode.equals(rightValueNode)) { + return false; + } + } + } + return true; + } + } } diff --git a/json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java b/json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java index 830cc3bb..84e2aed0 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java +++ b/json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java @@ -30,7 +30,9 @@ public enum RelationalOperator { TYPE("TYPE"), MATCHES("MATCHES"), EMPTY("EMPTY"), - SUBSETOF("SUBSETOF"); + SUBSETOF("SUBSETOF"), + ANYOF("ANYOF"), + NONEOF("NONEOF"); private final String operatorString; diff --git a/json-path/src/test/java/com/jayway/jsonpath/FilterParseTest.java b/json-path/src/test/java/com/jayway/jsonpath/FilterParseTest.java index 948ca75f..37e37f79 100644 --- a/json-path/src/test/java/com/jayway/jsonpath/FilterParseTest.java +++ b/json-path/src/test/java/com/jayway/jsonpath/FilterParseTest.java @@ -1,9 +1,9 @@ package com.jayway.jsonpath; -import java.util.Collections; import org.assertj.core.api.Assertions; import org.junit.Test; +import java.util.Collections; import java.util.regex.Pattern; import static com.jayway.jsonpath.Criteria.where; @@ -152,6 +152,24 @@ public class FilterParseTest { assertThat(filter).isEqualTo(parsed); } + @Test + public void a_anyof_filter_can_be_serialized() { + + String filter = filter(where("a").anyof(Collections.emptyList())).toString(); + String parsed = parse("[?(@['a'] ANYOF [])]").toString(); + + assertThat(filter).isEqualTo(parsed); + } + + @Test + public void a_noneof_filter_can_be_serialized() { + + String filter = filter(where("a").noneof(Collections.emptyList())).toString(); + String parsed = parse("[?(@['a'] NONEOF [])]").toString(); + + assertThat(filter).isEqualTo(parsed); + } + @Test public void a_exists_filter_can_be_serialized() { diff --git a/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java b/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java index e786ae83..84153b32 100644 --- a/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java +++ b/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java @@ -1,6 +1,5 @@ package com.jayway.jsonpath; -import java.util.ArrayList; import org.assertj.core.util.Lists; import org.junit.Test; @@ -378,6 +377,36 @@ public class FilterTest extends BaseTest { assertThat(filter(where("string-arr").subsetof(list)).apply(createPredicateContext(json))).isEqualTo(false); } + //---------------------------------------------------------------------------- + // + // ANYOF + // + //---------------------------------------------------------------------------- + @Test + public void array_anyof_evals() { + List list = Lists.newArrayList("a", "z"); + assertThat(filter(where("string-arr").anyof(list)).apply(createPredicateContext(json))).isEqualTo(true); + list = Lists.newArrayList("z", "b", "a"); + assertThat(filter(where("string-arr").anyof(list)).apply(createPredicateContext(json))).isEqualTo(true); + list = Lists.newArrayList("x", "y", "z"); + assertThat(filter(where("string-arr").anyof(list)).apply(createPredicateContext(json))).isEqualTo(false); + } + + //---------------------------------------------------------------------------- + // + // NONEOF + // + //---------------------------------------------------------------------------- + @Test + public void array_noneof_evals() { + List list = Lists.newArrayList("a", "z"); + assertThat(filter(where("string-arr").noneof(list)).apply(createPredicateContext(json))).isEqualTo(false); + list = Lists.newArrayList("z", "b", "a"); + assertThat(filter(where("string-arr").noneof(list)).apply(createPredicateContext(json))).isEqualTo(false); + list = Lists.newArrayList("x", "y", "z"); + assertThat(filter(where("string-arr").noneof(list)).apply(createPredicateContext(json))).isEqualTo(true); + } + //---------------------------------------------------------------------------- // // EXISTS