Denormalizer::denormalizeField() - Code Metrics - Inspection of "add-force-type" - chubbyphp/chubbyphp-deserialization - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#13)

by Dominik

created 2018-05-09 15:18 UTC

Denormalizer::denormalizeField() B

↳ Parent: Denormalizer

Complexity

Conditions	3
Paths	3

Size

Total Lines	30
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	30
ccs	16
cts	16
cp	1
rs	8.8571
c	0
b	0
f	0
cc	3
eloc	20
nc	3
nop	5
crap	3

<?php

declare(strict_types=1);

namespace Chubbyphp\Deserialization\Denormalizer;

use Chubbyphp\Deserialization\DeserializerLogicException;
use Chubbyphp\Deserialization\DeserializerRuntimeException;
use Chubbyphp\Deserialization\Mapping\DenormalizationFieldMappingInterface;
use Chubbyphp\Deserialization\Mapping\DenormalizationObjectMappingInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

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

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

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

    /**
     * @param object|string                     $object
     * @param array                             $data
     * @param DenormalizerContextInterface|null $context
     * @param string                            $path
     *
     * @return object
     *
     * @throws DeserializerLogicException
     * @throws DeserializerRuntimeException
     */
    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']);
        }

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

        foreach ($objectMapping->getDenormalizationFieldMappings($path, $type) as $fieldMapping) {
            $this->denormalizeField($context, $fieldMapping, $path, $data, $object);

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

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

        return $object;
    }

    /**
     * @param string $class
     *
     * @return DenormalizationObjectMappingInterface
     *
     * @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;
        }
    }

    /**
     * @param DenormalizationObjectMappingInterface $objectMapping
     * @param string                                $path
     * @param string|null                           $type
     *
     * @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 DenormalizerContextInterface         $context
     * @param DenormalizationFieldMappingInterface $fieldMapping
     * @param string                               $path
     * @param array                                $data
     * @param object                               $object
     */
    private function denormalizeField(
        DenormalizerContextInterface $context,
        DenormalizationFieldMappingInterface $fieldMapping,
        string $path,
        array $data,
        $object
    ) {
        $name = $fieldMapping->getName();
        if (!array_key_exists($name, $data)) {
            return;
        }

        $fieldDenormalizer = $fieldMapping->getFieldDenormalizer();

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

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

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

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

    /**
     * @param DenormalizationFieldMappingInterface $fieldMapping
     * @param mixed                                $value
     *
     * @return mixed
     */
    private function forceType(DenormalizationFieldMappingInterface $fieldMapping, $value)
    {
        if (!method_exists($fieldMapping, 'getForceType')) {
            return $value;
        }

        if (null === $forceType = $fieldMapping->getForceType()) {
            return $value;
        }

        $type = gettype($value);

        if (!is_scalar($value) || $forceType === $type) {
            return $value;
        }

        if (!in_array($forceType, DenormalizationFieldMappingInterface::FORCETYPES, true)) {
            return $value;
        }

        $forcedValue = $value;
        settype($forcedValue, $forceType);

        if ((string) $value !== (string) $forcedValue) {
            return $value;
        }

        return $forcedValue;
    }

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

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

        throw $exception;
    }

    /**
     * @param DenormalizerContextInterface         $context
     * @param DenormalizationFieldMappingInterface $fieldMapping
     *
     * @return bool
     */
    private function isWithinGroup(
        DenormalizerContextInterface $context,
        DenormalizationFieldMappingInterface $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|int $name
     *
     * @return string
     */
    private function getSubPathByName(string $path, $name): string
    {
        return '' === $path ? (string) $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\DeserializerLogicException;
8		use Chubbyphp\Deserialization\DeserializerRuntimeException;
9		use Chubbyphp\Deserialization\Mapping\DenormalizationFieldMappingInterface;
10		use Chubbyphp\Deserialization\Mapping\DenormalizationObjectMappingInterface;
11		use Psr\Log\LoggerInterface;
12		use Psr\Log\NullLogger;
13
14		final class Denormalizer implements DenormalizerInterface
15		{
16		/**
17		* @var DenormalizerObjectMappingRegistryInterface
18		*/
19		private $denormalizerObjectMappingRegistry;
20
21		/**
22		* @var LoggerInterface
23		*/
24		private $logger;
25
26		/**
27		* @param DenormalizerObjectMappingRegistryInterface $denormalizerObjectMappingRegistry
28		* @param LoggerInterface\|null $logger
29		*/
30	11	public function __construct(
31		DenormalizerObjectMappingRegistryInterface $denormalizerObjectMappingRegistry,
32		LoggerInterface $logger = null
33		) {
34	11	$this->denormalizerObjectMappingRegistry = $denormalizerObjectMappingRegistry;
35	11	$this->logger = $logger ?? new NullLogger();
36	11	}
37
38		/**
39		* @param object\|string $object
40		* @param array $data
41		* @param DenormalizerContextInterface\|null $context
42		* @param string $path
43		*
44		* @return object
45		*
46		* @throws DeserializerLogicException
47		* @throws DeserializerRuntimeException
48		*/
49	11	public function denormalize($object, array $data, DenormalizerContextInterface $context = null, string $path = '')
50		{
51	11	$context = $context ?? DenormalizerContextBuilder::create()->getContext();
52
53	11	$class = is_object($object) ? get_class($object) : $object;
54	11	$objectMapping = $this->getObjectMapping($class);
55
56	10	$type = null;
57	10	if (isset($data['_type'])) {
58	2	$type = $data['_type'];
59
60	2	unset($data['_type']);
61		}
62
63	10	if (!is_object($object)) {
64	9	$object = $this->createNewObject($objectMapping, $path, $type);
65		}
66
67	9	foreach ($objectMapping->getDenormalizationFieldMappings($path, $type) as $fieldMapping) {
68	9	$this->denormalizeField($context, $fieldMapping, $path, $data, $object);
69
70	9	unset($data[$fieldMapping->getName()]);
71		}
72
73	9	if (null !== $context->getAllowedAdditionalFields()
74	9	&& [] !== $fields = array_diff(array_keys($data), $context->getAllowedAdditionalFields())
75		) {
76	2	$this->handleNotAllowedAdditionalFields($path, $fields);
77		}
78
79	7	return $object;
80		}
81
82		/**
83		* @param string $class
84		*
85		* @return DenormalizationObjectMappingInterface
86		*
87		* @throws DeserializerLogicException
88		*/
89	11	private function getObjectMapping(string $class): DenormalizationObjectMappingInterface
90		{
91		try {
92	11	return $this->denormalizerObjectMappingRegistry->getObjectMapping($class);
93	1	} catch (DeserializerLogicException $exception) {
94	1	$this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);
95
96	1	throw $exception;
97		}
98		}
99
100		/**
101		* @param DenormalizationObjectMappingInterface $objectMapping
102		* @param string $path
103		* @param string\|null $type
104		*
105		* @return object
106		*/
107	9	private function createNewObject(
108		DenormalizationObjectMappingInterface $objectMapping,
109		string $path,
110		string $type = null
111		) {
112	9	$factory = $objectMapping->getDenormalizationFactory($path, $type);
113	9	$object = $factory();
114
115	9	if (is_object($object)) {
116	8	return $object;
117		}
118
119	1	$exception = DeserializerLogicException::createFactoryDoesNotReturnObject($path, gettype($object));
120
121	1	$this->logger->error('deserialize: {exception}', ['exception' => $exception->getMessage()]);
122
123	1	throw $exception;
124		}
125
126		/**
127		* @param DenormalizerContextInterface $context
128		* @param DenormalizationFieldMappingInterface $fieldMapping
129		* @param string $path
130		* @param array $data
131		* @param object $object
132		*/
133	9	private function denormalizeField(
134		DenormalizerContextInterface $context,
135		DenormalizationFieldMappingInterface $fieldMapping,
136		string $path,
137		array $data,
138		$object
139		) {
140	9	$name = $fieldMapping->getName();
141	9	if (!array_key_exists($name, $data)) {
142	2	return;
143		}
144
145	7	$fieldDenormalizer = $fieldMapping->getFieldDenormalizer();
146
147	7	if (!$this->isWithinGroup($context, $fieldMapping)) {
148	1	return;
149		}
150
151	6	$subPath = $this->getSubPathByName($path, $name);
152
153	6	$this->logger->info('deserialize: path {path}', ['path' => $subPath]);
154
155	6	$fieldDenormalizer->denormalizeField(
156	6	$subPath,
157	6	$object,
158	6	$this->forceType($fieldMapping, $data[$name]),
159	6	$context,
160	6	$this
161		);
162	6	}
163
164		/**
165		* @param DenormalizationFieldMappingInterface $fieldMapping
166		* @param mixed $value
167		*
168		* @return mixed
169		*/
170	6	private function forceType(DenormalizationFieldMappingInterface $fieldMapping, $value)
171		{
172	6	if (!method_exists($fieldMapping, 'getForceType')) {
173	6	return $value;
174		}
175
176		if (null === $forceType = $fieldMapping->getForceType()) {
177		return $value;
178		}
179
180		$type = gettype($value);
181
182		if (!is_scalar($value) \|\| $forceType === $type) {
183		return $value;
184		}
185
186		if (!in_array($forceType, DenormalizationFieldMappingInterface::FORCETYPES, true)) {
187		return $value;
188		}
189
190		$forcedValue = $value;
191		settype($forcedValue, $forceType);
192
193		if ((string) $value !== (string) $forcedValue) {
194		return $value;
195		}
196
197		return $forcedValue;
198		}
199
200		/**
201		* @param string $path
202		* @param array $names
203		*/
204	2	private function handleNotAllowedAdditionalFields(string $path, array $names)
205		{
206	2	$exception = DeserializerRuntimeException::createNotAllowedAdditionalFields(
207	2	$this->getSubPathsByNames($path, $names)
208		);
209
210	2	$this->logger->notice('deserialize: {exception}', ['exception' => $exception->getMessage()]);
211
212	2	throw $exception;
213		}
214
215		/**
216		* @param DenormalizerContextInterface $context
217		* @param DenormalizationFieldMappingInterface $fieldMapping
218		*
219		* @return bool
220		*/
221	7	private function isWithinGroup(
222		DenormalizerContextInterface $context,
223		DenormalizationFieldMappingInterface $fieldMapping
224		): bool {
225	7	if ([] === $groups = $context->getGroups()) {
226	5	return true;
227		}
228
229	2	foreach ($fieldMapping->getGroups() as $group) {
230	1	if (in_array($group, $groups, true)) {
231	1	return true;
232		}
233		}
234
235	1	return false;
236		}
237
238		/**
239		* @param string $path
240		* @param string\|int $name
241		*
242		* @return string
243		*/
244	7	private function getSubPathByName(string $path, $name): string
245		{
246	7	return '' === $path ? (string) $name : $path.'.'.$name;
247		}
248
249		/**
250		* @param string $path
251		* @param array $names
252		*
253		* @return array
254		*/
255	2	private function getSubPathsByNames(string $path, array $names): array
256		{
257	2	$subPaths = [];
258	2	foreach ($names as $name) {
259	2	$subPaths[] = $this->getSubPathByName($path, $name);
260		}
261
262	2	return $subPaths;
263		}
264		}
265

chubbyphp / chubbyphp-deserialization

Pull Request — master (#13)

Denormalizer::denormalizeField() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like