refactor to resolve units from suffix

Author: yitzwillroth

src/Illuminate/Validation/Rules/File.php

@@ -20,12 +20,12 @@ class File implements Rule, DataAwareRule, ValidatorAwareRule
     /**
      * Binary units flag used for size validation.
      */
-    public const BINARY = 'binary';
+    protected const BINARY = 'binary';
 
     /**
      * International units flag used for size validation.
      */
-    public const INTERNATIONAL = 'international';
+    protected const INTERNATIONAL = 'international';
 
     /**
      * The MIME types that the given file should match. This array may also contain file extensions.
@@ -42,14 +42,14 @@ class File implements Rule, DataAwareRule, ValidatorAwareRule
     protected $allowedExtensions = [];
 
     /**
-     * The minimum size in kilobytes that the file can be.
+     * The minimum file size that the file can be.
      *
      * @var null|int
      */
     protected $minimumFileSize = null;
 
     /**
-     * The maximum size in kilobytes that the file can be.
+     * The maximum file size that the file can be.
      *
      * @var null|int
      */
@@ -166,7 +166,9 @@ public function extensions($extensions)
     }
 
     /**
-     * Set the units for size validation to binary.
+     * Set the units for size validation to binary (1024-based).
+     * 
+     * Only affects naked numeric values. Explicit suffixes (MB, MiB) take precedence.
      */
     public function binary(): static
     {
@@ -175,70 +177,84 @@ public function binary(): static
     }
 
     /**
-     * Set the units for size validation to international.
+     * Set the units for size validation to international (1000-based).
+     * 
+     * Only affects naked numeric values. Explicit suffixes (MB, MiB) take precedence.
      */
     public function international(): static
     {
         $this->units = self::INTERNATIONAL;
         return $this;
     }
 
-
-
     /**
-     * Indicate that the uploaded file should be exactly a certain size in kilobytes.
+     * Indicate that the uploaded file should be exactly a certain size.
+     * 
+     * Supports both numeric values and human-readable sizes with suffixes:
+     * - Binary: 1KiB, 1MiB, 1GiB, 1TiB (1024-based)
+     * - International: 1KB, 1MB, 1GB, 1TB (1000-based)
+     * - Numeric: Uses instance unit setting (binary/international)
      */
-    public function size(string|int $size, ?string $units = null): static
+    public function size(string|int $size): static
     {
-        $this->minimumFileSize = $this->toKilobytes($size, $this->units($units));
+        $this->minimumFileSize = $this->toKilobytes($size);
         $this->maximumFileSize = $this->minimumFileSize;
 
         return $this;
     }
 
     /**
-     * Indicate that the uploaded file should be between a minimum and maximum size in kilobytes.
+     * Indicate that the uploaded file should be between a minimum and maximum size.
+     * 
+     * Supports both numeric values and human-readable sizes with suffixes:
+     * - Binary: 1KiB, 1MiB, 1GiB, 1TiB (1024-based)
+     * - International: 1KB, 1MB, 1GB, 1TB (1000-based)
+     * - Numeric: Uses instance unit setting (binary/international)
      */
-    public function between(string|int $minSize, string|int $maxSize, ?string $units = null): static
+    public function between(string|int $minSize, string|int $maxSize): static
     {
-        $this->minimumFileSize = $this->toKilobytes($minSize, $this->units($units));
-        $this->maximumFileSize = $this->toKilobytes($maxSize, $this->units($units));
+        $this->minimumFileSize = $this->toKilobytes($minSize);
+        $this->maximumFileSize = $this->toKilobytes($maxSize);
 
         return $this;
     }
 
     /**
-     * Indicate that the uploaded file should be no less than the given number of kilobytes.
+     * Indicate that the uploaded file should be no less than the given size.
+     * 
+     * Supports both numeric values and human-readable sizes with suffixes:
+     * - Binary: 1KiB, 1MiB, 1GiB, 1TiB (1024-based)
+     * - International: 1KB, 1MB, 1GB, 1TB (1000-based)
+     * - Numeric: Uses instance unit setting (binary/international)
      */
-    public function min(string|int $size, ?string $units = null): static
+    public function min(string|int $size): static
     {
-        $this->minimumFileSize = $this->toKilobytes($size, $this->units($units));
+        $this->minimumFileSize = $this->toKilobytes($size);
 
         return $this;
     }
 
     /**
-     * Indicate that the uploaded file should be no more than the given number of kilobytes.
+     * Indicate that the uploaded file should be no more than the given size.
+     * 
+     * Supports both numeric values and human-readable sizes with suffixes:
+     * - Binary: 1KiB, 1MiB, 1GiB, 1TiB (1024-based)
+     * - International: 1KB, 1MB, 1GB, 1TB (1000-based)
+     * - Numeric: Uses instance unit setting (binary/international)
      */
