Merge pull request #517 from json-path/revert-488-master

Revert "Add support of new operators ANYOF and NONEOF"

README.md

@@ -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    |
+| Function                  | Description                                                        | Output    |
-| :------------------------ | :------------------------------------------------------------------ |-----------|
+| :------------------------ | :----------------------------------------------------------------- |-----------|
-| min()                     | Provides the min value of an array of numbers                       | Double    |
+| min()                    | Provides the min value of an array of numbers                       | Double    |
-| max()                     | Provides the max 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    |
+| avg()                    | Provides the average value of an array of numbers                   | Double    |
-| stddev()                  | Provides the standard deviation 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   |
+| length()                 | Provides the length of an array                                     | Integer   |
 
 
 Filter Operators
@@ -91,22 +91,20 @@ 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                                                           |
+| Operator                 | Description                                                       |
-| :----------------------- | :-------------------------------------------------------------------- |
+| :----------------------- | :---------------------------------------------------------------- |
-| ==                       | left is equal to right (note that 1 is not equal to '1')              |
+| ==                       | left is equal to right (note that 1 is not equal to '1')          |
-| !=                       | left is not equal to right                                            |
+| !=                       | left is not equal to right                                        |
-| <                        | left is less than right                                               |
+| <                        | left is less than right                                           |
-| <=                       | left is less or equal to right                                        |
+| <=                       | left is less or equal to right                                    |
-| >                        | left is greater than right                                            |
+| >                        | left is greater than right                                        |
-| >=                       | left is greater than or equal to right                                |
+| >=                       | left is greater than or equal to right                            |
-| =~                       | left matches regular expression  [?(@.name =~ /foo.*?/i)]             |
+| =~                       | left matches regular expression  [?(@.name =~ /foo.*?/i)]         |
-| in                       | left exists in right [?(@.size in ['S', 'M'])]                        |
+| in                       | left exists in right [?(@.size in ['S', 'M'])]                    |
-| nin                      | left does not exists in right                                         |
+| nin                      | left does not exists in right                                     |
-| subsetof                 | left is a subset of right [?(@.sizes subsetof ['S', 'M', 'L'])]       |
+| subsetof                 | left is a subset of right [?(@.sizes subsetof ['S', 'M', 'L'])]     |
-| anyof                    | left has an intersection with right [?(@.sizes anyof ['M', 'L'])]     |
+| size                     | size of left (array or string) should match right                 |
-| noneof                   | left has no intersection with right [?(@.sizes noneof ['M', 'L'])]    |
+| empty                    | left (array or string) should be empty                            |
-| size                     | size of left (array or string) should match right                     |
-| empty                    | left (array or string) should be empty                                |
 
 
 Path Examples

json-path/src/main/java/com/jayway/jsonpath/Criteria.java

@@ -296,56 +296,6 @@ public class Criteria implements Predicate {
         return this;
     }
 
-    /**
-     * The <code>anyof</code> 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 <code>anyof</code> 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 <code>noneof</code> 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 <code>noneof</code> 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 <code>all</code> operator is similar to $in, but instead of matching any value
      * in the specified array all values in the array must be matched.

json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java

@@ -31,8 +31,6 @@ 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){
@@ -298,77 +296,4 @@ 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;
-        }
-    }
 }

json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java

@@ -30,9 +30,7 @@ public enum RelationalOperator {
     TYPE("TYPE"),
     MATCHES("MATCHES"),
     EMPTY("EMPTY"),
-    SUBSETOF("SUBSETOF"),
+    SUBSETOF("SUBSETOF");
-    ANYOF("ANYOF"),
-    NONEOF("NONEOF");
 
     private final String operatorString;
 

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,24 +152,6 @@ 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() {
 

json-path/src/test/java/com/jayway/jsonpath/FilterTest.java

@@ -1,5 +1,6 @@
 package com.jayway.jsonpath;
 
+import java.util.ArrayList;
 import org.assertj.core.util.Lists;
 import org.junit.Test;
 
@@ -378,36 +379,6 @@ 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<String> 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<String> 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