Denormalizer::isWithinGroup() - Code Metrics - chubbyphp/chubbyphp-deserialization - Measure and Improve Code Quality continuously with Scrutinizer

Denormalizer::isWithinGroup() A
last analyzed 2019-11-21 13:57 UTC

↳ Parent: Denormalizer
Complexity

Conditions	4
Paths	4
Size

Total Lines	24
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	7
CRAP Score	4
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	4
eloc	12
c	1
b	0
f	0
nc	4
nop	2
dl	0
loc	24
ccs	7
cts	7
cp	1
crap	4
rs	9.8666
<?php

declare(strict_types=1);

namespace Chubbyphp\Deserialization\Denormalizer;

use Chubbyphp\Deserialization\Accessor\PropertyAccessor;
use Chubbyphp\Deserialization\DeserializerLogicException;
use Chubbyphp\Deserialization\DeserializerRuntimeException;
use Chubbyphp\Deserialization\Mapping\DenormalizationFieldMappingInterface;
use Chubbyphp\Deserialization\Mapping\DenormalizationObjectMappingInterface;
use Chubbyphp\Deserialization\Policy\GroupPolicy;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

final class Denormalizer implements DenormalizerInterface
{
    /**
     * @var DenormalizerObjectMappingRegistryInterface
     */
    private $denormalizerObjectMappingRegistry;

    /**
     * @var LoggerInterface
     */
    private $logger;

    public function __construct(
        DenormalizerObjectMappingRegistryInterface $denormalizerObjectMappingRegistry,
        LoggerInterface $logger = null
    ) {
        $this->denormalizerObjectMappingRegistry = $denormalizerObjectMappingRegistry;
        $this->logger = $logger ?? new NullLogger();
    }

    /**
     * @param object|string $object
     *
     * @throws DeserializerLogicException
     * @throws DeserializerRuntimeException
     *
     * @return object
     */
    public function denormalize($object, array $data, DenormalizerContextInterface $context = null, string $path = '')
    {
        $context = $context ?? DenormalizerContextBuilder::create()->getContext();

        $class = is_object($object) ? get_class($object) : $object;
        $objectMapping = $this->getObjectMapping($class);

        $type = null;
        if (isset($data['_type'])) {
            $type = $data['_type'];

            unset($data['_type']);
        }

        $isNew = false;
        if (!is_object($object)) {
            $isNew = true;
            $object = $this->createNewObject($objectMapping, $path, $type);
        }

        $missingFields = [];
        $additionalFields = array_flip(array_keys($data));
        foreach ($objectMapping->getDenormalizationFieldMappings($path, $type) as $denormalizationFieldMapping) {
            $name = $denormalizationFieldMapping->getName();

            if (!array_key_exists($name, $data)) {
                $missingFields[] = $name;

                continue;
            }

            $this->denormalizeField($context, $denormalizationFieldMapping, $path, $name, $data, $object);

            unset($additionalFields[$name]);
        }

        $allowedAdditionalFields = $context->getAllowedAdditionalFields();

        if (null !== $allowedAdditionalFields
            && [] !== $fields = array_diff(array_keys($additionalFields), $allowedAdditionalFields)
        ) {
            $this->handleNotAllowedAdditionalFields($path, $fields);
        }

        if (!$isNew) {
            $this->resetMissingFields($context, $objectMapping, $object, $missingFields, $path, $type);
        }

        return $object;
    }

