Change implementation 'default' rule, and support multiple file upload

Author: emsifa

src/Rules/Defaults.php

@@ -3,8 +3,9 @@
 namespace Rakit\Validation\Rules;
 
 use Rakit\Validation\Rule;
+use Rakit\Validation\Rules\Interfaces\ModifyValue;
 
-class Defaults extends Rule
+class Defaults extends Rule implements ModifyValue
 {
 
     /** @var string */
@@ -26,4 +27,24 @@ public function check($value): bool
         $default = $this->parameter('default');
         return true;
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function modifyValue($value)
+    {
+        return $this->isEmptyValue($value) ? $this->parameter('default') : $value;
+    }
+
+    /**
+     * Check $value is empty value
+     *
+     * @param mixed $value
+     * @return boolean
+     */
+    protected function isEmptyValue($value): bool
+    {
+        $requiredValidator = new Required;
+        return false === $requiredValidator->check($value, []);
+    }
 }

src/Rules/Interfaces/BeforeValidate.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Rakit\Validation\Rules\Interfaces;
+
+interface BeforeValidate
+{
+    /**
+     * Before validate hook
+     *
+     * @return void
+     */
+    public function beforeValidate();
+}

src/Rules/Interfaces/ModifyValue.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Rakit\Validation\Rules\Interfaces;
+
+interface ModifyValue
+{
+    /**
+     * Modify given value
+     * so in current and next rules returned value will be used
+     *
+     * @param mixed $value
+     * @return mixed
+     */
+    public function modifyValue($value);
+}

src/Rules/Traits/FileTrait.php

@@ -3,6 +3,7 @@
 namespace Rakit\Validation\Rules\Traits;
 
 use InvalidArgumentException;
+use Rakit\Validation\Helper;
 
 trait FileTrait
 {
@@ -39,4 +40,47 @@ public function isUploadedFile($value): bool
     {
         return $this->isValueFromUploadedFiles($value) && is_uploaded_file($value['tmp_name']);
     }
+
+    /**
+     * Resolve uploaded file value
+     *
+     * @param  mixed $value
+     * @return array|null
+     */
+    public function resolveUploadedFileValue($value)
+    {
+        if (!$this->isValueFromUploadedFiles($value)) {
+            return null;
+        }
+
+        // Here $value should be an array:
+        // [
+        //      'name'      => string|array,
+        //      'type'      => string|array,
+        //      'size'      => int|array,
+        //      'tmp_name'  => string|array,
+        //      'error'     => string|array,
+        // ]
+
+        // Flatten $value to it's array dot format,
+        // so our array must be something like:
+        // ['name' => string, 'type' => string, 'size' => int, ...]
+        // or for multiple values:
+        // ['name.0' => string, 'name.1' => string, 'type.0' => string, 'type.1' => string, ...]
+        // or for nested array:
+        // ['name.foo.bar' => string, 'name.foo.baz' => string, 'type.foo.bar' => string, 'type.foo.baz' => string, ...]
+        $arrayDots = Helper::arrayDot($value);
+
+        $results = [];
+        foreach ($arrayDots as $key => $val) {
+            // Move first key to last key
+            // name.foo.bar -> foo.bar.name
+            $splits = explode(".", $key);
+            $firstKey = array_shift($splits);
+            $key = count($splits) ? implode(".", $splits) . ".{$firstKey}" : $firstKey;
+
+            Helper::arraySet($results, $key, $val);
+        }
+        return $results;
+    }
 }

src/Rules/UploadedFile.php

@@ -2,10 +2,12 @@
 
 namespace Rakit\Validation\Rules;
 
-use Rakit\Validation\Rule;
+use Rakit\Validation\Helper;
 use Rakit\Validation\MimeTypeGuesser;
+use Rakit\Validation\Rule;
+use Rakit\Validation\Rules\Interfaces\BeforeValidate;
 
-class UploadedFile extends Rule
+class UploadedFile extends Rule implements BeforeValidate
 {
     use Traits\FileTrait, Traits\SizeTrait;
 
@@ -92,6 +94,33 @@ public function fileTypes($types): Rule
         return $this;
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function beforeValidate()
+    {
+        $attribute = $this->getAttribute();
+
+        // We only resolve uploaded file value
+        // from complex attribute such as 'files.photo', 'images.*', 'images.foo.bar', etc.
+        if (!$attribute->isUsingDotNotation()) {
+            return;
+        }
+
+        $keys = explode(".", $attribute->getKey());
+        $firstKey = array_shift($keys);
+        $firstKeyValue = $this->validation->getValue($firstKey);
+
+        $resolvedValue = $this->resolveUploadedFileValue($firstKeyValue);
+
+        // Return original value if $value can't be resolved as uploaded file value
+        if (!$resolvedValue) {
+            return;
+        }
+
+        $this->validation->setValue($firstKey, $resolvedValue);
+    }
+
     /**
      * Check the $value is valid
      *

src/Validation.php

@@ -2,9 +2,10 @@
 
 namespace Rakit\Validation;
 
-use Rakit\Validation\Rules\Required;
 use Closure;
-use Rakit\Validation\Rules\Defaults;
+use Rakit\Validation\Rules\Interfaces\BeforeValidate;
+use Rakit\Validation\Rules\Interfaces\ModifyValue;
+use Rakit\Validation\Rules\Required;
 
 class Validation
 {
@@ -92,6 +93,16 @@ public function validate(array $inputs = [])
     {
         $this->errors = new ErrorBag; // reset error bag
         $this->inputs = array_merge($this->inputs, $this->resolveInputAttributes($inputs));
+
+        // Before validation hooks
+        foreach ($this->attributes as $attributeKey => $attribute) {
+            foreach ($attribute->getRules() as $rule) {
+                if ($rule instanceof BeforeValidate) {
+                    $rule->beforeValidate();
+                }
+            }
+        }
+
         foreach ($this->attributes as $attributeKey => $attribute) {
             $this->validateAttribute($attribute);
         }
@@ -133,10 +144,9 @@ protected function validateAttribute(Attribute $attribute)
         foreach ($rules as $ruleValidator) {
             $ruleValidator->setAttribute($attribute);
 
-            if ($isEmptyValue && $ruleValidator instanceof Defaults) {
-                $value = $ruleValidator->parameter('default');
+            if ($ruleValidator instanceof ModifyValue) {
+                $value = $ruleValidator->modifyValue($value);
                 $isEmptyValue = $this->isEmptyValue($value);
-                continue;
             }
 
             $valid = $ruleValidator->check($value);
@@ -600,6 +610,18 @@ public function getValue(string $key)
         return Helper::arrayGet($this->inputs, $key);
     }
 
+    /**
+     * Set input value
+     *
+     * @param string $key
+     * @param mixed $value
+     * @return void
+     */
+    public function setValue(string $key, $value)
+    {
+        Helper::arraySet($this->inputs, $key, $value);
+    }
+
     /**
      * Given $key and check value is exsited
      *

tests/Rules/UploadedFileTest.php

@@ -133,7 +133,6 @@ public function testMinSize()
 
     public function testFileTypes()
     {
-
         $rule = $this->getMockBuilder(UploadedFile::class)
             ->setMethods(['isUploadedFile'])
             ->getMock();