Add matches to ParseQuery

* add matches to query

* Bad $options test

* not-a-real-modifier

Author: dplewis

src/Parse/ParseQuery.php

@@ -694,6 +694,27 @@ public function notContainedIn($key, $values)
         return $this;
     }
 
+    /**
+     * Adds a regular expression constraint for finding string values that match
+     * the provided regular expression.
+     * This may be slow for large datasets.
+     *
+     * @param string $key       The key that the string to match is stored in.
+     * @param string $regex     The regular expression pattern to match.
+     * @param string $modifiers  Modifies the search, supports i, m
+     *
+     * @return ParseQuery Returns the query, so you can chain this call.
+     */
+    public function matches($key, $regex, $modifiers = '')
+    {
+        $this->addCondition($key, '$regex', $regex);
+        if (strlen($modifiers)) {
+            $this->addCondition($key, '$options', $modifiers);
+        }
+
+        return $this;
+    }
+
     /**
      * Add a constraint that requires that a key's value matches a ParseQuery
      * constraint.

tests/Parse/ParseQueryTest.php

@@ -330,6 +330,103 @@ public function testStartsWithRegexQuestionmark()
         );
     }
 
+    public function testMatchesSingle()
+    {
+        $this->provideTestObjects(10);
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'bar0');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            1,
+            'Matches function did not return correct number of objects.'
+        );
+        $this->assertEquals(
+            $results[0]->get('foo'),
+            'bar0',
+            'Matches function did not return the correct object.'
+        );
+    }
+
+    public function testMatchesMultiple()
+    {
+        $this->provideTestObjects(10);
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'bar');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            10,
+            'Matches function did not return correct number of objects.'
+        );
+    }
+
+    public function testMatchesRegexDelimiters()
+    {
+        $testObject = ParseObject::create('TestObject');
+        $testObject->set('foo', "foob\E");
+        $testObject->save();
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'foob\E');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            1,
+            'Matches function did not return correct number of objects.'
+        );
+        $query->matches('foo', 'foobE');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            0,
+            'Matches function did not return correct number of objects.'
+        );
+    }
+
+    public function testMatchesCaseInsensitiveModifier()
+    {
+        $testObject = ParseObject::create('TestObject');
+        $testObject->set('foo', 'FOOBAR');
+        $testObject->save();
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'foo', 'i');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            1,
+            'Matches function did not return correct number of objects.'
+        );
+        $this->assertEquals(
+            $results[0]->get('foo'),
+            'FOOBAR',
+            'Matches function did not return correct number of objects.'
+        );
+    }
+
+    public function testMatchesMultilineModifier()
+    {
+        $testObject = ParseObject::create('TestObject');
+        $testObject->set('foo', 'foo\nbar');
+        $testObject->save();
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'bar', 'm');
+        $results = $query->find();
+        $this->assertEquals(
+            count($results),
+            1,
+            'Matches function did not return correct number of objects.'
+        );
+    }
+
+    public function testMatchesBadOptions()
+    {
+        $this->provideTestObjects(10);
+        $query = new ParseQuery('TestObject');
+        $query->matches('foo', 'bar', 'not-a-real-modifier');
+        $this->setExpectedException('Parse\ParseException', 'Bad $options value for query: not-a-real-modifier', 102);
+        $query->find();
+    }
+
     public function testContainsSingle()
     {
         $testObject = ParseObject::create('TestObject');
@@ -381,7 +478,7 @@ public function testContainsNonExistent()
             'Contains should not find.'
         );
     }
-    
+
     public function testGreaterThan()
     {
         $this->provideTestObjects(10);