ClosureNormalizer::supports() - Code Metrics - b2pweb/bdf-serializer - Measure and Improve Code Quality continuously with Scrutinizer

ClosureNormalizer::supports() A
last analyzed 2023-03-02 14:56 UTC

↳ Parent: ClosureNormalizer

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Bdf\Serializer\Normalizer;

use Bdf\Serializer\Context\DenormalizationContext;
use Bdf\Serializer\Context\NormalizationContext;
use Bdf\Serializer\Exception\UnexpectedValueException;
use Bdf\Serializer\Type\Type;
use Closure;
use SuperClosure\Analyzer\TokenAnalyzer;
use SuperClosure\Exception\SuperClosureException;
use SuperClosure\Serializer;
use SuperClosure\SerializerInterface;

/**
 * ClosureNormalizer
 *
 * @author  Seb
 *
 * @implements NormalizerInterface<\Closure>
 */
class ClosureNormalizer implements NormalizerInterface, AutoRegisterInterface
{
    /**
     * The closure serializer
     *
     * @var SerializerInterface
     */
    private $serializer;

    /**
     * ClosureNormalizer constructor.
     *
     * @param SerializerInterface $serializer
     */
    public function __construct(SerializerInterface $serializer = null)
    {
        $this->serializer = $serializer ?: new Serializer(new TokenAnalyzer());
    }

    /**
     * {@inheritdoc}
     *
     * @throws UnexpectedValueException If the closure could not be serialize
     * @psalm-suppress InvalidCatch
     */
    public function normalize($data, NormalizationContext $context)
    {
        try {
            return $this->serializer->serialize($data);
        } catch (SuperClosureException $e) {
            throw new UnexpectedValueException('Could not normalize closure object', 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws UnexpectedValueException If the closure could not be unserialize
     * @psalm-suppress InvalidCatch
     */
    public function denormalize($data, Type $type, DenormalizationContext $context)
    {
        try {
            return $this->serializer->unserialize($data);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
        } catch (SuperClosureException $e) {
            throw new UnexpectedValueException('Could not denormalize closure object', 0, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function supports(string $className): bool
    {
        return $className === Closure::class;
    }

    /**
     * {@inheritdoc}
     */
    public function registerTo(NormalizerLoaderInterface $loader): void
    {
        $loader->associate(Closure::class, $this);
    }
}


1		<?php
2
3		namespace Bdf\Serializer\Normalizer;
4
5		use Bdf\Serializer\Context\DenormalizationContext;
6		use Bdf\Serializer\Context\NormalizationContext;
7		use Bdf\Serializer\Exception\UnexpectedValueException;
8		use Bdf\Serializer\Type\Type;
9		use Closure;
10		use SuperClosure\Analyzer\TokenAnalyzer;
11		use SuperClosure\Exception\SuperClosureException;
12		use SuperClosure\Serializer;
13		use SuperClosure\SerializerInterface;
14
15		/**
16		* ClosureNormalizer
17		*
18		* @author Seb
19		*
20		* @implements NormalizerInterface<\Closure>
21		*/
22		class ClosureNormalizer implements NormalizerInterface, AutoRegisterInterface
23		{
24		/**
25		* The closure serializer
26		*
27		* @var SerializerInterface
28		*/
29		private $serializer;
30
31		/**
32		* ClosureNormalizer constructor.
33		*
34		* @param SerializerInterface $serializer
35		*/
36	8	public function __construct(SerializerInterface $serializer = null)
37		{
38	8	$this->serializer = $serializer ?: new Serializer(new TokenAnalyzer());
39		}
40
41		/**
42		* {@inheritdoc}
43		*
44		* @throws UnexpectedValueException If the closure could not be serialize
45		* @psalm-suppress InvalidCatch
46		*/
47	2	public function normalize($data, NormalizationContext $context)
48		{
49		try {
50	2	return $this->serializer->serialize($data);
51		} catch (SuperClosureException $e) {
52		throw new UnexpectedValueException('Could not normalize closure object', 0, $e);
53		}
54		}
55
56		/**
57		* {@inheritdoc}
58		*
59		* @throws UnexpectedValueException If the closure could not be unserialize
60		* @psalm-suppress InvalidCatch
61		*/
62	2	public function denormalize($data, Type $type, DenormalizationContext $context)
63		{
64		try {
65	2	return $this->serializer->unserialize($data);
		0 ignored issues – show Bug Best Practice introduced 2022-02-04 15:22 UTC by Report Bug Copy Issue Report The expression `return $this->serializer->unserialize($data)` returns the type `Closure` which is incompatible with the return type mandated by `Bdf\Serializer\Normalize...nterface::denormalize()` of `Bdf\Serializer\Normalizer\T`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
66		} catch (SuperClosureException $e) {
67		throw new UnexpectedValueException('Could not denormalize closure object', 0, $e);
68		}
69		}
70
71		/**
72		* {@inheritdoc}
73		*/
74	2	public function supports(string $className): bool
75		{
76	2	return $className === Closure::class;
77		}
78
79		/**
80		* {@inheritdoc}
81		*/
82	6	public function registerTo(NormalizerLoaderInterface $loader): void
83		{
84	6	$loader->associate(Closure::class, $this);
85		}
86		}
87

b2pweb / bdf-serializer

ClosureNormalizer::supports() A last analyzed 2023-03-02 14:56 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ClosureNormalizer::supports() A
last analyzed 2023-03-02 14:56 UTC