JMSSerializerAdapter::convertContext() - Code Metrics - FriendsOfSymfony/FOSRestBundle - Measure and Improve Code Quality continuously with Scrutinizer

JMSSerializerAdapter::convertContext() C
last analyzed 2020-06-15 21:38 UTC

↳ Parent: JMSSerializerAdapter

Complexity

Conditions	10
Paths	256

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	10

Importance

Changes

Metric	Value
dl	0
loc	35
ccs	21
cts	21
cp	1
rs	6.1333
c	0
b	0
f	0
cc	10
nc	256
nop	2
crap	10

How to fix Complexity

<?php

/*
 * This file is part of the FOSRestBundle package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\RestBundle\Serializer;

use FOS\RestBundle\Context\Context;
use JMS\Serializer\Context as JMSContext;
use JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface;
use JMS\Serializer\ContextFactory\SerializationContextFactoryInterface;
use JMS\Serializer\DeserializationContext;
use JMS\Serializer\SerializationContext;
use JMS\Serializer\SerializerInterface;

/**
 * Adapter to plug the JMS serializer into the FOSRestBundle Serializer API.
 *
 * @author Christian Flothmann <[email protected]>
 */
final class JMSSerializerAdapter implements Serializer
{
    /**
     * @internal
     */
    const SERIALIZATION = 0;

    /**
     * @internal
     */
    const DESERIALIZATION = 1;

    private $serializer;
    private $serializationContextFactory;
    private $deserializationContextFactory;

    public function __construct(
        SerializerInterface $serializer,
        SerializationContextFactoryInterface $serializationContextFactory = null,
        DeserializationContextFactoryInterface $deserializationContextFactory = null
    ) {
        $this->serializer = $serializer;
        $this->serializationContextFactory = $serializationContextFactory;
        $this->deserializationContextFactory = $deserializationContextFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize($data, string $format, Context $context): string
    {
        $context = $this->convertContext($context, self::SERIALIZATION);

        return $this->serializer->serialize($data, $format, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function deserialize(string $data, string $type, string $format, Context $context)
    {
        $context = $this->convertContext($context, self::DESERIALIZATION);

        return $this->serializer->deserialize($data, $type, $format, $context);
    }

    private function convertContext(Context $context, int $direction): JMSContext
    {
        if (self::SERIALIZATION === $direction) {
            $jmsContext = $this->serializationContextFactory
                ? $this->serializationContextFactory->createSerializationContext()
                : SerializationContext::create();
        } else {
            $jmsContext = $this->deserializationContextFactory
                ? $this->deserializationContextFactory->createDeserializationContext()
                : DeserializationContext::create();
        }

        foreach ($context->getAttributes() as $key => $value) {
            $jmsContext->setAttribute($key, $value);
        }

        if (null !== $context->getVersion()) {
            $jmsContext->setVersion($context->getVersion());
        }
        if (null !== $context->getGroups()) {
            $jmsContext->setGroups($context->getGroups());
        }
        if (true === $context->isMaxDepthEnabled()) {
            $jmsContext->enableMaxDepthChecks();
        }
        if (null !== $context->getSerializeNull()) {
            $jmsContext->setSerializeNull($context->getSerializeNull());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        }

        foreach ($context->getExclusionStrategies() as $strategy) {
            $jmsContext->addExclusionStrategy($strategy);
        }

        return $jmsContext;
    }
}


1		<?php
2
3		/*
4		* This file is part of the FOSRestBundle package.
5		*
6		* (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace FOS\RestBundle\Serializer;
13
14		use FOS\RestBundle\Context\Context;
15		use JMS\Serializer\Context as JMSContext;
16		use JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface;
17		use JMS\Serializer\ContextFactory\SerializationContextFactoryInterface;
18		use JMS\Serializer\DeserializationContext;
19		use JMS\Serializer\SerializationContext;
20		use JMS\Serializer\SerializerInterface;
21
22		/**
23		* Adapter to plug the JMS serializer into the FOSRestBundle Serializer API.
24		*
25		* @author Christian Flothmann <[email protected]>
26		*/
27		final class JMSSerializerAdapter implements Serializer
28		{
29		/**
30		* @internal
31		*/
32		const SERIALIZATION = 0;
33
34		/**
35		* @internal
36		*/
37		const DESERIALIZATION = 1;
38
39		private $serializer;
40		private $serializationContextFactory;
41		private $deserializationContextFactory;
42
43	12	public function __construct(
44		SerializerInterface $serializer,
45		SerializationContextFactoryInterface $serializationContextFactory = null,
46		DeserializationContextFactoryInterface $deserializationContextFactory = null
47		) {
48	12	$this->serializer = $serializer;
49	12	$this->serializationContextFactory = $serializationContextFactory;
50	12	$this->deserializationContextFactory = $deserializationContextFactory;
51	12	}
52
53		/**
54		* {@inheritdoc}
55		*/
56	10	public function serialize($data, string $format, Context $context): string
57		{
58	10	$context = $this->convertContext($context, self::SERIALIZATION);
59
60	10	return $this->serializer->serialize($data, $format, $context);
61		}
62
63		/**
64		* {@inheritdoc}
65		*/
66	2	public function deserialize(string $data, string $type, string $format, Context $context)
67		{
68	2	$context = $this->convertContext($context, self::DESERIALIZATION);
69
70	2	return $this->serializer->deserialize($data, $type, $format, $context);
71		}
72
73	12	private function convertContext(Context $context, int $direction): JMSContext
74		{
75	12	if (self::SERIALIZATION === $direction) {
76	10	$jmsContext = $this->serializationContextFactory
77	9	? $this->serializationContextFactory->createSerializationContext()
78	10	: SerializationContext::create();
79		} else {
80	2	$jmsContext = $this->deserializationContextFactory
81	1	? $this->deserializationContextFactory->createDeserializationContext()
82	2	: DeserializationContext::create();
83		}
84
85	12	foreach ($context->getAttributes() as $key => $value) {
86	7	$jmsContext->setAttribute($key, $value);
87		}
88
89	12	if (null !== $context->getVersion()) {
90	1	$jmsContext->setVersion($context->getVersion());
91		}
92	12	if (null !== $context->getGroups()) {
93	1	$jmsContext->setGroups($context->getGroups());
94		}
95	12	if (true === $context->isMaxDepthEnabled()) {
96	1	$jmsContext->enableMaxDepthChecks();
97		}
98	12	if (null !== $context->getSerializeNull()) {
99	3	$jmsContext->setSerializeNull($context->getSerializeNull());
		0 ignored issues – show Bug introduced 2018-11-09 15:49 UTC by Report Bug Copy Issue Report The method `setSerializeNull` does only exist in `JMS\Serializer\SerializationContext`, but not in `JMS\Serializer\DeserializationContext`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
100		}
101
102	12	foreach ($context->getExclusionStrategies() as $strategy) {
103	1	$jmsContext->addExclusionStrategy($strategy);
104		}
105
106	12	return $jmsContext;
107		}
108		}
109

FriendsOfSymfony / FOSRestBundle

JMSSerializerAdapter::convertContext() C last analyzed 2020-06-15 21:38 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like

JMSSerializerAdapter::convertContext() C
last analyzed 2020-06-15 21:38 UTC