fix: Constraints for $all $regex are KeyConstraints and not strings

Author: Eduard Bosch Bertran

Parse/src/main/java/com/parse/OfflineQueryLogic.java

@@ -236,7 +236,7 @@ private static boolean matchesEqualConstraint(Object constraint, Object value) {
       decider = new Decider() {
         @Override
         public boolean decide(Object constraint, Object value) {
-          return ((String) value).matches(constraint.toString());
+          return ((String) value).matches(((KeyConstraints)constraint).get("$regex").toString());
         }
       };
     } else {
@@ -390,9 +390,13 @@ private static boolean isAnyValueRegexStartsWith(Collection<?> constraints) {
    * All values in a $all constraint must be a starting with another string regex.
    */
   private static Collection<?> cleanRegexStartsWith(Collection<?> constraints) {
-    ArrayList<String> cleanedValues = new ArrayList<>();
+    ArrayList<KeyConstraints> cleanedValues = new ArrayList<>();
     for (Object constraint : constraints) {
-      String cleanedRegex = cleanRegexStartsWith((String) constraint);
+      if (!(constraint instanceof KeyConstraints)) {
+        return null;
+      }
+
+      KeyConstraints cleanedRegex = cleanRegexStartsWith((KeyConstraints) constraint);
       if (cleanedRegex == null) {
         return null;
       }
@@ -409,28 +413,35 @@ private static Collection<?> cleanRegexStartsWith(Collection<?> constraints) {
    * If given string is not a regex to match a string at the beginning of another string, then null
    * is returned.
    */
-  private static String cleanRegexStartsWith(String regex) {
+  private static KeyConstraints cleanRegexStartsWith(KeyConstraints regex) {
     if (!isStartsWithRegex(regex)) {
       return null;
     }
 
     // remove all instances of \Q and \E from the remaining text & escape single quotes
-    String literalizedString = regex.replaceAll("([^\\\\])(\\\\E)", "$1")
+    String literalizedString = ((String)regex.get("$regex"))
+        .replaceAll("([^\\\\])(\\\\E)", "$1")
         .replaceAll("([^\\\\])(\\\\Q)", "$1")
         .replaceAll("^\\\\E", "")
         .replaceAll("^\\\\Q", "")
         .replaceAll("([^'])'", "$1''")
         .replaceAll("^'([^'])", "''$1");
 
-    return '^' + literalizedString + ".*";
+    regex.put("$regex", literalizedString + ".*");
+    return regex;
   }
 
   /**
    * Check if given constraint is a regex to match strings that starts with another string.
    */
   private static boolean isStartsWithRegex(Object constraint) {
-    return constraint != null && constraint instanceof String &&
-        ((String)constraint).startsWith("^");
+    if (constraint == null || !(constraint instanceof KeyConstraints)) {
+      return false;
+    }
+
+    KeyConstraints keyConstraints = (KeyConstraints) constraint;
+    return keyConstraints.size() == 1 && keyConstraints.containsKey("$regex") &&
+        ((String)keyConstraints.get("$regex")).startsWith("^");
   }
 
   /**

Parse/src/test/java/com/parse/OfflineQueryLogicTest.java

@@ -395,25 +395,25 @@ public void testMatchesAllStartingWith() throws Exception {
     query = new ParseQuery.State.Builder<>("TestObject")
         .addCondition("foo", "$all",
             Arrays.asList(
-                buildStartsWithRegex("foo"),
-                buildStartsWithRegex("bar")))
+                buildStartsWithRegexKeyConstraint("foo"),
+                buildStartsWithRegexKeyConstraint("bar")))
         .build();
     assertTrue(matches(logic, query, object));
 
     query = new ParseQuery.State.Builder<>("TestObject")
         .addCondition("foo", "$all",
             Arrays.asList(
-                buildStartsWithRegex("fo"),
-                buildStartsWithRegex("b")))
+                buildStartsWithRegexKeyConstraint("fo"),
+                buildStartsWithRegexKeyConstraint("b")))
         .build();
     assertTrue(matches(logic, query, object));
 
     query = new ParseQuery.State.Builder<>("TestObject")
         .addCondition("foo", "$all",
             Arrays.asList(
-                buildStartsWithRegex("foo"),
-                buildStartsWithRegex("bar"),
-                buildStartsWithRegex("qux")))
+                buildStartsWithRegexKeyConstraint("foo"),
+                buildStartsWithRegexKeyConstraint("bar"),
+                buildStartsWithRegexKeyConstraint("qux")))
         .build();
     assertFalse(matches(logic, query, object));
 
@@ -439,19 +439,43 @@ public void testMatchesAllStartingWithParameters() throws Exception {
     query = new ParseQuery.State.Builder<>("TestObject")
         .addCondition("foo", "$all",
             Arrays.asList(
-                buildStartsWithRegex("foo"),
-                buildStartsWithRegex("bar")))
+                buildStartsWithRegexKeyConstraint("foo"),
+                buildStartsWithRegexKeyConstraint("bar")))
         .build();
     assertTrue(matches(logic, query, object));
 
     query = new ParseQuery.State.Builder<>("TestObject")
         .addCondition("foo", "$all",
             Arrays.asList(
-                buildStartsWithRegex("fo"),
+                buildStartsWithRegexKeyConstraint("fo"),
+                buildStartsWithRegex("ba"),
                 "b"))
         .build();
     thrown.expect(IllegalArgumentException.class);
     assertFalse(matches(logic, query, object));
+
+    query = new ParseQuery.State.Builder<>("TestObject")
+        .addCondition("foo", "$all",
+            Arrays.asList(
+                buildStartsWithRegexKeyConstraint("fo"),
+                "b"))
+        .build();
+    thrown.expect(IllegalArgumentException.class);
+    assertFalse(matches(logic, query, object));
+  }
+
+  /**
+   * Helper method to convert a string to a key constraint to match strings that starts with given
+   * string.
+   *
+   * @param prefix String to use as prefix in regex.
+   * @return The key constraint for word matching at the beginning of a string.
+   */
+  @NonNull
+  private ParseQuery.KeyConstraints buildStartsWithRegexKeyConstraint(String prefix) {
+    ParseQuery.KeyConstraints constraint = new ParseQuery.KeyConstraints();
+    constraint.put("$regex", buildStartsWithRegex(prefix));
+    return constraint;
   }
 
   /**