Quick bug-fix of "null" values for normalizers (which was not working properly before)

Author: PandaHugMonster

src/PHP.php

@@ -106,7 +106,7 @@ public static function frameworkDir() {
 	 */
 	public static function simpUtilsVersion(): Version|string {
 		$class = static::redef(Version::class);
-		return new $class('1.0.4', 'SimpUtils');
+		return new $class('1.0.5', 'SimpUtils');
 	}
 
 	/**

src/generic/BasicValidator.php

@@ -3,11 +3,35 @@
 namespace spaf\simputils\generic;
 
 use spaf\simputils\interfaces\ValidatorInterface;
+use function is_null;
 
 /**
  * @codeCoverageIgnore
  */
 abstract class BasicValidator extends SimpleObject implements ValidatorInterface {
 
-
+	/**
+	 * Wrapper method that is used to permit null without processing
+	 *
+	 * For example if "null|..." or "?..." specified.
+	 *
+	 * NOTE Really important to note that in case of "not-allowed", it means that
+	 *      null value goes directly to the "process" method. And then the exact
+	 *      normalizer has to deal with it.
+	 *
+	 * TODO One of the reasons why it's done like this, that the registry with methods
+	 *      attached to properties do not have stored additional arguments from
+	 *      "properties" attributes pre-processing. When more advanced reference
+	 *      storage will be built, this could be done differently.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return mixed|null
+	 */
+	static function whenNullAllowed(mixed $value): mixed {
+		if (is_null($value)) {
+			return null;
+		}
+		return static::process($value);
+	}
 }

src/traits/PropertiesTrait.php

@@ -277,16 +277,19 @@ private function _simpUtilsGetValidator($item, $attr, $call_type): ?Closure {
 			$attr_instance = $attr->newInstance();
 			$valid = $attr_instance?->valid ?? false;
 
+			$t = null;
+			if ($item instanceof ReflectionProperty) {
+				$t = $item?->getType();
+			} else if ($item instanceof ReflectionMethod) {
+				$param = $item->getParameters()[0] ?? null;
+				/** @var \ReflectionParameter $param */
+				$t = $param?->getType();
+			}
+			$_method = $t && $t->allowsNull()?'whenNullAllowed':'process';
+
 			if ($valid === true &&
 				$validators_enabled === CommonMemoryCacheIndex::PROPERTY_VALIDATOR_ENABLED
 			) {
-				if ($item instanceof ReflectionProperty) {
-					$t = $item?->getType();
-				} else if ($item instanceof ReflectionMethod) {
-					$param = $item->getParameters()[0] ?? null;
-					/** @var \ReflectionParameter $param */
-					$t = $param?->getType();
-				}
 				if ($t instanceof ReflectionUnionType) {
 					// NOTE Union-Types are not supported due to unpredictable nature
 					return null; // @codeCoverageIgnore
@@ -304,18 +307,18 @@ private function _simpUtilsGetValidator($item, $attr, $call_type): ?Closure {
 						}
 					}
 					if (!empty($validators[$class]) && PHP::isClass($validators[$class])) {
-						$closure = Closure::fromCallable([$validators[$class], 'process']);
+						$closure = Closure::fromCallable([$validators[$class], $_method]);
 						return $closure;
 					}
 				}
 			} else if (is_string($valid) &&
 				$validators_enabled >= CommonMemoryCacheIndex::PROPERTY_VALIDATOR_LIMITED
 			) {
 				if (!empty($validators[$valid])) {
-					$closure = Closure::fromCallable([$validators[$valid], 'process']);
+					$closure = Closure::fromCallable([$validators[$valid], $_method]);
 					return $closure;
 				} else if (PHP::isClass($valid)) {
-					$closure = Closure::fromCallable([$valid, 'process']);
+					$closure = Closure::fromCallable([$valid, $_method]);
 					return $closure;
 				}
 			}