filter out non-required array parts. Fixes #262

src/Valitron/Validator.php

@@ -1,4 +1,5 @@
 <?php
+
 namespace Valitron;
 
 /**
@@ -387,7 +388,6 @@ class Validator
      * @param  string $field
      * @param  mixed $value
      * @param  array $params
-
      * @return bool
      */
     protected function validateBetween($field, $value, $params)
@@ -827,7 +827,8 @@ class Validator
     }
 
     //Validate optional field
-    protected function validateOptional($field, $value, $params) {
+    protected function validateOptional($field, $value, $params)
+    {
         //Always return true
         return true;
     }
@@ -940,24 +941,21 @@ class Validator
                 }
             }
             return array($values, true);
-        }
+        } // Dead end, abort
-        // Dead end, abort
         elseif ($identifier === NULL || !isset($data[$identifier])) {
             if ($allow_empty) {
                 //when empty values are allowed, we only care if the key exists
                 return array(null, array_key_exists($identifier, $data));
             }
             return array(null, false);
-        }
+        } // Match array element
-        // Match array element
         elseif (count($identifiers) === 0) {
             if ($allow_empty) {
                 //when empty values are allowed, we only care if the key exists
                 return array(null, array_key_exists($identifier, $data));
             }
-            return array($data[$identifier], false);
+            return array($data[$identifier], $allow_empty);
-        }
+        } // We need to go deeper
-        // We need to go deeper
         else {
             return $this->getPart($data[$identifier], $identifiers, $allow_empty);
         }
