Use result object instead of exception for type cast control flow (#24)

yiisoft · May 25, 2023 · e392eb6 · e392eb6
1 parent 5acbc12
commit e392eb6
Show file tree

Hide file tree

Showing 10 changed files with 84 additions and 63 deletions.
diff --git a/src/Hydrator.php b/src/Hydrator.php
@@ -105,12 +105,12 @@ private function getConstructorArguments(string $class, array $sourceData, array
             }
 
             if ($resolved) {
-                try {
-                    $constructorArguments[$parameterName] = $this->typeCaster->cast(
-                        $resolvedValue,
-                        $parameter->getType()
-                    );
-                } catch (SkipTypeCastException) {
+                $result = $this->typeCaster->cast(
+                    $resolvedValue,
+                    $parameter->getType()
+                );
+                if ($result->isCasted()) {
+                    $constructorArguments[$parameterName] = $result->getValue();
                 }
             }
         }
@@ -162,9 +162,9 @@ private function getHydrateData(
             }
 
             if ($resolved) {
-                try {
-                    $hydrateData[$propertyName] = $this->typeCaster->cast($resolvedValue, $property->getType());
-                } catch (SkipTypeCastException) {
+                $result = $this->typeCaster->cast($resolvedValue, $property->getType());
+                if ($result->isCasted()) {
+                    $hydrateData[$propertyName] = $result->getValue();
                 }
             }
         }

diff --git a/src/ParameterAttributesHandler.php b/src/ParameterAttributesHandler.php
@@ -56,11 +56,9 @@ public function handle(
             if ($this->typeCaster === null) {
                 return $resolvedValue;
             }
-            try {
-                return $this->typeCaster->cast($resolvedValue, $parameter->getType());
-            } catch (SkipTypeCastException) {
-                return $resolvedValue;
-            }
+
+            $result = $this->typeCaster->cast($resolvedValue, $parameter->getType());
+            return $result->isCasted() ? $result->getValue() : $resolvedValue;
         }
 
         throw new NotResolvedException();

diff --git a/src/SkipTypeCastException.php b/src/SkipTypeCastException.php
diff --git a/src/TypeCastResult.php b/src/TypeCastResult.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Hydrator;
+
+final class TypeCastResult
+{
+    private function __construct(
+        private bool $isCasted,
+        private mixed $value = null,
+    ) {
+    }
+
+    public static function success(mixed $value): self
+    {
+        return new self(true, $value);
+    }
+
+    public static function skip(): self
+    {
+        return new self(false);
+    }
+
+    public function isCasted(): bool
+    {
+        return $this->isCasted;
+    }
+
+    public function getValue(): mixed
+    {
+        return $this->value;
+    }
+}
diff --git a/src/TypeCaster/CompositeTypeCaster.php b/src/TypeCaster/CompositeTypeCaster.php
@@ -5,8 +5,8 @@
 namespace Yiisoft\Hydrator\TypeCaster;
 
 use ReflectionType;
-use Yiisoft\Hydrator\SkipTypeCastException;
 use Yiisoft\Hydrator\TypeCasterInterface;
+use Yiisoft\Hydrator\TypeCastResult;
 
 final class CompositeTypeCaster implements TypeCasterInterface
 {
@@ -21,15 +21,15 @@ public function __construct(
         $this->typeCasters = $typeCasters;
     }
 
-    public function cast(mixed $value, ?ReflectionType $type): mixed
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult
     {
         foreach ($this->typeCasters as $typeCaster) {
-            try {
-                return $typeCaster->cast($value, $type);
-            } catch (SkipTypeCastException) {
+            $result = $typeCaster->cast($value, $type);
+            if ($result->isCasted()) {
+                return $result;
             }
         }
 
-        throw new SkipTypeCastException();
+        return TypeCastResult::skip();
     }
 }
diff --git a/src/TypeCaster/NoTypeCaster.php b/src/TypeCaster/NoTypeCaster.php
@@ -6,11 +6,12 @@
 
 use ReflectionType;
 use Yiisoft\Hydrator\TypeCasterInterface;
+use Yiisoft\Hydrator\TypeCastResult;
 
 final class NoTypeCaster implements TypeCasterInterface
 {
-    public function cast(mixed $value, ?ReflectionType $type): mixed
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult
     {
-        return $value;
+        return TypeCastResult::success($value);
     }
 }
diff --git a/src/TypeCaster/SimpleTypeCaster.php b/src/TypeCaster/SimpleTypeCaster.php
@@ -10,8 +10,8 @@
 use ReflectionUnionType;
 use Stringable;
 use Yiisoft\Hydrator\HydratorInterface;
-use Yiisoft\Hydrator\SkipTypeCastException;
 use Yiisoft\Hydrator\TypeCasterInterface;
+use Yiisoft\Hydrator\TypeCastResult;
 use Yiisoft\Strings\NumericHelper;
 
 use function is_array;
@@ -32,7 +32,7 @@ public function withHydrator(HydratorInterface $hydrator): self
         return $new;
     }
 
-    public function cast(mixed $value, ?ReflectionType $type): mixed
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult
     {
         if ($type instanceof ReflectionNamedType) {
             $types = [$type];
@@ -42,44 +42,44 @@ public function cast(mixed $value, ?ReflectionType $type): mixed
                 static fn(mixed $type) => $type instanceof ReflectionNamedType,
             );
         } elseif ($type === null) {
-            return $value;
+            return TypeCastResult::success($value);
         } else {
-            throw new SkipTypeCastException();
+            return TypeCastResult::skip();
         }
 
         foreach ($types as $t) {
             if (null === $value && $t->allowsNull()) {
-                return null;
+                return TypeCastResult::success(null);
             }
             if ($t->isBuiltin()) {
                 switch ($t->getName()) {
                     case 'string':
                         if (is_string($value)) {
-                            return $value;
+                            return TypeCastResult::success($value);
                         }
                         break;
 
                     case 'int':
                         if (is_int($value)) {
-                            return $value;
+                            return TypeCastResult::success($value);
                         }
                         break;
 
                     case 'float':
                         if (is_float($value)) {
-                            return $value;
+                            return TypeCastResult::success($value);
                         }
                         break;
 
                     case 'bool':
                         if (is_bool($value)) {
-                            return $value;
+                            return TypeCastResult::success($value);
                         }
                         break;
 
                     case 'array':
                         if (is_array($value)) {
-                            return $value;
+                            return TypeCastResult::success($value);
                         }
                         break;
                 }
@@ -91,31 +91,31 @@ public function cast(mixed $value, ?ReflectionType $type): mixed
                 switch ($t->getName()) {
                     case 'string':
                         if (is_scalar($value) || null === $value || $value instanceof Stringable) {
-                            return (string) $value;
+                            return TypeCastResult::success((string) $value);
                         }
                         break;
 
                     case 'int':
                         if (is_bool($value) || is_float($value) || null === $value) {
-                            return (int) $value;
+                            return TypeCastResult::success((int) $value);
                         }
                         if ($value instanceof Stringable || is_string($value)) {
-                            return (int) NumericHelper::normalize((string) $value);
+                            return TypeCastResult::success((int) NumericHelper::normalize((string) $value));
                         }
                         break;
 
                     case 'float':
                         if (is_int($value) || is_bool($value) || null === $value) {
-                            return (float) $value;
+                            return TypeCastResult::success((float) $value);
                         }
                         if ($value instanceof Stringable || is_string($value)) {
-                            return (float) NumericHelper::normalize((string) $value);
+                            return TypeCastResult::success((float) NumericHelper::normalize((string) $value));
                         }
                         break;
 
                     case 'bool':
                         if (is_scalar($value) || null === $value || is_array($value) || is_object($value)) {
-                            return (bool) $value;
+                            return TypeCastResult::success((bool) $value);
                         }
                         break;
                 }
@@ -125,16 +125,18 @@ public function cast(mixed $value, ?ReflectionType $type): mixed
             $class = $t->getName();
             if (is_object($value)) {
                 if (is_a($value, $class)) {
-                    return $value;
+                    return TypeCastResult::success($value);
                 }
             } elseif (is_array($value) && $this->hydrator !== null) {
                 $reflection = new ReflectionClass($class);
                 if ($reflection->isInstantiable()) {
-                    return $this->hydrator->create($class, $value);
+                    return TypeCastResult::success(
+                        $this->hydrator->create($class, $value)
+                    );
                 }
             }
         }
 
-        throw new SkipTypeCastException();
+        return TypeCastResult::skip();
     }
 }
