Add nullable validation rule

Author: papac

src/Support/Str.php

@@ -488,6 +488,17 @@ public static function fixUTF8(string $garbled_utf8_string): string
         return Encoding::fixUTF8($garbled_utf8_string);
     }
 
+    /**
+     * Check if the string is empty
+     *
+     * @param  string $str
+     * @return bool
+     */
+    public static function isEmpty(string $str): bool
+    {
+        return trim($str) === '' || $str === '' || $str === null || strlen($str) === 0;
+    }
+
     /**
      * __call
      *

src/Validation/Rules/NullableRule.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Bow\Validation\Rules;
+
+use Bow\Support\Str;
+
+trait NullableRule
+{
+    /**
+     * Compile Nullable Rule
+     *
+     * [nullable] Check that the content of the field is nullable
+     *
+     * @param  string $key
+     * @param  string $masque
+     * @return void
+     */
+    protected function compileNullable(string $key, string $masque): void
+    {
+        if (!preg_match("/^nullable$/", $masque, $match)) {
+            return;
+        }
+
+        if (!isset($this->inputs[$key]) || $this->inputs[$key] === null || (is_string($this->inputs[$key]) && Str::isEmpty($this->inputs[$key]))) {
+            return;
+        }
+
+        $this->last_message = $this->lexical('nullable', $key);
+
+        $this->fails = true;
+
+        $this->errors[$key][] = [
+            "masque" => $masque,
+            "message" => $this->last_message
+        ];
+    }
+}

src/Validation/Validator.php

@@ -8,6 +8,7 @@
 use Bow\Validation\Rules\DatabaseRule;
 use Bow\Validation\Rules\DatetimeRule;
 use Bow\Validation\Rules\EmailRule;
+use Bow\Validation\Rules\NullableRule;
 use Bow\Validation\Rules\NumericRule;
 use Bow\Validation\Rules\RegexRule;
 use Bow\Validation\Rules\StringRule;
@@ -21,6 +22,7 @@ class Validator
     use NumericRule;
     use StringRule;
     use RegexRule;
+    use NullableRule;
 
     /**
      * The Fails flag
@@ -63,6 +65,7 @@ class Validator
      * @var array
      */
     protected array $rules = [
+        'Nullable',
         'Required',
         "RequiredIf",
         'Max',
@@ -147,21 +150,8 @@ public function validate(array $inputs, array $rules): Validate
          * Formatting and validation of each rule
          * eg. name => "required|max:100|alpha"
          */
-        foreach ($rules as $key => $rule) {
-            foreach (explode("|", $rule) as $masque) {
-                // In the box there is a | super flux.
-                if (is_int($masque) || Str::len($masque) == "") {
-                    continue;
-                }
-
-                // Mask on the required rule
-                foreach ($this->rules as $rule) {
-                    $this->{'compile' . $rule}($key, $masque);
-                    if ($rule == 'Required' && $this->fails) {
-                        break;
-                    }
-                }
-            }
+        foreach ($rules as $field => $rule) {
+            $this->checkRule($rule, $field);
         }
 
         return new Validate(
@@ -170,4 +160,29 @@ public function validate(array $inputs, array $rules): Validate
             $this->errors
         );
     }
+
+    /**
+     * Check atomic rule
+     *
+     * @param string $rule
+     * @param string $field
+     * @return void
+     */
+    private function checkRule(string $rule, string $field): void
+    {
+        foreach (explode("|", $rule) as $masque) {
+            // In the box there is a | super flux.
+            if (is_int($masque) || Str::len($masque) == "") {
+                continue;
+            }
+
+            // Mask on the required rule
+            foreach ($this->rules as $rule) {
+                $this->{'compile' . $rule}($field, $masque);
+                if ($rule == 'Required' && $this->fails) {
+                    break;
+                }
+            }
+        }
+    }
 }

tests/Validation/ValidationTest.php

@@ -474,4 +474,36 @@ public function test_regex_rule_fails_with_invalid_phone_format()
         );
         $this->assertTrue($validation->fails());
     }
+
+    // ==================== Nullable Rule ====================
+
+    public function test_nullable_rule_passes_with_null_value()
+    {
+        $validation = Validator::make(['name' => null], ['name' => 'nullable']);
+        $this->assertFalse($validation->fails());
+    }
+
+    public function test_nullable_rule_passes_with_missing_field()
+    {
+        $validation = Validator::make([], ['name' => 'nullable']);
+        $this->assertFalse($validation->fails());
+    }
+
+    public function test_nullable_rule_passes_with_value()
+    {
+        $validation = Validator::make(['name' => 'Bow'], ['name' => 'nullable']);
+        $this->assertFalse($validation->fails());
+    }
+
+    public function test_nullable_and_required_rule_fails_with_null()
+    {
+        $validation = Validator::make(['name' => null], ['name' => 'nullable|required']);
+        $this->assertTrue($validation->fails());
+    }
+
+    public function test_nullable_and_required_rule_passes_with_value()
+    {
+        $validation = Validator::make(['name' => 'Bow'], ['name' => 'nullable|required']);
+        $this->assertFalse($validation->fails());
+    }
 }