Denormalizer::denormalizeField() - Code Metrics - Inspection of "try to reduce the complexity" - chubbyphp/chubbyphp-deserialization - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (63f127)

by Dominik

created 2017-09-27 20:25 UTC

Denormalizer::denormalizeField() B

↳ Parent: Denormalizer

Complexity

Conditions	3
Paths	3

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	24
ccs	0
cts	11
cp	0
rs	8.9713
c	0
b	0
f	0
cc	3
eloc	15
nc	3
nop	5
crap	12

<?php

declare(strict_types=1);

namespace Chubbyphp\Deserialization\Denormalizer;

use Chubbyphp\Deserialization\Mapping\DenormalizingFieldMappingInterface;
use Chubbyphp\Deserialization\Mapping\DenormalizingObjectMappingInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

final class Denormalizer implements DenormalizerInterface
{
    /**
     * @var DenormalizingObjectMappingInterface[]
     */
    private $objectMappings;

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

    /**
     * @param array                $objectMappings
     * @param LoggerInterface|null $logger
     */
    public function __construct(array $objectMappings, LoggerInterface $logger = null)
    {
        $this->objectMappings = [];
        foreach ($objectMappings as $objectMapping) {
            $this->addObjectMapping($objectMapping);
        }

        $this->logger = $logger ?? new NullLogger();
    }

    /**
     * @param DenormalizingObjectMappingInterface $objectMapping
     */
    private function addObjectMapping(DenormalizingObjectMappingInterface $objectMapping)
    {
        $this->objectMappings[$objectMapping->getClass()] = $objectMapping;
    }

    /**
     * @param object|string                     $object
     * @param array                             $data
     * @param DenormalizerContextInterface|null $context
     * @param string                            $path
     *
     * @return object
     *
     * @throws DenormalizerException
     */
    public function denormalize($object, array $data, DenormalizerContextInterface $context = null, string $path = '')
    {
        $context = $context ?? new DenormalizerContext();

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

        if (!is_object($object)) {
            $factory = $objectMapping->getFactory();
            $object = $factory();
        }

        foreach ($objectMapping->getDenormalizingFieldMappings() as $denormalizingFieldMapping) {
            $this->denormalizeField($context, $denormalizingFieldMapping, $path, $data, $object);

            unset($data[$denormalizingFieldMapping->getName()]);
        }

        if ([] !== $data && !$context->isAllowedAdditionalFields()) {
            $this->handleNotAllowedAddtionalFields($path, array_keys($data));
        }

        return $object;
    }

    /**
     * @param string $class
     *
     * @return DenormalizingObjectMappingInterface
     */
    private function getObjectMapping(string $class): DenormalizingObjectMappingInterface
    {
        if (isset($this->objectMappings[$class])) {
            return $this->objectMappings[$class];
        }

        $exception = DenormalizerException::createMissingMapping($class);

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

        throw $exception;
    }

    /**
     * @param DenormalizerContextInterface       $context
     * @param DenormalizingFieldMappingInterface $denormalizingFieldMapping
     * @param string                             $path
     * @param array                              $data
     * @param $object
     */
    private function denormalizeField(
        DenormalizerContextInterface $context,
        DenormalizingFieldMappingInterface $denormalizingFieldMapping,
        string $path,
        array $data,
        $object
    ) {
        $name = $denormalizingFieldMapping->getName();
        if (!array_key_exists($name, $data)) {
            return;
        }

        $fieldDenormalizer = $denormalizingFieldMapping->getFieldDenormalizer();

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

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

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

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

    /**
     * @param string $path
     * @param $names
     */
    private function handleNotAllowedAddtionalFields(string $path, $names)
    {
        $exception = DenormalizerException::createNotAllowedAddtionalFields(
            $this->getSubPathsByNames($path, $names)
        );

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

        throw $exception;
    }

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

        foreach ($fieldMapping->getGroups() as $group) {
            if (in_array($group, $groups, true)) {
                return true;
            }
        }

        return false;
    }

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

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

