vendor/symfony/serializer/Normalizer/AbstractObjectNormalizer.php line 111

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Serializer\Normalizer;
  14. use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException;
  15. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  16. use Symfony\Component\PropertyInfo\Type;
  17. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  18. use Symfony\Component\Serializer\Exception\ExtraAttributesException;
  19. use Symfony\Component\Serializer\Exception\LogicException;
  20. use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
  21. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  22. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  23. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  25. /**
  26.  * Base class for a normalizer dealing with objects.
  27.  *
  28.  * @author Kévin Dunglas <dunglas@gmail.com>
  29.  */
  30. abstract class AbstractObjectNormalizer extends AbstractNormalizer
  31. {
  32.     const ENABLE_MAX_DEPTH = 'enable_max_depth';
  33.     const DEPTH_KEY_PATTERN = 'depth_%s::%s';
  34.     const DISABLE_TYPE_ENFORCEMENT = 'disable_type_enforcement';
  36.     private $propertyTypeExtractor;
  37.     private $attributesCache = [];
  38.     private $cache = [];
  40.     public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null, PropertyTypeExtractorInterface $propertyTypeExtractor = null)
  41.     {
  42.         parent::__construct($classMetadataFactory, $nameConverter);
  44.         $this->propertyTypeExtractor = $propertyTypeExtractor;
  45.     }
  47.     /**
  48.      * {@inheritdoc}
  49.      */
  50.     public function supportsNormalization($data, $format = null)
  51.     {
  52.         return \is_object($data) && !$data instanceof \Traversable;
  53.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     public function normalize($object, $format = null, array $context = [])
  59.     {
  60.         if (!isset($context['cache_key'])) {
  61.             $context['cache_key'] = $this->getCacheKey($format, $context);
  62.         }
  64.         if ($this->isCircularReference($object, $context)) {
  65.             return $this->handleCircularReference($object);
  66.         }
  68.         $data = [];
  69.         $stack = [];
  70.         $attributes = $this->getAttributes($object, $format, $context);
  71.         $class = \get_class($object);
  72.         $attributesMetadata = $this->classMetadataFactory ? $this->classMetadataFactory->getMetadataFor($class)->getAttributesMetadata() : null;
  74.         foreach ($attributes as $attribute) {
  75.             if (null !== $attributesMetadata && $this->isMaxDepthReached($attributesMetadata, $class, $attribute, $context)) {
  76.                 continue;
  77.             }
  79.             $attributeValue = $this->getAttributeValue($object, $attribute, $format, $context);
  81.             if (isset($this->callbacks[$attribute])) {
  82.                 $attributeValue = \call_user_func($this->callbacks[$attribute], $attributeValue);
  83.             }
  85.             if (null !== $attributeValue && !is_scalar($attributeValue)) {
  86.                 $stack[$attribute] = $attributeValue;
  87.             }
  89.             $data = $this->updateData($data, $attribute, $attributeValue);
  90.         }
  92.         foreach ($stack as $attribute => $attributeValue) {
  93.             if (!$this->serializer instanceof NormalizerInterface) {
  94.                 throw new LogicException(sprintf('Cannot normalize attribute "%s" because the injected serializer is not a normalizer', $attribute));
  95.             }
  97.             $data = $this->updateData($data, $attribute, $this->serializer->normalize($attributeValue, $format, $this->createChildContext($context, $attribute, $format)));
  98.         }
  100.         return $data;
  101.     }
  103.     /**
  104.      * Gets and caches attributes for the given object, format and context.
  105.      *
  106.      * @param object      $object
  107.      * @param string|null $format
  108.      *
  109.      * @return string[]
  110.      */
  111.     protected function getAttributes($object, $format = null, array $context)
  112.     {
  113.         $class = \get_class($object);
  114.         $key = $class.'-'.$context['cache_key'];
  116.         if (isset($this->attributesCache[$key])) {
  117.             return $this->attributesCache[$key];
  118.         }
  120.         $allowedAttributes = $this->getAllowedAttributes($object, $context, true);
  122.         if (false !== $allowedAttributes) {
  123.             if ($context['cache_key']) {
  124.                 $this->attributesCache[$key] = $allowedAttributes;
  125.             }
  127.             return $allowedAttributes;
  128.         }
  130.         $attributes = $this->extractAttributes($object, $format, $context);
  132.         if ($context['cache_key']) {
  133.             $this->attributesCache[$key] = $attributes;
  134.         }
  136.         return $attributes;
  137.     }
  139.     /**
  140.      * Extracts attributes to normalize from the class of the given object, format and context.
  141.      *
  142.      * @param object      $object
  143.      * @param string|null $format
  144.      *
  145.      * @return string[]
  146.      */
  147.     abstract protected function extractAttributes($object, $format = null, array $context = []);
  149.     /**
  150.      * Gets the attribute value.
  151.      *
  152.      * @param object      $object
  153.      * @param string      $attribute
  154.      * @param string|null $format
  155.      *
  156.      * @return mixed
  157.      */
  158.     abstract protected function getAttributeValue($object, $attribute, $format = null, array $context = []);
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function supportsDenormalization($data, $type, $format = null)
  164.     {
  165.         return isset($this->cache[$type]) ? $this->cache[$type] : $this->cache[$type] = class_exists($type);
  166.     }
  168.     /**
  169.      * {@inheritdoc}
  170.      */
  171.     public function denormalize($data, $type, $format = null, array $context = [])
  172.     {
  173.         if (!isset($context['cache_key'])) {
  174.             $context['cache_key'] = $this->getCacheKey($format, $context);
  175.         }
  177.         $allowedAttributes = $this->getAllowedAttributes($type, $context, true);
  178.         $normalizedData = $this->prepareForDenormalization($data);
  179.         $extraAttributes = [];
  181.         $reflectionClass = new \ReflectionClass($type);
  182.         $object = $this->instantiateObject($normalizedData, $type, $context, $reflectionClass, $allowedAttributes, $format);
  184.         foreach ($normalizedData as $attribute => $value) {
  185.             if ($this->nameConverter) {
  186.                 $attribute = $this->nameConverter->denormalize($attribute);
  187.             }
  189.             if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes)) || !$this->isAllowedAttribute($type, $attribute, $format, $context)) {
  190.                 if (isset($context[self::ALLOW_EXTRA_ATTRIBUTES]) && !$context[self::ALLOW_EXTRA_ATTRIBUTES]) {
  191.                     $extraAttributes[] = $attribute;
  192.                 }
  194.                 continue;
  195.             }
  197.             $value = $this->validateAndDenormalize($type, $attribute, $value, $format, $context);
  198.             try {
  199.                 $this->setAttributeValue($object, $attribute, $value, $format, $context);
  200.             } catch (InvalidArgumentException $e) {
  201.                 throw new NotNormalizableValueException($e->getMessage(), $e->getCode(), $e);
  202.             }
  203.         }
  205.         if (!empty($extraAttributes)) {
  206.             throw new ExtraAttributesException($extraAttributes);
  207.         }
  209.         return $object;
  210.     }
  212.     /**
  213.      * Sets attribute value.
  214.      *
  215.      * @param object      $object
  216.      * @param string      $attribute
  217.      * @param mixed       $value
  218.      * @param string|null $format
  219.      */
  220.     abstract protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []);
  222.     /**
  223.      * Validates the submitted data and denormalizes it.
  224.      *
  225.      * @param string      $currentClass
  226.      * @param string      $attribute
  227.      * @param mixed       $data
  228.      * @param string|null $format
  229.      *
  230.      * @return mixed
  231.      *
  232.      * @throws NotNormalizableValueException
  233.      * @throws LogicException
  234.      */
  235.     private function validateAndDenormalize($currentClass, $attribute, $data, $format, array $context)
  236.     {
  237.         if (null === $this->propertyTypeExtractor || null === $types = $this->propertyTypeExtractor->getTypes($currentClass, $attribute)) {
  238.             return $data;
  239.         }
  241.         $expectedTypes = [];
  242.         foreach ($types as $type) {
  243.             if (null === $data && $type->isNullable()) {
  244.                 return null;
  245.             }
  247.             $collectionValueType = $type->isCollection() ? $type->getCollectionValueType() : null;
  249.             // Fix a collection that contains the only one element
  250.             // This is special to xml format only
  251.             if ('xml' === $format && null !== $collectionValueType && (!\is_array($data) || !\is_int(key($data)))) {
  252.                 $data = [$data];
  253.             }
  255.             if (null !== $collectionValueType && Type::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
  256.                 $builtinType = Type::BUILTIN_TYPE_OBJECT;
  257.                 $class = $collectionValueType->getClassName().'[]';
  259.                 if (null !== $collectionKeyType = $type->getCollectionKeyType()) {
  260.                     $context['key_type'] = $collectionKeyType;
  261.                 }
  262.             } else {
  263.                 $builtinType = $type->getBuiltinType();
  264.                 $class = $type->getClassName();
  265.             }
  267.             $expectedTypes[Type::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
  269.             if (Type::BUILTIN_TYPE_OBJECT === $builtinType) {
  270.                 if (!$this->serializer instanceof DenormalizerInterface) {
  271.                     throw new LogicException(sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer', $attribute, $class));
  272.                 }
  274.                 $childContext = $this->createChildContext($context, $attribute, $format);
  275.                 if ($this->serializer->supportsDenormalization($data, $class, $format, $childContext)) {
  276.                     return $this->serializer->denormalize($data, $class, $format, $childContext);
  277.                 }
  278.             }
  280.             // JSON only has a Number type corresponding to both int and float PHP types.
  281.             // PHP's json_encode, JavaScript's JSON.stringify, Go's json.Marshal as well as most other JSON encoders convert
  282.             // floating-point numbers like 12.0 to 12 (the decimal part is dropped when possible).
  283.             // PHP's json_decode automatically converts Numbers without a decimal part to integers.
  284.             // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
  285.             // a float is expected.
  286.             if (Type::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && false !== strpos($format, JsonEncoder::FORMAT)) {
  287.                 return (float) $data;
  288.             }
  290.             if (\call_user_func('is_'.$builtinType, $data)) {
  291.                 return $data;
  292.             }
  293.         }
  295.         if (!empty($context[self::DISABLE_TYPE_ENFORCEMENT])) {
  296.             return $data;
  297.         }
  299.         throw new NotNormalizableValueException(sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), \gettype($data)));
  300.     }
  302.     /**
  303.      * @internal
  304.      */
  305.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, $parameterName, $parameterData, array $context, $format = null)
  306.     {
  307.         if (null === $this->propertyTypeExtractor || null === $types = $this->propertyTypeExtractor->getTypes($class->getName(), $parameterName)) {
  308.             return parent::denormalizeParameter($class, $parameter, $parameterName, $parameterData, $context, $format);
  309.         }
  311.         return $this->validateAndDenormalize($class->getName(), $parameterName, $parameterData, $format, $context);
  312.     }
  314.     /**
  315.      * Sets an attribute and apply the name converter if necessary.
  316.      *
  317.      * @param string $attribute
  318.      * @param mixed  $attributeValue
  319.      *
  320.      * @return array
  321.      */
  322.     private function updateData(array $data, $attribute, $attributeValue)
  323.     {
  324.         if ($this->nameConverter) {
  325.             $attribute = $this->nameConverter->normalize($attribute);
  326.         }
  328.         $data[$attribute] = $attributeValue;
  330.         return $data;
  331.     }
  333.     /**
  334.      * Is the max depth reached for the given attribute?
  335.      *
  336.      * @param AttributeMetadataInterface[] $attributesMetadata
  337.      * @param string                       $class
  338.      * @param string                       $attribute
  339.      *
  340.      * @return bool
  341.      */
  342.     private function isMaxDepthReached(array $attributesMetadata, $class, $attribute, array &$context)
  343.     {
  344.         if (
  345.             !isset($context[static::ENABLE_MAX_DEPTH]) ||
  346.             !$context[static::ENABLE_MAX_DEPTH] ||
  347.             !isset($attributesMetadata[$attribute]) ||
  348.             null === $maxDepth = $attributesMetadata[$attribute]->getMaxDepth()
  349.         ) {
  350.             return false;
  351.         }
  353.         $key = sprintf(static::DEPTH_KEY_PATTERN, $class, $attribute);
  354.         if (!isset($context[$key])) {
  355.             $context[$key] = 1;
  357.             return false;
  358.         }
  360.         if ($context[$key] === $maxDepth) {
  361.             return true;
  362.         }
  364.         ++$context[$key];
  366.         return false;
  367.     }
  369.     /**
  370.      * Overwritten to update the cache key for the child.
  371.      *
  372.      * We must not mix up the attribute cache between parent and children.
  373.      *
  374.      * {@inheritdoc}
  375.      */
  376.     protected function createChildContext(array $parentContext, $attribute/*, string $format = null */)
  377.     {
  378.         if (\func_num_args() >= 3) {
  379.             $format = func_get_arg(2);
  380.         } else {
  381.             // will be deprecated in version 4
  382.             $format = null;
  383.         }
  385.         $context = parent::createChildContext($parentContext, $attribute, $format);
  386.         // format is already included in the cache_key of the parent.
  387.         $context['cache_key'] = $this->getCacheKey($format, $context);
  389.         return $context;
  390.     }
  392.     /**
  393.      * Builds the cache key for the attributes cache.
  394.      *
  395.      * The key must be different for every option in the context that could change which attributes should be handled.
  396.      *
  397.      * @param string|null $format
  398.      *
  399.      * @return bool|string
  400.      */
  401.     private function getCacheKey($format, array $context)
  402.     {
  403.         unset($context['cache_key']); // avoid artificially different keys
  404.         try {
  405.             return md5($format.serialize([
  406.                 'context' => $context,
  407.                 'ignored' => $this->ignoredAttributes,
  408.                 'camelized' => $this->camelizedAttributes,
  409.             ]));
  410.         } catch (\Exception $exception) {
  411.             // The context cannot be serialized, skip the cache
  412.             return false;
  413.         }
  414.     }
  415. }