@@ -973,7 +971,7 @@ class Validator
         $set_to_break = false;
         foreach ($this->_validations as $v) {
             foreach ($v['fields'] as $field) {
-                 list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field));
+                list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field), false);
 
                 // Don't validate if the field is not required and the value is empty
                 if ($this->hasRule('optional', $field) && isset($values)) {
@@ -996,6 +994,8 @@ class Validator
 
                 if (!$multiple) {
                     $values = array($values);
+                } else if (! $this->hasRule('required', $field)){
+                    $values = array_filter($values);
                 }
 
                 $result = true;
@@ -1021,7 +1021,8 @@ class Validator
      * Should the validation stop a rule is failed
      * @param bool $stop
      */
-    public function stopOnFirstFail($stop = true) {
+    public function stopOnFirstFail($stop = true)
+    {
         $this->stop_on_first_fail = (bool)$stop;
     }
 
@@ -1101,8 +1102,7 @@ class Validator
      */
     public static function addRule($name, $callback, $message = null)
     {
-        if ($message === null)
+        if ($message === null) {
-        {
             $message = static::ERROR_DEFAULT;
         }
 
@@ -1114,16 +1114,14 @@ class Validator
 
     public function getUniqueRuleName($fields)
     {
-        if (is_array($fields))
+        if (is_array($fields)) {
-        {
             $fields = implode("_", $fields);
         }
 
         $orgName = "{$fields}_rule";
         $name = $orgName;
         $rules = $this->getRules();
-        while (isset($rules[$name]))
+        while (isset($rules[$name])) {
-        {
             $name = $orgName . "_" . rand(0, 10000);
         }
 
@@ -1158,8 +1156,7 @@ class Validator
         $params = array_slice(func_get_args(), 2);
 
         if (is_callable($rule)
-            && !(is_string($rule) && $this->hasValidator($rule)))
+            && !(is_string($rule) && $this->hasValidator($rule))) {
-        {
             $name = $this->getUniqueRuleName($fields);
             $msg = isset($params[0]) ? $params[0] : null;
             $this->addInstanceRule($name, $rule, $msg);
@@ -1296,7 +1293,8 @@ class Validator
      * @param string field_name
      * @param array $rules
      */
-    public function mapFieldRules($field_name, $rules){
+    public function mapFieldRules($field_name, $rules)
+    {
         $me = $this;
 
         array_map(function ($rule) use ($field_name, $me) {
@@ -1326,7 +1324,8 @@ class Validator
      *
      * @param array $rules
      */
-    public function mapFieldsRules($rules){
+    public function mapFieldsRules($rules)
+    {
         $me = $this;
         array_map(function ($field_name) use ($rules, $me) {
             $me->mapFieldRules($field_name, $rules[$field_name]);

tests/Valitron/ValidateTest.php

@@ -1,4 +1,5 @@
 <?php
+
 use Valitron\Validator;
 
 class ValidateTest extends BaseTestCase
@@ -21,6 +22,7 @@ class ValidateTest extends BaseTestCase
         $v->rule('required', 'name');
         $this->assertFalse($v->errors('name'));
     }
+
     public function testArrayOfFieldsToValidate()
     {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
@@ -158,7 +160,8 @@ class ValidateTest extends BaseTestCase
         $this->assertFalse($v->validate());
     }
 
-    public function testAcceptedNotSet(){
+    public function testAcceptedNotSet()
+    {
         $v = new Validator();
         $v->rule('accepted', 'agree');
         $this->assertFalse($v->validate());
@@ -189,7 +192,8 @@ class ValidateTest extends BaseTestCase
         $this->assertTrue($v->validate());
     }
 
-    public function testIntegerStrict(){
+    public function testIntegerStrict()
+    {
 
         $v = new Validator(array('num' => ' 41243'));
         $v->rule('integer', 'num');
@@ -645,13 +649,15 @@ class ValidateTest extends BaseTestCase
         $this->assertFalse($v->validate());
     }
 
-    public function testEmailDnsValid(){
+    public function testEmailDnsValid()
+    {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
         $v->rule('emailDNS', 'email');
         $this->assertTrue($v->validate());
     }
 
-    public function testEmailDnsInvalid(){
+    public function testEmailDnsInvalid()
+    {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.zyx'));
         $v->rule('emailDNS', 'email');
         $this->assertFalse($v->validate());
@@ -995,7 +1001,8 @@ class ValidateTest extends BaseTestCase
         $this->assertEquals($v1->errors(), $v2->errors());
     }
 
-    public function testMalformedBulkRules(){
+    public function testMalformedBulkRules()
+    {
         $v = new Validator();
         $v->rules(
             array(
@@ -1053,7 +1060,9 @@ class ValidateTest extends BaseTestCase
     public function testAddRuleClosure()
     {
         $v = new Validator(array('name' => 'Chester Tester'));
-        $v->addRule('testRule', function() { return true; });
+        $v->addRule('testRule', function () {
+            return true;
+        });
         $v->rule('testRule', 'name');
         $this->assertTrue($v->validate());
     }
@@ -1061,7 +1070,9 @@ class ValidateTest extends BaseTestCase
     public function testAddRuleClosureReturnsFalse()
     {
         $v = new Validator(array('name' => 'Chester Tester'));
-        $v->addRule('testRule', function() { return false; });
+        $v->addRule('testRule', function () {
+            return false;
+        });
         $v->rule('testRule', 'name');
         $this->assertFalse($v->validate());
     }
@@ -1069,7 +1080,9 @@ class ValidateTest extends BaseTestCase
     public function testAddRuleClosureWithFieldArray()
     {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'foo@example.com'));
-        $v->addRule('testRule', function() { return true; });
+        $v->addRule('testRule', function () {
+            return true;
+        });
         $v->rule('testRule', array('name', 'email'));
         $this->assertTrue($v->validate());
     }
@@ -1077,7 +1090,9 @@ class ValidateTest extends BaseTestCase
     public function testAddRuleClosureWithArrayAsExtraParameter()
     {
         $v = new Validator(array('name' => 'Chester Tester'));
-        $v->addRule('testRule', function() { return true; });
+        $v->addRule('testRule', function () {
+            return true;
+        });
         $v->rule('testRule', 'name', array('foo', 'bar'));
         $this->assertTrue($v->validate());
     }
@@ -1090,8 +1105,16 @@ class ValidateTest extends BaseTestCase
         $this->assertTrue($v->validate());
     }
 
-    public function sampleObjectCallback() { return true; }
+    public function sampleObjectCallback()
-    public function sampleObjectCallbackFalse() { return false; }
+    {
+        return true;
+    }
+
+    public function sampleObjectCallbackFalse()
+    {
+        return false;
+    }
+
     public function testAddRuleCallbackArray()
     {
         $v = new Validator(array('name' => 'Chester Tester'));
@@ -1351,7 +1374,8 @@ class ValidateTest extends BaseTestCase
         $this->assertTrue($v->validate());
     }
 
-    public function testRequiredAllowEmpty(){
+    public function testRequiredAllowEmpty()
+    {
         $data = array(
             'empty_text' => '',
             'null_value' => null,
@@ -1457,8 +1481,41 @@ class ValidateTest extends BaseTestCase
         $this->assertFalse($v->validate());
     }
 
+    /**
+     * @see https://github.com/vlucas/valitron/issues/262
+     */
+    public function testOptionalArrayPartsAreIgnored()
+    {
+        $v = new Validator(array(
+                'data' => array(
+                    array('foo' => '2018-01-01'),
+                    array('bar' => 1)
+                )
+            )
+        );
+        $v->rule('date', 'data.*.foo');
+        $this->assertTrue($v->validate());
     }
 
-function sampleFunctionCallback($field, $value, array $params) {
+    /**
+     * @see https://github.com/vlucas/valitron/issues/262
+     */
+    public function testRequiredArrayPartsAreNotIgnored()
+    {
+        $v = new Validator(array(
+                'data' => array(
+                    array('foo' => '2018-01-01'),
+                    array('bar' => 1)
+                )
+            )
+        );
+        $v->rule('required', 'data.*.foo');
+        $v->rule('date', 'data.*.foo');
+        $this->assertFalse($v->validate());
+    }
+}
+
+function sampleFunctionCallback($field, $value, array $params)
+{
     return true;
 }