W2w\Lib\ApieObjectAccessNormalizer\Normalizers\MethodCallDenormalizer

Complexity

Total Complexity

7

Size/Duplication

Total Lines	59
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

3 Methods

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

<?php


namespace W2w\Lib\ApieObjectAccessNormalizer\Normalizers;

use ReflectionClass;
use ReflectionMethod;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
use W2w\Lib\ApieObjectAccessNormalizer\NameConverters\NullNameConverter;
use W2w\Lib\ApieObjectAccessNormalizer\ObjectAccess\ObjectAccessInterface;

/**
 * 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 (!isset($context['key_prefix'])) {
            $context['key_prefix'] = '';
        }
        $method = new ReflectionMethod(substr($type, strlen('ReflectionMethod::')));

The call to ReflectionMethod::__construct() has too few arguments starting with name.

        $objectAccess = $context['object_access'] ?? $this->objectAccess;
        $arguments = $objectAccess->getMethodArguments($method, new ReflectionClass($context['object-instance']));
        $initialArguments = $context['initial-arguments'] ?? [];
        $returnObject = $initialArguments;
        foreach ($arguments as $denormalizedFieldName => $type) {

$type is overwriting one of the parameters of this function.

            $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;
            }
            $returnObject[$fieldName] = $this->normalizer->denormalizeType($data, $denormalizedFieldName, $fieldName, $type, $format, $context);
        }
        return $method->invokeArgs($context['object-instance'], $returnObject);
    }
}