Denormalizer::addObjectMapping() - Code Metrics - Inspection of "add denormalizer test" - chubbyphp/chubbyphp-deserialization - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cc6a18...73e738 )

by Dominik

created 2017-10-04 17:26 UTC

Denormalizer::addObjectMapping() A

↳ Parent: Denormalizer

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace Chubbyphp\Deserialization\Denormalizer;

use Chubbyphp\Deserialization\DeserializerLogicException;
use Chubbyphp\Deserialization\DeserializerRuntimeException;
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 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 = $data['_type'] ?? null;

        unset($data['_type']);

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

chubbyphp / chubbyphp-deserialization

Push — master ( cc6a18...73e738 )

Denormalizer::addObjectMapping() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like