-refactoring

Author: alexndlm

src/Serializer/AbstractItemNormalizer.php

@@ -304,27 +304,18 @@ protected function instantiateObject(array &$data, string $class, array &$contex
 
  return $object;
  }
- // clean up even if no match
- unset($context[static::OBJECT_TO_POPULATE]);
 
  $class = $this->getClassDiscriminatorResolvedClass($data, $class, $context);
  $reflectionClass = new \ReflectionClass($class);
 
  $constructor = $this->getConstructor($data, $class, $context, $reflectionClass, $allowedAttributes);
  if ($constructor) {
- $context['has_constructor'] = true;
- if (true !== $constructor->isPublic()) {
- return $reflectionClass->newInstanceWithoutConstructor();
- }
-
  $constructorParameters = $constructor->getParameters();
- $missingConstructorArguments = [];
- $params = [];
- $unsetKeys = [];
 
+ $params = [];
+ $missingConstructorArguments = [];
  foreach ($constructorParameters as $constructorParameter) {
  $paramName = $constructorParameter->name;
- $attributeContext = $this->getAttributeDenormalizationContext($class, $paramName, $context);
  $key = $this->nameConverter ? $this->nameConverter->normalize($paramName, $class, $format, $context) : $paramName;
 
  $allowed = false === $allowedAttributes || (\is_array($allowedAttributes) && \in_array($paramName, $allowedAttributes, true));
@@ -335,22 +326,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
  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));
  }
 
- $variadicParameters = [];
- foreach ($data[$key] as $parameterKey => $parameterData) {
- try {
- $variadicParameters[$parameterKey] = $this->denormalizeParameter($reflectionClass, $constructorParameter, $paramName, $parameterData, $attributeContext, $format);
- } catch (NotNormalizableValueException $exception) {
- if (!isset($context['not_normalizable_value_exceptions'])) {
- throw $exception;
- }
-
- $context['not_normalizable_value_exceptions'][] = $exception;
- $params[$paramName] = $parameterData;
- }
- }
-
- $params = array_merge(array_values($params), $variadicParameters);
- $unsetKeys[] = $key;
+ $params[] = $data[$paramName];
  }
  } elseif ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
  $constructorContext = $context;
@@ -365,21 +341,18 @@ protected function instantiateObject(array &$data, string $class, array &$contex
  }
 
  // Don't run set for a parameter passed to the constructor
- $unsetKeys[] = $key;
- } elseif (\array_key_exists($key, $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
- $params[$paramName] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
- } elseif (\array_key_exists($key, $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class] ?? [])) {
- $params[$paramName] = $this->defaultContext[self::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
+ unset($data[$key]);
+ } elseif (isset($context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key])) {
+ $params[] = $context[static::DEFAULT_CONSTRUCTOR_ARGUMENTS][$class][$key];
  } elseif ($constructorParameter->isDefaultValueAvailable()) {
- $params[$paramName] = $constructorParameter->getDefaultValue();
- } elseif (!($context[self::REQUIRE_ALL_PROPERTIES] ?? $this->defaultContext[self::REQUIRE_ALL_PROPERTIES] ?? false) && $constructorParameter->hasType() && $constructorParameter->getType()->allowsNull()) {
- $params[$paramName] = null;
+ $params[] = $constructorParameter->getDefaultValue();
  } else {
  if (!isset($context['not_normalizable_value_exceptions'])) {
  $missingConstructorArguments[] = $constructorParameter->name;
  continue;
  }
 
+ $attributeContext = $this->getAttributeDenormalizationContext($class, $paramName, $context);
  $constructorParameterType = 'unknown';
  $reflectionType = $constructorParameter->getType();
  if ($reflectionType instanceof \ReflectionNamedType) {
@@ -401,39 +374,15 @@ protected function instantiateObject(array &$data, string $class, array &$contex
  throw new MissingConstructorArgumentsException(\sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$%s".', $class, implode('", "$', $missingConstructorArguments)), 0, null, $missingConstructorArguments, $class);
  }
 
- if (!$constructor->isConstructor()) {
- $instance = $constructor->invokeArgs(null, $params);
-
- // do not set a parameter that has been set in the constructor
- foreach ($unsetKeys as $key) {
- unset($data[$key]);
- }
-
- return $instance;
- }
-
- try {
- $instance = $reflectionClass->newInstanceArgs($params);
-
- // do not set a parameter that has been set in the constructor
- foreach ($unsetKeys as $key) {
- unset($data[$key]);
- }
-
- return $instance;
- } catch (\TypeError $e) {
- if (!isset($context['not_normalizable_value_exceptions'])) {
- throw $e;
- }
-
+ if (\count($context['not_normalizable_value_exceptions'] ?? []) > 0) {
  return $reflectionClass->newInstanceWithoutConstructor();
  }
- }
 
- unset($context['has_constructor']);
+ if ($constructor->isConstructor()) {
+ return $reflectionClass->newInstanceArgs($params);
+ }
 
- if (!$reflectionClass->isInstantiable()) {
- throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Failed to create object because the class "%s" is not instantiable.', $class), $data, ['unknown'], $context['deserialization_path'] ?? null);
+ return $constructor->invokeArgs(null, $params);
  }
 
  return new $class();