vendor/symfony/serializer/Normalizer/AbstractNormalizer.php line 254

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\Serializer\Exception\CircularReferenceException;
  15. use Symfony\Component\Serializer\Exception\InvalidArgumentException;
  16. use Symfony\Component\Serializer\Exception\LogicException;
  17. use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
  18. use Symfony\Component\Serializer\Exception\RuntimeException;
  19. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  20. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
  21. use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
  22. use Symfony\Component\Serializer\SerializerAwareInterface;
  23. use Symfony\Component\Serializer\SerializerAwareTrait;
  25. /**
  26.  * Normalizer implementation.
  27.  *
  28.  * @author Kévin Dunglas <dunglas@gmail.com>
  29.  */
  30. abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
  31. {
  32.     use ObjectToPopulateTrait;
  33.     use SerializerAwareTrait;
  35.     /* constants to configure the context */
  37.     /**
  38.      * How many loops of circular reference to allow while normalizing.
  39.      *
  40.      * The default value of 1 means that when we encounter the same object a
  41.      * second time, we consider that a circular reference.
  42.      *
  43.      * You can raise this value for special cases, e.g. in combination with the
  44.      * max depth setting of the object normalizer.
  45.      */
  46.     public const CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit';
  48.     /**
  49.      * Instead of creating a new instance of an object, update the specified object.
  50.      *
  51.      * If you have a nested structure, child objects will be overwritten with
  52.      * new instances unless you set DEEP_OBJECT_TO_POPULATE to true.
  53.      */
  54.     public const OBJECT_TO_POPULATE = 'object_to_populate';
  56.     /**
  57.      * Only (de)normalize attributes that are in the specified groups.
  58.      */
  59.     public const GROUPS = 'groups';
  61.     /**
  62.      * Limit (de)normalize to the specified names.
  63.      *
  64.      * For nested structures, this list needs to reflect the object tree.
  65.      */
  66.     public const ATTRIBUTES = 'attributes';
  68.     /**
  69.      * If ATTRIBUTES are specified, and the source has fields that are not part of that list,
  70.      * either ignore those attributes (true) or throw an ExtraAttributesException (false).
  71.      */
  72.     public const ALLOW_EXTRA_ATTRIBUTES = 'allow_extra_attributes';
  74.     /**
  75.      * Hashmap of default values for constructor arguments.
  76.      *
  77.      * The names need to match the parameter names in the constructor arguments.
  78.      */
  79.     public const DEFAULT_CONSTRUCTOR_ARGUMENTS = 'default_constructor_arguments';
  81.     /**
  82.      * Hashmap of field name => callable to normalize this field.
  83.      *
  84.      * The callable is called if the field is encountered with the arguments:
  85.      *
  86.      * - mixed  $attributeValue value of this field
  87.      * - object $object         the whole object being normalized
  88.      * - string $attributeName  name of the attribute being normalized
  89.      * - string $format         the requested format
  90.      * - array  $context        the serialization context
  91.      */
  92.     public const CALLBACKS = 'callbacks';
  94.     /**
  95.      * Handler to call when a circular reference has been detected.
  96.      *
  97.      * If you specify no handler, a CircularReferenceException is thrown.
  98.      *
  99.      * The method will be called with ($object, $format, $context) and its
  100.      * return value is returned as the result of the normalize call.
  101.      */
  102.     public const CIRCULAR_REFERENCE_HANDLER = 'circular_reference_handler';
  104.     /**
  105.      * Skip the specified attributes when normalizing an object tree.
  106.      *
  107.      * This list is applied to each element of nested structures.
  108.      *
  109.      * Note: The behaviour for nested structures is different from ATTRIBUTES
  110.      * for historical reason. Aligning the behaviour would be a BC break.
  111.      */
  112.     public const IGNORED_ATTRIBUTES = 'ignored_attributes';
  114.     /**
  115.      * @internal
  116.      */
  117.     protected const CIRCULAR_REFERENCE_LIMIT_COUNTERS = 'circular_reference_limit_counters';
  119.     protected $defaultContext = [
  120.         self::ALLOW_EXTRA_ATTRIBUTES => true,
  121.         self::CIRCULAR_REFERENCE_LIMIT => 1,
  122.         self::IGNORED_ATTRIBUTES => [],
  123.     ];
  125.     /**
  126.      * @deprecated since Symfony 4.2
  127.      */
  128.     protected $circularReferenceLimit = 1;
  130.     /**
  131.      * @deprecated since Symfony 4.2
  132.      *
  133.      * @var callable|null
  134.      */
  135.     protected $circularReferenceHandler;
  137.     /**
  138.      * @var ClassMetadataFactoryInterface|null
  139.      */
  140.     protected $classMetadataFactory;
  142.     /**
  143.      * @var NameConverterInterface|null
  144.      */
  145.     protected $nameConverter;
  147.     /**
  148.      * @deprecated since Symfony 4.2
  149.      */
  150.     protected $callbacks = [];
  152.     /**
  153.      * @deprecated since Symfony 4.2
  154.      */
  155.     protected $ignoredAttributes = [];
  157.     /**
  158.      * @deprecated since Symfony 4.2
  159.      */
  160.     protected $camelizedAttributes = [];
  162.     /**
  163.      * Sets the {@link ClassMetadataFactoryInterface} to use.
  164.      */
  165.     public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null, array $defaultContext = [])
  166.     {
  167.         $this->classMetadataFactory = $classMetadataFactory;
  168.         $this->nameConverter = $nameConverter;
  169.         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
  171.         if (isset($this->defaultContext[self::CALLBACKS])) {
  172.             if (!\is_array($this->defaultContext[self::CALLBACKS])) {
  173.                 throw new InvalidArgumentException(sprintf('The "%s" default context option must be an array of callables.', self::CALLBACKS));
  174.             }
  176.             foreach ($this->defaultContext[self::CALLBACKS] as $attribute => $callback) {
  177.                 if (!\is_callable($callback)) {
  178.                     throw new InvalidArgumentException(sprintf('Invalid callback found for attribute "%s" in the "%s" default context option.', $attribute, self::CALLBACKS));
  179.                 }
  180.             }
  181.         }
  183.         if (isset($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER]) && !\is_callable($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER])) {
  184.             throw new InvalidArgumentException(sprintf('Invalid callback found in the "%s" default context option.', self::CIRCULAR_REFERENCE_HANDLER));
  185.         }
  186.     }
  188.     /**
  189.      * Sets circular reference limit.
  190.      *
  191.      * @deprecated since Symfony 4.2
  192.      *
  193.      * @param int $circularReferenceLimit Limit of iterations for the same object
  194.      *
  195.      * @return self
  196.      */
  197.     public function setCircularReferenceLimit($circularReferenceLimit)
  198.     {
  199.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "circular_reference_limit" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  201.         $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] = $this->circularReferenceLimit = $circularReferenceLimit;
  203.         return $this;
  204.     }
  206.     /**
  207.      * Sets circular reference handler.
  208.      *
  209.      * @deprecated since Symfony 4.2
  210.      *
  211.      * @return self
  212.      */
  213.     public function setCircularReferenceHandler(callable $circularReferenceHandler)
  214.     {
  215.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "circular_reference_handler" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  217.         $this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER] = $this->circularReferenceHandler = $circularReferenceHandler;
  219.         return $this;
  220.     }
  222.     /**
  223.      * Sets normalization callbacks.
  224.      *
  225.      * @deprecated since Symfony 4.2
  226.      *
  227.      * @param callable[] $callbacks Help normalize the result
  228.      *
  229.      * @return self
  230.      *
  231.      * @throws InvalidArgumentException if a non-callable callback is set
  232.      */
  233.     public function setCallbacks(array $callbacks)
  234.     {
  235.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "callbacks" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  237.         foreach ($callbacks as $attribute => $callback) {
  238.             if (!\is_callable($callback)) {
  239.                 throw new InvalidArgumentException(sprintf('The given callback for attribute "%s" is not callable.', $attribute));
  240.             }
  241.         }
  242.         $this->defaultContext[self::CALLBACKS] = $this->callbacks = $callbacks;
  244.         return $this;
  245.     }
  247.     /**
  248.      * Sets ignored attributes for normalization and denormalization.
  249.      *
  250.      * @deprecated since Symfony 4.2
  251.      *
  252.      * @return self
  253.      */
  254.     public function setIgnoredAttributes(array $ignoredAttributes)
  255.     {
  256.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2, use the "ignored_attributes" key of the context instead.', __METHOD__), \E_USER_DEPRECATED);
  258.         $this->defaultContext[self::IGNORED_ATTRIBUTES] = $this->ignoredAttributes = $ignoredAttributes;
  260.         return $this;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     public function hasCacheableSupportsMethod(): bool
  267.     {
  268.         return false;
  269.     }
  271.     /**
  272.      * Detects if the configured circular reference limit is reached.
  273.      *
  274.      * @param object $object
  275.      * @param array  $context
  276.      *
  277.      * @return bool
  278.      *
  279.      * @throws CircularReferenceException
  280.      */
  281.     protected function isCircularReference($object, &$context)
  282.     {
  283.         $objectHash = spl_object_hash($object);
  285.         $circularReferenceLimit = $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->circularReferenceLimit;
  286.         if (isset($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash])) {
  287.             if ($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash] >= $circularReferenceLimit) {
  288.                 unset($context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash]);
  290.                 return true;
  291.             }
  293.             ++$context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash];
  294.         } else {
  295.             $context[self::CIRCULAR_REFERENCE_LIMIT_COUNTERS][$objectHash] = 1;
  296.         }
  298.         return false;
  299.     }
  301.     /**
  302.      * Handles a circular reference.
  303.      *
  304.      * If a circular reference handler is set, it will be called. Otherwise, a
  305.      * {@class CircularReferenceException} will be thrown.
  306.      *
  307.      * @final since Symfony 4.2
  308.      *
  309.      * @param object      $object
  310.      * @param string|null $format
  311.      * @param array       $context
  312.      *
  313.      * @return mixed
  314.      *
  315.      * @throws CircularReferenceException
  316.      */
  317.     protected function handleCircularReference($object/*, string $format = null, array $context = []*/)
  318.     {
  319.         if (\func_num_args() < 2 && __CLASS__ !== static::class && __CLASS__ !== (new \ReflectionMethod($this, __FUNCTION__))->getDeclaringClass()->getName() && !$this instanceof \PHPUnit\Framework\MockObject\MockObject && !$this instanceof \Prophecy\Prophecy\ProphecySubjectInterface && !$this instanceof \Mockery\MockInterface) {
  320.             @trigger_error(sprintf('The "%s()" method will have two new "string $format = null" and "array $context = []" arguments in version 5.0, not defining it is deprecated since Symfony 4.2.', __METHOD__), \E_USER_DEPRECATED);
  321.         }
  322.         $format = \func_num_args() > 1 ? func_get_arg(1) : null;
  323.         $context = \func_num_args() > 2 ? func_get_arg(2) : [];
  325.         $circularReferenceHandler = $context[self::CIRCULAR_REFERENCE_HANDLER] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER] ?? $this->circularReferenceHandler;
  326.         if ($circularReferenceHandler) {
  327.             return $circularReferenceHandler($object, $format, $context);
  328.         }
  330.         throw new CircularReferenceException(sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', \get_class($object), $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->circularReferenceLimit));
  331.     }
  333.     /**
  334.      * Gets attributes to normalize using groups.
  335.      *
  336.      * @param string|object $classOrObject
  337.      * @param bool          $attributesAsString If false, return an array of {@link AttributeMetadataInterface}
  338.      *
  339.      * @throws LogicException if the 'allow_extra_attributes' context variable is false and no class metadata factory is provided
  340.      *
  341.      * @return string[]|AttributeMetadataInterface[]|bool
  342.      */
  343.     protected function getAllowedAttributes($classOrObject, array $context, $attributesAsString = false)
  344.     {
  345.         $allowExtraAttributes = $context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES];
  346.         if (!$this->classMetadataFactory) {
  347.             if (!$allowExtraAttributes) {
  348.                 throw new LogicException(sprintf('A class metadata factory must be provided in the constructor when setting "%s" to false.', self::ALLOW_EXTRA_ATTRIBUTES));
  349.             }
  351.             return false;
  352.         }
  354.         $tmpGroups = $context[self::GROUPS] ?? $this->defaultContext[self::GROUPS] ?? null;
  355.         $groups = (\is_array($tmpGroups) || is_scalar($tmpGroups)) ? (array) $tmpGroups : false;
  356.         if (false === $groups && $allowExtraAttributes) {
  357.             return false;
  358.         }
  360.         $allowedAttributes = [];
  361.         foreach ($this->classMetadataFactory->getMetadataFor($classOrObject)->getAttributesMetadata() as $attributeMetadata) {
  362.             $name = $attributeMetadata->getName();
  364.             if (
  365.                 (false === $groups || array_intersect($attributeMetadata->getGroups(), $groups)) &&
  366.                 $this->isAllowedAttribute($classOrObject, $name, null, $context)
  367.             ) {
  368.                 $allowedAttributes[] = $attributesAsString ? $name : $attributeMetadata;
  369.             }
  370.         }
  372.         return $allowedAttributes;
  373.     }
  375.     /**
  376.      * Is this attribute allowed?
  377.      *
  378.      * @param object|string $classOrObject
  379.      * @param string        $attribute
  380.      * @param string|null   $format
  381.      *
  382.      * @return bool
  383.      */
  384.     protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = [])
  385.     {
  386.         $ignoredAttributes = $context[self::IGNORED_ATTRIBUTES] ?? $this->defaultContext[self::IGNORED_ATTRIBUTES] ?? $this->ignoredAttributes;
  387.         if (\in_array($attribute, $ignoredAttributes)) {
  388.             return false;
  389.         }
  391.         $attributes = $context[self::ATTRIBUTES] ?? $this->defaultContext[self::ATTRIBUTES] ?? null;
  392.         if (isset($attributes[$attribute])) {
  393.             // Nested attributes
  394.             return true;
  395.         }
  397.         if (\is_array($attributes)) {
  398.             return \in_array($attribute, $attributes, true);
  399.         }
  401.         return true;
  402.     }
  404.     /**
  405.      * Normalizes the given data to an array. It's particularly useful during
  406.      * the denormalization process.
  407.      *
  408.      * @param object|array $data
  409.      *
  410.      * @return array
  411.      */
  412.     protected function prepareForDenormalization($data)
  413.     {
  414.         return (array) $data;
  415.     }
  417.     /**
  418.      * Returns the method to use to construct an object. This method must be either
  419.      * the object constructor or static.
  420.      *
  421.      * @param string     $class
  422.      * @param array|bool $allowedAttributes
  423.      *
  424.      * @return \ReflectionMethod|null
  425.      */
  426.     protected function getConstructor(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes)
  427.     {
  428.         return $reflectionClass->getConstructor();
  429.     }
  431.     /**
  432.      * Instantiates an object using constructor parameters when needed.
  433.      *
  434.      * This method also allows to denormalize data into an existing object if
  435.      * it is present in the context with the object_to_populate. This object
  436.      * is removed from the context before being returned to avoid side effects
  437.      * when recursively normalizing an object graph.
  438.      *
  439.      * @param string     $class
  440.      * @param array|bool $allowedAttributes
  441.      *
  442.      * @return object
  443.      *
  444.      * @throws RuntimeException
  445.      * @throws MissingConstructorArgumentsException
  446.      */
  447.     protected function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, string $format = null)
  448.     {
  449.         if (null !== $object = $this->extractObjectToPopulate($class, $context, self::OBJECT_TO_POPULATE)) {
  450.             unset($context[self::OBJECT_TO_POPULATE]);
  452.             return $object;
  453.         }
  454.         // clean up even if no match
  455.         unset($context[static::OBJECT_TO_POPULATE]);
  457.         $constructor = $this->getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
  458.         if ($constructor) {
  459.             if (true !== $constructor->isPublic()) {
  460.                 return $reflectionClass->newInstanceWithoutConstructor();
  461.             }
  463.             $constructorParameters = $constructor->getParameters();
  465.             $params = [];
  466.             foreach ($constructorParameters as $constructorParameter) {
  467.                 $paramName = $constructorParameter->name;
  468.                 $key = $this->nameConverter ? $this->nameConverter->normalize($paramName, $class, $format, $context) : $paramName;
  470.                 $allowed = false === $allowedAttributes || \in_array($paramName, $allowedAttributes);
  471.                 $ignored = !$this->isAllowedAttribute($class, $paramName, $format, $context);
  472.                 if ($constructorParameter->isVariadic()) {
  473.                     if ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  474.                         if (!\is_array($data[$paramName])) {
  475.                             throw new RuntimeException(sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));
  476.                         }
  478.                         $variadicParameters = [];
  479.                         foreach ($data[$paramName] as $parameterData) {
  480.                             $variadicParameters[] = $this->denormalizeParameter($reflectionClass, $constructorParameter, $paramName, $parameterData, $context, $format);
  481.                         }
  483.                         $params = array_merge($params, $variadicParameters);
  484.                         unset($data[$key]);
  485.                     }
  486.                 } elseif ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  487.                     $parameterData = $data[$key];
  488.                     if (null === $parameterData && $constructorParameter->allowsNull()) {
  489.                         $params[] = null;
  490.                         // Don't run set for a parameter passed to the constructor
  491.                         unset($data[$key]);
  492.                         continue;
  493.                     }
  495.                     // Don't run set for a parameter passed to the constructor
  496.                     $params[] = $this->denormalizeParameter($reflectionClass, $constructorParameter, $paramName, $parameterData, $context, $format);
  497.                     unset($data[$key]);
  498.                 } elseif (\array_key_exists($key, $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
  499.                     $params[] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  500.                 } elseif (\array_key_exists($key, $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
  501.                     $params[] = $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  502.                 } elseif ($constructorParameter->isDefaultValueAvailable()) {
  503.                     $params[] = $constructorParameter->getDefaultValue();
  504.                 } elseif ($constructorParameter->hasType() && $constructorParameter->getType()->allowsNull()) {
  505.                     $params[] = null;
  506.                 } else {
  507.                     throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires parameter "%s" to be present.', $class, $constructorParameter->name));
  508.                 }
  509.             }
  511.             if ($constructor->isConstructor()) {
  512.                 return $reflectionClass->newInstanceArgs($params);
  513.             } else {
  514.                 return $constructor->invokeArgs(null, $params);
  515.             }
  516.         }
  518.         return new $class();
  519.     }
  521.     /**
  522.      * @internal
  523.      */
  524.     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, $parameterName, $parameterData, array $context, $format = null)
  525.     {
  526.         try {
  527.             if (($parameterType = $parameter->getType()) instanceof \ReflectionNamedType && !$parameterType->isBuiltin()) {
  528.                 $parameterClass = $parameterType->getName();
  529.                 new \ReflectionClass($parameterClass); // throws a \ReflectionException if the class doesn't exist
  531.                 if (!$this->serializer instanceof DenormalizerInterface) {
  532.                     throw new LogicException(sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameterClass, static::class));
  533.                 }
  535.                 return $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $parameterName, $format));
  536.             }
  537.         } catch (\ReflectionException $e) {
  538.             throw new RuntimeException(sprintf('Could not determine the class of the parameter "%s".', $parameterName), 0, $e);
  539.         } catch (MissingConstructorArgumentsException $e) {
  540.             if (!$parameter->getType()->allowsNull()) {
  541.                 throw $e;
  542.             }
  544.             return null;
  545.         }
  547.         return $parameterData;
  548.     }
  550.     /**
  551.      * @param string $attribute Attribute name
  552.      *
  553.      * @internal
  554.      */
  555.     protected function createChildContext(array $parentContext, $attribute/*, ?string $format */): array
  556.     {
  557.         if (\func_num_args() < 3) {
  558.             @trigger_error(sprintf('Method "%s::%s()" will have a third "?string $format" argument in version 5.0; not defining it is deprecated since Symfony 4.3.', static::class, __FUNCTION__), \E_USER_DEPRECATED);
  559.         }
  560.         if (isset($parentContext[self::ATTRIBUTES][$attribute])) {
  561.             $parentContext[self::ATTRIBUTES] = $parentContext[self::ATTRIBUTES][$attribute];
  562.         } else {
  563.             unset($parentContext[self::ATTRIBUTES]);
  564.         }
  566.         return $parentContext;
  567.     }
  568. }