diff --git a/src/TypeCasterInterface.php b/src/TypeCasterInterface.php
@@ -8,8 +8,5 @@
 
 interface TypeCasterInterface
 {
-    /**
-     * @throws SkipTypeCastException
-     */
-    public function cast(mixed $value, ?ReflectionType $type): mixed;
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult;
 }
diff --git a/tests/Support/SkipTypeCaster.php b/tests/Support/SkipTypeCaster.php
@@ -5,13 +5,13 @@
 namespace Yiisoft\Hydrator\Tests\Support;
 
 use ReflectionType;
-use Yiisoft\Hydrator\SkipTypeCastException;
 use Yiisoft\Hydrator\TypeCasterInterface;
+use Yiisoft\Hydrator\TypeCastResult;
 
 final class SkipTypeCaster implements TypeCasterInterface
 {
-    public function cast(mixed $value, ?ReflectionType $type): mixed
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult
     {
-        throw new SkipTypeCastException();
+        return TypeCastResult::skip();
     }
 }
diff --git a/tests/Support/String42TypeCaster.php b/tests/Support/String42TypeCaster.php
@@ -6,20 +6,20 @@
 
 use ReflectionNamedType;
 use ReflectionType;
-use Yiisoft\Hydrator\SkipTypeCastException;
 use Yiisoft\Hydrator\TypeCasterInterface;
+use Yiisoft\Hydrator\TypeCastResult;
 
 final class String42TypeCaster implements TypeCasterInterface
 {
-    public function cast(mixed $value, ?ReflectionType $type): mixed
+    public function cast(mixed $value, ?ReflectionType $type): TypeCastResult
     {
         if ($type instanceof ReflectionNamedType
             && $type->isBuiltin()
             && $type->getName() === 'string'
         ) {
-            return '42';
+            return TypeCastResult::success('42');
         }
 
-        throw new SkipTypeCastException();
+        return TypeCastResult::skip();
     }
 }