Apie\ObjectAccessNormalizer\Normalizers\MethodCallDenormalizer

Complexity

Total Complexity

11

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	supportsDenormalization()	0	6	2
A	__construct()	0	8	1
B	denormalize()	0	40	8

<?php


namespace Apie\ObjectAccessNormalizer\Normalizers;

use Apie\ObjectAccessNormalizer\Errors\ErrorBag;
use Apie\ObjectAccessNormalizer\Exceptions\ValidationException;
use Apie\ObjectAccessNormalizer\NameConverters\NullNameConverter;
use Apie\ObjectAccessNormalizer\ObjectAccess\ObjectAccessInterface;
use ReflectionClass;
use ReflectionMethod;
use stdClass;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
use Throwable;

/**
 * Special denormalizer to call a reflection method and return the value back.
 *
 * Usage:
 * - type: ReflectionMethod::ClassWithNameSpace::method
 * - context['object-instance'] object to run method on
 * - context['initial-arguments'] already hydrated arguments with key = variable name.
 * - context['object-access'] used object access instance.
 */
class MethodCallDenormalizer implements ContextAwareDenormalizerInterface
{
    /**
     * @var ObjectAccessInterface
     */
    private $objectAccess;

    /**
     * @var ApieObjectAccessNormalizer
     */
    private $normalizer;

    /**
     * @var NameConverterInterface
     */
    private $nameConverter;

    public function __construct(
        ObjectAccessInterface $objectAccess,
        ApieObjectAccessNormalizer $normalizer,
        NameConverterInterface $nameConverter = null
    ) {
        $this->objectAccess = $objectAccess;
        $this->normalizer = $normalizer;
        $this->nameConverter = $nameConverter ?? new NullNameConverter();
    }

    /**
     * {@inheritDoc}
     */
    public function supportsDenormalization($data, $type, $format = null, array $context = [])
    {
        if (strpos($type, 'ReflectionMethod::') !== 0) {
            return false;
        }
        return isset($context['object-instance']);
    }

    /**
     * {@inheritDoc}
     */
    public function denormalize($data, $type, $format = null, array $context = [])
    {
        if ($data instanceof stdClass) {
            $data = json_decode(json_encode($data), true);
        }
        if (!isset($context['key_prefix'])) {
            $context['key_prefix'] = '';
        }
        $method = new ReflectionMethod(substr($type, strlen('ReflectionMethod::')));
        $objectAccess = $context['object_access'] ?? $this->objectAccess;
        $arguments = $objectAccess->getMethodArguments($method, new ReflectionClass($context['object-instance']));
        $initialArguments = $context['initial-arguments'] ?? [];
        $returnObject = $initialArguments;
        $errorBag = new ErrorBag('');
        foreach ($arguments as $denormalizedFieldName => $typeHint) {
            $fieldName = $this->nameConverter->normalize($denormalizedFieldName, $type, $format, $context);

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

            if (isset($initialArguments[$fieldName])) {
                continue;
            }
            if (!isset($data[$fieldName])) {
                $errorBag->addThrowable($fieldName, new ValidationException([$fieldName => ['required']]));
                continue;
            }
            try {
                $returnObject[$fieldName] = $this->normalizer->denormalizeType(
                    $data,
                    $denormalizedFieldName,
                    $fieldName,
                    $typeHint,
                    $format,
                    $context
                );
            } catch (Throwable $throwable) {
                $errorBag->addThrowable($fieldName, $throwable);
            }
        }
        if ($errorBag->hasErrors()) {
            throw new ValidationException($errorBag);
        }
        return $method->invokeArgs($context['object-instance'], $returnObject);
    }
}