vendor/jms/serializer/src/Metadata/Driver/TypedPropertiesDriver.php line 66

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer\Metadata\Driver;
  7. use JMS\Serializer\Metadata\ClassMetadata as SerializerClassMetadata;
  8. use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
  9. use JMS\Serializer\Metadata\PropertyMetadata;
  10. use JMS\Serializer\Metadata\StaticPropertyMetadata;
  11. use JMS\Serializer\Metadata\VirtualPropertyMetadata;
  12. use JMS\Serializer\Type\Parser;
  13. use JMS\Serializer\Type\ParserInterface;
  14. use Metadata\ClassMetadata;
  15. use Metadata\Driver\DriverInterface;
  16. use ReflectionClass;
  17. use ReflectionException;
  18. use ReflectionProperty;
  20. class TypedPropertiesDriver implements DriverInterface
  21. {
  22.     /**
  23.      * @var DriverInterface
  24.      */
  25.     protected $delegate;
  27.     /**
  28.      * @var ParserInterface
  29.      */
  30.     protected $typeParser;
  32.     /**
  33.      * @var string[]
  34.      */
  35.     private $allowList;
  37.     /**
  38.      * @param string[] $allowList
  39.      */
  40.     public function __construct(DriverInterface $delegate, ?ParserInterface $typeParser = null, array $allowList = [])
  41.     {
  42.         $this->delegate = $delegate;
  43.         $this->typeParser = $typeParser ?: new Parser();
  44.         $this->allowList = array_merge($allowList, $this->getDefaultWhiteList());
  45.     }
  47.     private function getDefaultWhiteList(): array
  48.     {
  49.         return [
  50.             'int',
  51.             'float',
  52.             'bool',
  53.             'boolean',
  54.             'string',
  55.             'double',
  56.             'iterable',
  57.             'resource',
  58.         ];
  59.     }
  61.     /**
  62.      * @return SerializerClassMetadata|null
  63.      */
  64.     public function loadMetadataForClass(ReflectionClass $class): ?ClassMetadata
  65.     {
  66.         $classMetadata = $this->delegate->loadMetadataForClass($class);
  67.         \assert($classMetadata instanceof SerializerClassMetadata);
  69.         if (PHP_VERSION_ID <= 70400) {
  70.             return $classMetadata;
  71.         }
  73.         // We base our scan on the internal driver's property list so that we
  74.         // respect any internal allow/blocklist like in the AnnotationDriver
  75.         foreach ($classMetadata->propertyMetadata as $propertyMetadata) {
  76.             // If the inner driver provides a type, don't guess anymore.
  77.             if ($propertyMetadata->type || $this->isVirtualProperty($propertyMetadata)) {
  78.                 continue;
  79.             }
  81.             try {
  82.                 $propertyReflection = $this->getReflection($propertyMetadata);
  83.                 $reflectionType = $propertyReflection->getType();
  84.                 if ($this->shouldTypeHint($reflectionType)) {
  85.                     $type = $reflectionType->getName();
  87.                     $propertyMetadata->setType($this->typeParser->parse($type));
  88.                 }
  89.             } catch (ReflectionException $e) {
  90.                 continue;
  91.             }
  92.         }
  94.         return $classMetadata;
  95.     }
  97.     private function isVirtualProperty(PropertyMetadata $propertyMetadata): bool
  98.     {
  99.         return $propertyMetadata instanceof VirtualPropertyMetadata
  100.             || $propertyMetadata instanceof StaticPropertyMetadata
  101.             || $propertyMetadata instanceof ExpressionPropertyMetadata;
  102.     }
  104.     private function getReflection(PropertyMetadata $propertyMetadata): ReflectionProperty
  105.     {
  106.         return new ReflectionProperty($propertyMetadata->class, $propertyMetadata->name);
  107.     }
  109.     /**
  110.      * @phpstan-assert-if-true \ReflectionNamedType $reflectionType
  111.      */
  112.     private function shouldTypeHint(?\ReflectionType $reflectionType): bool
  113.     {
  114.         if (!$reflectionType instanceof \ReflectionNamedType) {
  115.             return false;
  116.         }
  118.         if (in_array($reflectionType->getName(), $this->allowList, true)) {
  119.             return true;
  120.         }
  122.         return class_exists($reflectionType->getName())
  123.             || interface_exists($reflectionType->getName());
  124.     }
  125. }