8bbd7389a3
* 4.0: [HttpKernel] Fix restoring trusted proxies in tests Update UPGRADE-4.0.md CODEOWNERS: some more rules removed unneeded comments in tests removed unneeded comments in tests Change PHPDoc in ResponseHeaderBag::getCookies() to help IDEs [HttpKernel] fix registering IDE links [HttpKernel] Set first trusted proxy as REMOTE_ADDR in InlineFragmentRenderer. [Process] Consider \"executable\" suffixes first on Windows Triggering RememberMe's loginFail() when token cannot be created [Serializer] Fix serializer tries to denormalize null values on nullable properties [FrameworkBundle] Change priority of AddConsoleCommandPass to TYPE_BEFORE_REMOVING
422 lines
14 KiB
PHP
422 lines
14 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Symfony package.
|
|
*
|
|
* (c) Fabien Potencier <fabien@symfony.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Symfony\Component\Serializer\Normalizer;
|
|
|
|
use Symfony\Component\Serializer\Exception\CircularReferenceException;
|
|
use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
|
|
use Symfony\Component\Serializer\Exception\InvalidArgumentException;
|
|
use Symfony\Component\Serializer\Exception\LogicException;
|
|
use Symfony\Component\Serializer\Exception\RuntimeException;
|
|
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
|
|
use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
|
|
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
|
|
use Symfony\Component\Serializer\SerializerAwareInterface;
|
|
use Symfony\Component\Serializer\SerializerAwareTrait;
|
|
|
|
/**
|
|
* Normalizer implementation.
|
|
*
|
|
* @author Kévin Dunglas <dunglas@gmail.com>
|
|
*/
|
|
abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
|
|
{
|
|
use ObjectToPopulateTrait;
|
|
use SerializerAwareTrait;
|
|
|
|
const CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit';
|
|
const OBJECT_TO_POPULATE = 'object_to_populate';
|
|
const GROUPS = 'groups';
|
|
const ATTRIBUTES = 'attributes';
|
|
const ALLOW_EXTRA_ATTRIBUTES = 'allow_extra_attributes';
|
|
const DEFAULT_CONSTRUCTOR_ARGUMENTS = 'default_constructor_arguments';
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $circularReferenceLimit = 1;
|
|
|
|
/**
|
|
* @var callable
|
|
*/
|
|
protected $circularReferenceHandler;
|
|
|
|
/**
|
|
* @var ClassMetadataFactoryInterface|null
|
|
*/
|
|
protected $classMetadataFactory;
|
|
|
|
/**
|
|
* @var NameConverterInterface|null
|
|
*/
|
|
protected $nameConverter;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $callbacks = array();
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $ignoredAttributes = array();
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
protected $camelizedAttributes = array();
|
|
|
|
/**
|
|
* Sets the {@link ClassMetadataFactoryInterface} to use.
|
|
*/
|
|
public function __construct(ClassMetadataFactoryInterface $classMetadataFactory = null, NameConverterInterface $nameConverter = null)
|
|
{
|
|
$this->classMetadataFactory = $classMetadataFactory;
|
|
$this->nameConverter = $nameConverter;
|
|
}
|
|
|
|
/**
|
|
* Set circular reference limit.
|
|
*
|
|
* @param int $circularReferenceLimit Limit of iterations for the same object
|
|
*
|
|
* @return self
|
|
*/
|
|
public function setCircularReferenceLimit($circularReferenceLimit)
|
|
{
|
|
$this->circularReferenceLimit = $circularReferenceLimit;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set circular reference handler.
|
|
*
|
|
* @param callable $circularReferenceHandler
|
|
*
|
|
* @return self
|
|
*/
|
|
public function setCircularReferenceHandler(callable $circularReferenceHandler)
|
|
{
|
|
$this->circularReferenceHandler = $circularReferenceHandler;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set normalization callbacks.
|
|
*
|
|
* @param callable[] $callbacks Help normalize the result
|
|
*
|
|
* @return self
|
|
*
|
|
* @throws InvalidArgumentException if a non-callable callback is set
|
|
*/
|
|
public function setCallbacks(array $callbacks)
|
|
{
|
|
foreach ($callbacks as $attribute => $callback) {
|
|
if (!\is_callable($callback)) {
|
|
throw new InvalidArgumentException(sprintf(
|
|
'The given callback for attribute "%s" is not callable.',
|
|
$attribute
|
|
));
|
|
}
|
|
}
|
|
$this->callbacks = $callbacks;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set ignored attributes for normalization and denormalization.
|
|
*
|
|
* @return self
|
|
*/
|
|
public function setIgnoredAttributes(array $ignoredAttributes)
|
|
{
|
|
$this->ignoredAttributes = $ignoredAttributes;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function hasCacheableSupportsMethod(): bool
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Detects if the configured circular reference limit is reached.
|
|
*
|
|
* @param object $object
|
|
* @param array $context
|
|
*
|
|
* @return bool
|
|
*
|
|
* @throws CircularReferenceException
|
|
*/
|
|
protected function isCircularReference($object, &$context)
|
|
{
|
|
$objectHash = spl_object_hash($object);
|
|
|
|
if (isset($context[static::CIRCULAR_REFERENCE_LIMIT][$objectHash])) {
|
|
if ($context[static::CIRCULAR_REFERENCE_LIMIT][$objectHash] >= $this->circularReferenceLimit) {
|
|
unset($context[static::CIRCULAR_REFERENCE_LIMIT][$objectHash]);
|
|
|
|
return true;
|
|
}
|
|
|
|
++$context[static::CIRCULAR_REFERENCE_LIMIT][$objectHash];
|
|
} else {
|
|
$context[static::CIRCULAR_REFERENCE_LIMIT][$objectHash] = 1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Handles a circular reference.
|
|
*
|
|
* If a circular reference handler is set, it will be called. Otherwise, a
|
|
* {@class CircularReferenceException} will be thrown.
|
|
*
|
|
* @param object $object
|
|
*
|
|
* @return mixed
|
|
*
|
|
* @throws CircularReferenceException
|
|
*/
|
|
protected function handleCircularReference($object)
|
|
{
|
|
if ($this->circularReferenceHandler) {
|
|
return \call_user_func($this->circularReferenceHandler, $object);
|
|
}
|
|
|
|
throw new CircularReferenceException(sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d)', \get_class($object), $this->circularReferenceLimit));
|
|
}
|
|
|
|
/**
|
|
* Gets attributes to normalize using groups.
|
|
*
|
|
* @param string|object $classOrObject
|
|
* @param array $context
|
|
* @param bool $attributesAsString If false, return an array of {@link AttributeMetadataInterface}
|
|
*
|
|
* @return string[]|AttributeMetadataInterface[]|bool
|
|
*/
|
|
protected function getAllowedAttributes($classOrObject, array $context, $attributesAsString = false)
|
|
{
|
|
if (!$this->classMetadataFactory) {
|
|
return false;
|
|
}
|
|
|
|
$groups = false;
|
|
if (isset($context[static::GROUPS]) && \is_array($context[static::GROUPS])) {
|
|
$groups = $context[static::GROUPS];
|
|
} elseif (!isset($context[static::ALLOW_EXTRA_ATTRIBUTES]) || $context[static::ALLOW_EXTRA_ATTRIBUTES]) {
|
|
return false;
|
|
}
|
|
|
|
$allowedAttributes = array();
|
|
foreach ($this->classMetadataFactory->getMetadataFor($classOrObject)->getAttributesMetadata() as $attributeMetadata) {
|
|
$name = $attributeMetadata->getName();
|
|
|
|
if (
|
|
(false === $groups || array_intersect($attributeMetadata->getGroups(), $groups)) &&
|
|
$this->isAllowedAttribute($classOrObject, $name, null, $context)
|
|
) {
|
|
$allowedAttributes[] = $attributesAsString ? $name : $attributeMetadata;
|
|
}
|
|
}
|
|
|
|
return $allowedAttributes;
|
|
}
|
|
|
|
/**
|
|
* Is this attribute allowed?
|
|
*
|
|
* @param object|string $classOrObject
|
|
* @param string $attribute
|
|
* @param string|null $format
|
|
* @param array $context
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = array())
|
|
{
|
|
if (in_array($attribute, $this->ignoredAttributes)) {
|
|
return false;
|
|
}
|
|
|
|
if (isset($context[self::ATTRIBUTES][$attribute])) {
|
|
// Nested attributes
|
|
return true;
|
|
}
|
|
|
|
if (isset($context[self::ATTRIBUTES]) && is_array($context[self::ATTRIBUTES])) {
|
|
return in_array($attribute, $context[self::ATTRIBUTES], true);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Normalizes the given data to an array. It's particularly useful during
|
|
* the denormalization process.
|
|
*
|
|
* @param object|array $data
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function prepareForDenormalization($data)
|
|
{
|
|
return (array) $data;
|
|
}
|
|
|
|
/**
|
|
* Returns the method to use to construct an object. This method must be either
|
|
* the object constructor or static.
|
|
*
|
|
* @param array $data
|
|
* @param string $class
|
|
* @param array $context
|
|
* @param \ReflectionClass $reflectionClass
|
|
* @param array|bool $allowedAttributes
|
|
*
|
|
* @return \ReflectionMethod|null
|
|
*/
|
|
protected function getConstructor(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes)
|
|
{
|
|
return $reflectionClass->getConstructor();
|
|
}
|
|
|
|
/**
|
|
* Instantiates an object using constructor parameters when needed.
|
|
*
|
|
* This method also allows to denormalize data into an existing object if
|
|
* it is present in the context with the object_to_populate. This object
|
|
* is removed from the context before being returned to avoid side effects
|
|
* when recursively normalizing an object graph.
|
|
*
|
|
* @param array $data
|
|
* @param string $class
|
|
* @param array $context
|
|
* @param \ReflectionClass $reflectionClass
|
|
* @param array|bool $allowedAttributes
|
|
* @param string|null $format
|
|
*
|
|
* @return object
|
|
*
|
|
* @throws RuntimeException
|
|
* @throws MissingConstructorArgumentsException
|
|
*/
|
|
protected function instantiateObject(array &$data, $class, array &$context, \ReflectionClass $reflectionClass, $allowedAttributes, string $format = null)
|
|
{
|
|
if (null !== $object = $this->extractObjectToPopulate($class, $context, static::OBJECT_TO_POPULATE)) {
|
|
unset($context[static::OBJECT_TO_POPULATE]);
|
|
|
|
return $object;
|
|
}
|
|
|
|
$constructor = $this->getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
|
|
if ($constructor) {
|
|
$constructorParameters = $constructor->getParameters();
|
|
|
|
$params = array();
|
|
foreach ($constructorParameters as $constructorParameter) {
|
|
$paramName = $constructorParameter->name;
|
|
$key = $this->nameConverter ? $this->nameConverter->normalize($paramName) : $paramName;
|
|
|
|
$allowed = false === $allowedAttributes || \in_array($paramName, $allowedAttributes);
|
|
$ignored = !$this->isAllowedAttribute($class, $paramName, $format, $context);
|
|
if ($constructorParameter->isVariadic()) {
|
|
if ($allowed && !$ignored && (isset($data[$key]) || array_key_exists($key, $data))) {
|
|
if (!\is_array($data[$paramName])) {
|
|
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));
|
|
}
|
|
|
|
$params = array_merge($params, $data[$paramName]);
|
|
}
|
|
} elseif ($allowed && !$ignored && (isset($data[$key]) || array_key_exists($key, $data))) {
|
|
$parameterData = $data[$key];
|
|
if (null === $parameterData && $constructorParameter->allowsNull()) {
|
|
$params[] = null;
|
|
// Don't run set for a parameter passed to the constructor
|
|
unset($data[$key]);
|
|
continue;
|
|
}
|
|
try {
|
|
if (null !== $constructorParameter->getClass()) {
|
|
if (!$this->serializer instanceof DenormalizerInterface) {
|
|
throw new LogicException(sprintf('Cannot create an instance of %s from serialized data because the serializer inject in "%s" is not a denormalizer', $constructorParameter->getClass(), static::class));
|
|
}
|
|
$parameterClass = $constructorParameter->getClass()->getName();
|
|
$parameterData = $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $paramName));
|
|
}
|
|
} catch (\ReflectionException $e) {
|
|
throw new RuntimeException(sprintf('Could not determine the class of the parameter "%s".', $key), 0, $e);
|
|
} catch (MissingConstructorArgumentsException $e) {
|
|
if (!$constructorParameter->getType()->allowsNull()) {
|
|
throw $e;
|
|
}
|
|
$parameterData = null;
|
|
}
|
|
|
|
// Don't run set for a parameter passed to the constructor
|
|
$params[] = $parameterData;
|
|
unset($data[$key]);
|
|
} elseif (isset($context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key])) {
|
|
$params[] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
|
|
} elseif ($constructorParameter->isDefaultValueAvailable()) {
|
|
$params[] = $constructorParameter->getDefaultValue();
|
|
} else {
|
|
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
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if ($constructor->isConstructor()) {
|
|
return $reflectionClass->newInstanceArgs($params);
|
|
} else {
|
|
return $constructor->invokeArgs(null, $params);
|
|
}
|
|
}
|
|
|
|
return new $class();
|
|
}
|
|
|
|
/**
|
|
* @param array $parentContext
|
|
* @param string $attribute
|
|
*
|
|
* @return array
|
|
*
|
|
* @internal
|
|
*/
|
|
protected function createChildContext(array $parentContext, $attribute)
|
|
{
|
|
if (isset($parentContext[self::ATTRIBUTES][$attribute])) {
|
|
$parentContext[self::ATTRIBUTES] = $parentContext[self::ATTRIBUTES][$attribute];
|
|
} else {
|
|
unset($parentContext[self::ATTRIBUTES]);
|
|
}
|
|
|
|
return $parentContext;
|
|
}
|
|
}
|