-    public function max(string|int $size, ?string $units = null): static
+    public function max(string|int $size): static
     {
-        $this->maximumFileSize = $this->toKilobytes($size, $this->units($units));
+        $this->maximumFileSize = $this->toKilobytes($size);
 
         return $this;
     }
 
-    /**
-     * Resolve the units to use for size calculations.
-     */
-    protected function units(?string $units = null): string
-    {
-        return $units ?? $this->units;
-    }
-
     /**
      * Convert a potentially human-friendly file size to kilobytes.
+     * 
+     * Supports suffix detection with precedence over instance settings.
      */
-    protected function toKilobytes(string|int $size, string $units): float|int
+    protected function toKilobytes(string|int $size): float|int
     {
         if (! is_string($size)) {
             return $size;
@@ -247,8 +263,8 @@ protected function toKilobytes(string|int $size, string $units): float|int
         if (($value = $this->parseSize($size)) === false || $value < 0) {
             throw new InvalidArgumentException('Invalid numeric value in file size.');
         }   
-
-        return $units === self::BINARY
+        
+        return $this->detectUnits($size) === self::BINARY
             ? $this->toBinaryKilobytes($size, $value)
             : $this->toInternationalKilobytes($size, $value);
     }
@@ -266,6 +282,22 @@ protected function parseSize($size): false|float
         );
     }
 
+    /**
+     * Detect the suffix and determine appropriate units from a file size string.
+     * 
+     * Returns binary for MiB/GiB/TiB suffixes, international for MB/GB/TB suffixes,
+     * or falls back to instance setting for naked values.
+     */
+    protected function detectUnits(string $size): string
+    {
+        return match (true) {
+            is_numeric($size) => $this->units,
+            in_array(strtolower(substr(trim($size), -3)), ['kib', 'mib', 'gib', 'tib']) => self::BINARY,
+            in_array(strtolower(substr(trim($size), -2)), ['kb', 'mb', 'gb', 'tb']) => self::INTERNATIONAL,
+            default => $this->units,
+        };
+    }
+
     /**
      * Convert a human-friendly file size to kilobytes using the International System.
      */
@@ -275,19 +307,26 @@ protected function toInternationalKilobytes(string $size, float $value): float|i
             $this->protectValueFromOverflow(
                 $this->prepareValueForPrecision($value),
                 ! is_numeric($size)
-                    ? match (substr(strtolower(trim($size)), -2)) {
-                        'kb' => 1,
-                        'mb' => 1_000,
-                        'gb' => 1_000_000,
-                        'tb' => 1_000_000_000,
-                        default => throw new InvalidArgumentException(
-                            'Invalid file size suffix. Valid suffixes are: KB, MB, GB, TB (case insensitive).'
-                        ),
-                    } : 1
+                    ? $this->getInternationalMultiplier(strtolower(trim($size)))
+                    : 1
                 )
             );
     }
 
+    /**
+     * Get the international multiplier for a given size string.
+     */
+    protected function getInternationalMultiplier(string $size): int
+    {
+        return match (substr($size, -2)) {
+            'kb' => 1,
+            'mb' => 1_000,
+            'gb' => 1_000_000,
+            'tb' => 1_000_000_000,
+            default => throw new InvalidArgumentException('Invalid file size suffix.'),
+        };
+    }
+
     /**
      * Convert a human-friendly file size to kilobytes using the Binary System.
      */
@@ -297,19 +336,26 @@ protected function toBinaryKilobytes(string $size, float $value): float|int
             $this->protectValueFromOverflow(
                 $this->prepareValueForPrecision($value),
                 ! is_numeric($size)
-                    ? match (substr(strtolower(trim($size)), -2)) {
-                        'kb' => 1,
-                        'mb' => 1_024,
-                        'gb' => 1_048_576,
-                        'tb' => 1_073_741_824,
-                        default => throw new InvalidArgumentException(
-                            'Invalid file size suffix. Valid suffixes are: KB, MB, GB, TB (case insensitive).'
-                        ),
-                    } : 1
+                    ? $this->getBinaryMultiplier(strtolower(trim($size)))
+                    : 1
                 )
             );
     }
 
+    /**
+     * Get the binary multiplier for a given size string.
+     */
+    protected function getBinaryMultiplier(string $size): int
+    {
+        return match (substr($size, -3)) {
+            'kib' => 1,
+            'mib' => 1_024,
+            'gib' => 1_048_576,
+            'tib' => 1_073_741_824,
+            default => throw new InvalidArgumentException('Invalid file size suffix.'),
+        };
+    }
+
     /**
      * Converts whole numbers to integers for exact arithmetic while keeping
      * fractional numbers as floats; also provides overflow protection by