Apie\ObjectAccessNormalizer\Normalizers\ApieObjectAccessNormalizer::denormalize()

Complexity

Conditions	16
Paths	456

Size

Total Lines	70
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

<?php
    public function denormalize($data, $type, $format = null, array $context = [])
    {
        if ($data instanceof stdClass) {
            $data = json_decode(json_encode($data), true);
        }

        // initialize context.
        $context = $this->sanitizeContext($context);
        if (empty($context['object_to_populate'])) {
            $object = $this->instantiate($data, $type, $context['object_access'], $format, $context);
            // skip setters that were already set in the constructor (and allows a different type then the setter)
            if (empty('keep_setter_calls')) {

The condition empty('keep_setter_calls') is always false.

                foreach (array_keys($context['object_access']->getConstructorArguments(new ReflectionClass($type))) as $skippedField) {
                    unset($data[$skippedField]);
                }
            }
        } else {
            $object = $context['object_to_populate'];
        }
        $context['object_hierarchy'][] = $object;
        /** @var ObjectAccessInterface $objectAccess */
        $objectAccess = $context['object_access'];
        if ($this->classMetadataFactory && isset($context['groups'])) {
            $objectAccess = $this->filterObjectAccess($objectAccess, $type, $context['groups']);
        }
        $reflClass = new ReflectionClass($object);
        $setterFields = $objectAccess->getSetterFields($reflClass);
        $errors = new ErrorBag($context['key_prefix']);
        // iterate over all fields that can be set and try to call them.
        foreach ($setterFields as $denormalizedFieldName) {
            try {
                $fieldName = $this->nameConverter->normalize($denormalizedFieldName, $type, $format, $context);

The call to Symfony\Component\Serializer\NameConverter\NameConverterInterface::normalize() has too many arguments starting with $type.

            } catch (Throwable $throwable) {
                // this means the actual field name can not be normalized, so is this a validation error or an internal error?
                $errors->addThrowable($denormalizedFieldName, $throwable);
                continue;
            }
            // actual field does not exist in the $data, so we do not need to call it.
            if (!array_key_exists($fieldName, $data)) {
                continue;
            }
            $succeeded = false;
            $foundErrors = [];
            // try all setters and see if we can call it.
            foreach ($objectAccess->getSetterTypes($reflClass, $denormalizedFieldName) as $getterType) {
                try {
                    $result = $this->denormalizeType($data, $denormalizedFieldName, $fieldName, $getterType, $format, $context);
                    $objectAccess->setValue($object, $denormalizedFieldName, $result);
                    $succeeded = true;
                } catch (Throwable $throwable) {
                    $foundErrors[] = $throwable;
                }
            }
            if (!$succeeded) {
                if ($foundErrors) {
                    $errors->addThrowable($denormalizedFieldName, reset($foundErrors));
                } else {
                    // if no typehints exist we end up here.
                    try {
                        $objectAccess->setValue($object, $denormalizedFieldName, $data[$fieldName]);
                    } catch (Throwable $throwable) {
                        $errors->addThrowable($denormalizedFieldName, $throwable);
                    }
                }
            }
        }
        if ($errors->hasErrors()) {
            throw new ValidationException($errors);
        }
        return $object;
    }