        return $subPaths;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Chubbyphp\Deserialization\Denormalizer;
6
7			use Chubbyphp\Deserialization\Mapping\DenormalizingFieldMappingInterface;
8			use Chubbyphp\Deserialization\Mapping\DenormalizingObjectMappingInterface;
9			use Psr\Log\LoggerInterface;
10			use Psr\Log\NullLogger;
11
12			final class Denormalizer implements DenormalizerInterface
13			{
14			/**
15			* @var DenormalizingObjectMappingInterface[]
16			*/
17			private $objectMappings;
18
19			/**
20			* @var LoggerInterface
21			*/
22			private $logger;
23
24			/**
25			* @param array $objectMappings
26			* @param LoggerInterface\|null $logger
27			*/
28			public function __construct(array $objectMappings, LoggerInterface $logger = null)
29			{
30			$this->objectMappings = [];
31			foreach ($objectMappings as $objectMapping) {
32			$this->addObjectMapping($objectMapping);
33			}
34
35			$this->logger = $logger ?? new NullLogger();
36			}
37
38			/**
39			* @param DenormalizingObjectMappingInterface $objectMapping
40			*/
41			private function addObjectMapping(DenormalizingObjectMappingInterface $objectMapping)
42			{
43			$this->objectMappings[$objectMapping->getClass()] = $objectMapping;
44			}
45
46			/**
47			* @param object\|string $object
48			* @param array $data
49			* @param DenormalizerContextInterface\|null $context
50			* @param string $path
51			*
52			* @return object
53			*
54			* @throws DenormalizerException
55			*/
56			public function denormalize($object, array $data, DenormalizerContextInterface $context = null, string $path = '')
57			{
58			$context = $context ?? new DenormalizerContext();
59
60			$class = is_object($object) ? get_class($object) : $object;
61			$objectMapping = $this->getObjectMapping($class);
62
63			if (!is_object($object)) {
64			$factory = $objectMapping->getFactory();
65			$object = $factory();
66			}
67
68			foreach ($objectMapping->getDenormalizingFieldMappings() as $denormalizingFieldMapping) {
69			$this->denormalizeField($context, $denormalizingFieldMapping, $path, $data, $object);
70
71			unset($data[$denormalizingFieldMapping->getName()]);
72			}
73
74			if ([] !== $data && !$context->isAllowedAdditionalFields()) {
75			$this->handleNotAllowedAddtionalFields($path, array_keys($data));
76			}
77
78			return $object;
79			}
80
81			/**
82			* @param string $class
83			*
84			* @return DenormalizingObjectMappingInterface
85			*/
86			private function getObjectMapping(string $class): DenormalizingObjectMappingInterface
87			{
88			if (isset($this->objectMappings[$class])) {
89			return $this->objectMappings[$class];
90			}
91
92			$exception = DenormalizerException::createMissingMapping($class);
93
94			$this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);
95
96			throw $exception;
97			}
98
99			/**
100			* @param DenormalizerContextInterface $context
101			* @param DenormalizingFieldMappingInterface $denormalizingFieldMapping
102			* @param string $path
103			* @param array $data
104			* @param $object
105			*/
106			private function denormalizeField(
107			DenormalizerContextInterface $context,
108			DenormalizingFieldMappingInterface $denormalizingFieldMapping,
109			string $path,
110			array $data,
111			$object
112			) {
113			$name = $denormalizingFieldMapping->getName();
114			if (!array_key_exists($name, $data)) {
115			return;
116			}
117
118			$fieldDenormalizer = $denormalizingFieldMapping->getFieldDenormalizer();
119
120			if (!$this->isWithinGroup($context, $denormalizingFieldMapping)) {
121			return;
122			}
123
124			$subPath = $this->getSubPathByName($path, $name);
125
126			$this->logger->info('deserialize: path {path}', ['path' => $subPath]);
127
128			$fieldDenormalizer->denormalizeField($subPath, $object, $data[$name], $context, $this);
129			}
130
131			/**
132			* @param string $path
133			* @param $names
134			*/
135			private function handleNotAllowedAddtionalFields(string $path, $names)
136			{
137			$exception = DenormalizerException::createNotAllowedAddtionalFields(
138			$this->getSubPathsByNames($path, $names)
139			);
140
141			$this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);
142
143			throw $exception;
144			}
145
146			/**
147			* @param DenormalizerContextInterface $context
148			* @param DenormalizingFieldMappingInterface $fieldMapping
149			*
150			* @return bool
151			*/
152			private function isWithinGroup(
153			DenormalizerContextInterface $context,
154			DenormalizingFieldMappingInterface $fieldMapping
155			): bool {
156			if ([] === $groups = $context->getGroups()) {
157			return true;
158			}
159
160			foreach ($fieldMapping->getGroups() as $group) {
161			if (in_array($group, $groups, true)) {
162			return true;
163			}
164			}
165
166			return false;
167			}
168
169			/**
170			* @param string $path
171			* @param string $name
172			*
173			* @return string
174			*/
175			private function getSubPathByName(string $path, string $name): string
176			{
177			return '' === $path ? $name : $path.'.'.$name;
178			}
179
180			/**
181			* @param string $path
182			* @param array $names
183			*
184			* @return array
185			*/
186			private function getSubPathsByNames(string $path, array $names): array
187			{
188			$subPaths = [];
189			foreach ($names as $name) {
190			$subPaths[] = $this->getSubPathByName($path, $name);
191			}
192
193			return $subPaths;
194			}
195			}
196

chubbyphp / chubbyphp-deserialization

Branch — master (63f127)

Denormalizer::denormalizeField() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like