    /**
     * @throws DeserializerLogicException
     */
    private function getObjectMapping(string $class): DenormalizationObjectMappingInterface
    {
        try {
            return $this->denormalizerObjectMappingRegistry->getObjectMapping($class);
        } catch (DeserializerLogicException $exception) {
            $this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);

            throw $exception;
        }
    }

    /**
     * @return object
     */
    private function createNewObject(
        DenormalizationObjectMappingInterface $objectMapping,
        string $path,
        string $type = null
    ) {
        $factory = $objectMapping->getDenormalizationFactory($path, $type);
        $object = $factory();

        if (is_object($object)) {
            return $object;
        }

        $exception = DeserializerLogicException::createFactoryDoesNotReturnObject($path, gettype($object));

        $this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);

        throw $exception;
    }

    /**
     * @param object $object
     */
    private function denormalizeField(
        DenormalizerContextInterface $context,
        DenormalizationFieldMappingInterface $denormalizationFieldMapping,
        string $path,
        string $name,
        array $data,
        $object
    ): void {
        if (!$this->isCompliant($context, $denormalizationFieldMapping, $object)) {
            return;
        }

        if (!$this->isWithinGroup($context, $denormalizationFieldMapping)) {
            return;
        }

        $subPath = $this->getSubPathByName($path, $name);

        $this->logger->info('deserialize: path {path}', ['path' => $subPath]);

        $fieldDenormalizer = $denormalizationFieldMapping->getFieldDenormalizer();
        $fieldDenormalizer->denormalizeField($subPath, $object, $data[$name], $context, $this);
    }

    private function handleNotAllowedAdditionalFields(string $path, array $names): void
    {
        $exception = DeserializerRuntimeException::createNotAllowedAdditionalFields(
            $this->getSubPathsByNames($path, $names)
        );

        $this->logger->notice('deserialize: {exception}', ['exception' => $exception->getMessage()]);

        throw $exception;
    }

    /**
     * @param object $object
     */
    private function isCompliant(
        DenormalizerContextInterface $context,
        DenormalizationFieldMappingInterface $mapping,
        $object
    ): bool {
        if (!is_callable([$mapping, 'getPolicy'])) {
            return true;
        }

        return $mapping->getPolicy()->isCompliant($context, $object);
        return $mapping->/** @scrutinizer ignore-call */ getPolicy()->isCompliant($context, $object);
    }

    private function isWithinGroup(
        DenormalizerContextInterface $context,
        DenormalizationFieldMappingInterface $fieldMapping
    ): bool {
        if ([] === $groups = $context->getGroups()) {
        if ([] === $groups = /** @scrutinizer ignore-deprecated */ $context->getGroups()) {
            return true;
        }

        @trigger_error(
            sprintf(
                'Use "%s" instead of "%s::setGroups"',
                GroupPolicy::class,
                DenormalizerContextInterface::class
            ),
            E_USER_DEPRECATED
        );

        foreach ($fieldMapping->getGroups() as $group) {
        foreach (/** @scrutinizer ignore-deprecated */ $fieldMapping->getGroups() as $group) {
            if (in_array($group, $groups, true)) {
                return true;
            }
        }

        return false;
    }

    private function getSubPathByName(string $path, string $name): string
    {
        return '' === $path ? $name : $path.'.'.$name;
    }

    private function getSubPathsByNames(string $path, array $names): array
    {
        $subPaths = [];
        foreach ($names as $name) {
            $subPaths[] = $this->getSubPathByName($path, $name);
        }

        return $subPaths;
    }

    /**
     * @param object $object
     */
    private function resetMissingFields(
        DenormalizerContextInterface $context,
        DenormalizationObjectMappingInterface $objectMapping,
        $object,
        array $missingFields,
        string $path,
        string $type = null
    ): void {
        if (!method_exists($context, 'isResetMissingFields') || !$context->isResetMissingFields()) {
            return;
        }

        $factory = $objectMapping->getDenormalizationFactory($path, $type);

        $newObject = $factory();

        foreach ($missingFields as $missingField) {
            $accessor = new PropertyAccessor($missingField);
            $accessor->setValue($object, $accessor->getValue($newObject));
        }
    }
}

chubbyphp / chubbyphp-deserialization

Denormalizer::isWithinGroup() A last analyzed 2019-11-21 13:57 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Denormalizer::isWithinGroup() A
last analyzed 2019-11-21 13:57 UTC
