Update maxSize rule

Author: natanfelles

guide/index.rst

@@ -602,15 +602,19 @@ The rule can take one parameter: ``$maxLength``.
 maxSize
 #######
 
-The field requires a file that does not exceed the maximum size of ``{0}`` kilobytes.
+The field requires a file that does not exceed the maximum size of ``{0}``,
+using ``{1}`` as the unit of measurement.
 
 .. code-block:: php
 
-    maxSize:$kilobytes
+    maxSize:$size,$unit
 
-The rule can take one parameter: ``$kilobytes``.
+The rule can take two parameters: ``$size`` and ``$unit``.
 
-``$kilobytes`` is the maximum number of kilobytes that the field file can receive.
+``$size`` is the maximum number of ``$unit`` that the field file can receive.
+
+``$unit`` can be ``B`` (bytes), ``KB`` (kilobytes), ``MB`` (megabytes), ``GB``
+(gigabytes) or ``TB`` (terabytes).
 
 md5
 ###

src/FilesValidator.php

@@ -10,6 +10,7 @@
 namespace Framework\Validation;
 
 use Framework\Helpers\ArraySimple;
+use InvalidArgumentException;
 
 /**
  * Class FilesValidator.
@@ -66,19 +67,28 @@ public static function uploaded(string $field, array $data = []) : bool
      *
      * @param string $field
      * @param array<string,mixed> $data
-     * @param int $kilobytes
+     * @param int|string $size
+     * @param string $unit
      *
      * @return bool
      */
-    public static function maxSize(string $field, array $data, int | string $kilobytes) : bool
+    public static function maxSize(string $field, array $data, int | string $size, string $unit) : bool
     {
         $uploaded = static::uploaded($field);
         if (!$uploaded) {
             return false;
         }
         $file = static::getFile($field);
-        $kilobytes = (int) $kilobytes;
-        return $file['size'] <= ($kilobytes * 1024);
+        $size = (int) $size;
+        $size = match(\strtolower($unit)) {
+            'b', 'byte', 'bytes' => $size,
+            'kb', 'kilobyte', 'kilobytes' => $size * 1024,
+            'mb', 'megabyte', 'megabytes' => $size * 1024 * 1024,
+            'gb', 'gigabyte', 'gigabytes' => $size * 1024 * 1024 * 1024,
+            'tb', 'terabyte', 'terabytes' => $size * 1024 * 1024 * 1024 * 1024,
+            default => throw new InvalidArgumentException('Invalid unit of measurement: ' . $unit)
+        };
+        return $file['size'] <= $size;
     }
 
     /**

src/Languages/en/validation.php

@@ -41,7 +41,7 @@
     'isset' => 'The {field} field must be sent.',
     'latin' => 'The {field} field requires only latin characters.',
     'uploaded' => 'The {field} field requires a file to be uploaded.',
-    'maxSize' => 'The {field} field requires a file that does not exceed the maximum size of {0} kilobytes.',
+    'maxSize' => 'The {field} field requires a file that does not exceed the maximum size of {0} {1, select, b{B} kb{KB} mb{MB} gb{GB} tb{TB} other{{1}}}.',
     'ext' => 'The {field} field requires a file with an accepted extension: {args}.',
     'mimes' => 'The {field} field requires a file with an accepted MIME type: {args}.',
     'image' => 'The {field} field requires an image.',

src/Languages/es/validation.php

@@ -41,7 +41,7 @@
     'isset' => 'El campo {field} debe enviarse.',
     'latin' => 'El campo {field} sólo requiere caracteres latinos.',
     'uploaded' => 'El campo {field} requiere que se cargue un archivo.',
-    'maxSize' => 'El campo {field} requiere un archivo que no exceda el tamaño máximo de {0} kilobytes.',
+    'maxSize' => 'El campo {field} requiere un archivo que no exceda el tamaño máximo de {0} {1, select, b{B} kb{KB} mb{MB} gb{GB} tb{TB} other{{1}}}.',
     'ext' => 'El campo {field} requiere un archivo con una extensión aceptada: {args}.',
     'mimes' => 'El campo {field} requiere un archivo con un tipo MIME aceptado: {args}.',
     'image' => 'El campo {field} requiere una imagen.',

src/Languages/pt-br/validation.php

@@ -41,7 +41,7 @@
     'isset' => 'O campo {field} deve ser enviado.',
     'latin' => 'O campo {field} requer apenas caracteres latinos.',
     'uploaded' => 'O campo {field} requer que um arquivo seja carregado.',
-    'maxSize' => 'O campo {field} requer um arquivo que não exceda o tamanho máximo de {0} kilobytes.',
+    'maxSize' => 'O campo {field} requer um arquivo que não exceda o tamanho máximo de {0} {1, select, b{B} kb{KB} mb{MB} gb{GB} tb{TB} other{{1}}}.',
     'ext' => 'O campo {field} requer um arquivo com uma extensão aceita: {args}.',
     'mimes' => 'O campo {field} requer um arquivo com um tipo MIME aceito: {args}.',
     'image' => 'O campo {field} requer uma imagem.',

src/Traits/FilesValidator.php

@@ -30,13 +30,14 @@ public function uploaded() : static
     /**
      * Validates file size.
      *
-     * @param int $kilobytes
+     * @param int $size
+     * @param string $unit
      *
      * @return static
      */
-    public function maxSize(int $kilobytes) : static
+    public function maxSize(int $size, string $unit) : static
     {
-        $this->rules[] = 'maxSize:' . $kilobytes;
+        $this->rules[] = 'maxSize:' . $size . ',' . $unit;
         return $this;
     }
 

tests/FilesValidatorTest.php

@@ -103,11 +103,15 @@ public function testUploaded() : void
 
     public function testMaxSize() : void
     {
-        self::assertFalse(FilesValidatorMock::maxSize('foo[a]', [], 10));
-        self::assertFalse(FilesValidatorMock::maxSize('foo[a]', [], '10'));
-        self::assertTrue(FilesValidatorMock::maxSize('foo[a]', [], 40));
-        self::assertTrue(FilesValidatorMock::maxSize('foo[a]', [], '40'));
-        self::assertFalse(FilesValidator::maxSize('foo[a]', [], 40));
+        self::assertFalse(FilesValidator::maxSize('foo[a]', [], 10, 'b'));
+        self::assertFalse(FilesValidatorMock::maxSize('foo[a]', [], 10, 'b'));
+        self::assertFalse(FilesValidatorMock::maxSize('foo[a]', [], 10, 'kb'));
+        self::assertTrue(FilesValidatorMock::maxSize('foo[a]', [], 10, 'mb'));
+        self::assertTrue(FilesValidatorMock::maxSize('foo[a]', [], 10, 'gb'));
+        self::assertTrue(FilesValidatorMock::maxSize('foo[a]', [], 10, 'tb'));
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid unit of measurement: foo');
+        FilesValidatorMock::maxSize('foo[a]', [], 10, 'foo');
     }
 
     public function testMimeTypes() : void

tests/RulesTest.php

@@ -262,7 +262,7 @@ public function testRuleUploaded() : void
 
     public function testRuleMaxSize() : void
     {
-        self::assertRule('maxSize:10', $this->rules->maxSize(10));
+        self::assertRule('maxSize:10,kb', $this->rules->maxSize(10, 'kb'));
     }
 
     public function testRuleMimes() : void