New query condition to match all strings that starts with some other given strings

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

@@ -18,6 +18,7 @@
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.regex.Pattern;
 
 /**
  * A {@code ParseEncoder} can be used to transform objects such as {@link ParseObjects} into JSON
@@ -40,7 +41,8 @@
         || value instanceof ParseACL
         || value instanceof ParseFile
         || value instanceof ParseGeoPoint
-        || value instanceof ParseRelation;
+        || value instanceof ParseRelation
+        || value instanceof Pattern;
   }
 
   public Object encode(Object object) {
@@ -120,6 +122,12 @@ public Object encode(Object object) {
         return ((ParseQuery.RelationConstraint) object).encode(this);
       }
 
+      if (object instanceof Pattern) {
+        JSONObject json = new JSONObject();
+        json.put("$regex", object.toString());
+        return json;
+      }
+
       if (object == null) {
         return JSONObject.NULL;
       }

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

@@ -8,6 +8,8 @@
  */
 package com.parse;
 
+import android.support.annotation.NonNull;
+
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -1694,6 +1696,31 @@ public ParseQuery<T> whereContainsAll(String key, Collection<?> values) {
     return this;
   }
 
+  /**
+   * Add a constraint to the query that requires a particular key's value match another
+   * {@code ParseQuery}.
+   * <p/>
+   * This only works on keys whose values are {@link ParseObject}s or lists of {@link ParseObject}s.
+   * Add a constraint to the query that requires a particular key's value to contain each one of
+   * the provided list of values entirely or just starting with given strings.
+   *
+   * @param key
+   *          The key to check. This key's value must be an array.
+   * @param values
+   *          The values that will match.
+   * @return this, so you can chain this call.
+   */
+  public ParseQuery<T> whereContainsAllStartsWith(String key, Collection<String> values) {
+    checkIfRunning();
+
+    ArrayList<Pattern> regexValues = new ArrayList<>();
+    for (String value : values) {
+      regexValues.add(Pattern.compile(buildStartsWithRegex(value)));
+    }
+
+    return whereContainsAll(key, regexValues);
+  }
+
   /**
    * Add a constraint to the query that requires a particular key's value match another
    * {@code ParseQuery}.
@@ -1947,7 +1974,7 @@ public ParseQuery<T> whereContains(String key, String substring) {
    * @return this, so you can chain this call.
    */
   public ParseQuery<T> whereStartsWith(String key, String prefix) {
-    String regex = "^" + Pattern.quote(prefix);
+    String regex = buildStartsWithRegex(prefix);
     whereMatches(key, regex);
     return this;
   }
@@ -2150,4 +2177,15 @@ public ParseQuery<T> setTrace(boolean shouldTrace) {
     builder.setTracingEnabled(shouldTrace);
     return this;
   }
+
+  /**
+   * Helper method to convert a string to regex for start word matching.
+   *
+   * @param prefix String to use as prefix in regex.
+   * @return The string converted as regex for start word matching.
+   */
+  @NonNull
+  private String buildStartsWithRegex(String prefix) {
+    return "^" + Pattern.quote(prefix);
+  }
 }

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

@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.regex.Pattern;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -161,6 +162,14 @@ public void testRelationContraint() throws JSONException {
     assertEquals(">", relationConstraintJSON.getString("key"));
   }
 
+  @Test
+  public void testPattern() throws JSONException {
+    Pattern pattern = Pattern.compile("^\\Qvalue\\E");
+    JSONObject patternJSON = (JSONObject) testClassObject.encode(pattern);
+    assertNotNull(patternJSON);
+    assertEquals("^\\Qvalue\\E", patternJSON.getString("$regex"));
+  }
+
   @Test
   public void testNull() throws JSONException {
     Object object = testClassObject.encode(null);

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

@@ -8,6 +8,8 @@
  */
 package com.parse;
 
+import android.support.annotation.NonNull;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -411,6 +413,20 @@ public void testWhereContainsAll() throws Exception {
     verifyCondition(query, "key", "$all", values);
   }
 
+  @Test
+  public void testWhereContainsAllStartingWith() throws Exception {
+    ParseQuery<ParseObject> query = new ParseQuery<>("Test");
+    List<String> values = Arrays.asList("value", "valueAgain");
+    List<String> valuesConverted = Arrays.asList(
+        buildStartsWithPattern("value"),
+        buildStartsWithPattern("valueAgain")
+    );
+
+    query.whereContainsAllStartsWith("key", values);
+
+    verifyConditionAsString(query, "key", "$all", valuesConverted);
+  }
+
   @Test
   public void testWhereNotContainedIn() throws Exception {
     ParseQuery<ParseObject> query = new ParseQuery<>("Test");
@@ -447,7 +463,7 @@ public void testWhereStartsWith() throws Exception {
     String value = "prefix";
     query.whereStartsWith("key", value);
 
-    verifyCondition(query, "key", "$regex", "^" + Pattern.quote(value));
+    verifyCondition(query, "key", "$regex", buildStartsWithPattern(value));
   }
 
   @Test
@@ -760,6 +776,20 @@ private static void verifyCondition(
       assertEquals(map.get(constraintKey), values.get(constraintKey));
     }
   }
+
+  private static void verifyConditionAsString(
+      ParseQuery query, String key, String conditionKey, List values) {
+    // We generate a state to verify the content of the builder
+    ParseQuery.State state = query.getBuilder().build();
+    ParseQuery.QueryConstraints queryConstraints = state.constraints();
+    ParseQuery.KeyConstraints keyConstraints =
+        (ParseQuery.KeyConstraints) queryConstraints.get(key);
+    Collection<String> list = (Collection<String>) keyConstraints.get(conditionKey);
+    assertEquals(values.size(), list.size());
+    for (Object listValue : list) {
+      assertTrue(values.contains(listValue.toString()));
+    }
+  }
 
   //endregion
 
@@ -846,4 +876,9 @@ public Task<Void> then(Task<Void> task) throws Exception {
       })).cast();
     }
   }
+
+  @NonNull
+  private String buildStartsWithPattern(String value) {
+    return "^" + Pattern.quote(value);
+  }
 }