NormalizationContext::prepareOptions() - Code Metrics - Inspection of "feat: Adding support of php 7.4 typed properties (..." - b2pweb/bdf-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f65755...df5a12 )

by Sébastien

created 2021-08-04 12:47 UTC

NormalizationContext::prepareOptions() B

↳ Parent: NormalizationContext

Complexity

Conditions	9
Paths	9

Size

Total Lines	26
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	19
CRAP Score	9

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	9
eloc	20
c	1
b	0
f	0
nc	9
nop	1
dl	0
loc	26
ccs	19
cts	19
cp	1
crap	9
rs	8.0555

<?php

namespace Bdf\Serializer\Context;

use Bdf\Serializer\Exception\CircularReferenceException;
use Bdf\Serializer\Metadata\PropertyMetadata;
use Bdf\Serializer\Normalizer\NormalizerInterface;

/**
 * NormalizationContext
 *
 * context used by normalization
 */
class NormalizationContext extends Context
{
    //List of denormalization options
    const EXCLUDES = 'exclude';
    const INCLUDES = 'include';
    const GROUPS = 'groups';
    const NULL = 'null';
    const META_TYPE = 'include_type';
    const VERSION = 'version';
    const DATETIME_FORMAT = 'dateFormat';
    const TIMEZONE = 'dateTimezone';
    const CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit';
    const REMOVE_DEFAULT_VALUE = 'remove_default_value';
    const THROWS_ON_ACCESSOR_ERROR = 'throws_on_accessor_error';

    /**
     * The default options of this context
     *
     * @var array
     */
    protected $defaultOptions = [
        /**
         * Properties to exclude from normalization
         *
         * @var array
         */
        self::EXCLUDES => null,
        /**
         * Properties to include from normalization
         *
         * @var array
         */
        self::INCLUDES => null,
        /**
         * Groups of properties to include
         *
         * @var array
         */
        self::GROUPS => null,
        /**
         * Null value will be added if true
         *
         * @var boolean
         */
        self::NULL => false,
        /**
         * Include the metadata '@type' in the payload
         *
         * @var boolean
         */
        self::META_TYPE => false,
        /**
         * The version of the object.
         *
         * @var string|null
         */
        self::VERSION => null,
        /**
         * The circular reference limit
         *
         * @var integer
         */
        self::CIRCULAR_REFERENCE_LIMIT => 1,
        /**
         * Default value will be removed if true
         *
         * @var boolean
         */
        self::REMOVE_DEFAULT_VALUE => false,
        /**
         * Throws exception if accessor has error
         *
         * @var boolean
         */
        self::THROWS_ON_ACCESSOR_ERROR => false,
    ];

    /**
     * The object reference for circular reference
     *
     * @var array
     */
    private $objectReferences = [];

    /**
     * {@inheritdoc}
     */
    public function __construct(NormalizerInterface $normalizer, array $options = [])
    {
        parent::__construct($normalizer, $this->defaultOptions);

        $this->prepareOptions($options);
    }

    /**
     * Get the context groups
     *
     * @return null|array
     */
    public function groups(): ?array
    {
        return $this->options[self::GROUPS];
    }

    /**
     * Get the context exclude properties
     *
     * @return null|array
     */
    public function excludeProperties(): ?array
    {
        return $this->options[self::EXCLUDES];
    }

    /**
     * Get the context include properties
     *
     * @return null|array
     */
    public function includeProperties(): ?array
    {
        return $this->options[self::INCLUDES];
    }

    /**
     * Should the self::NULL value be included
     *
     * @return boolean
     */
    public function shouldAddNull(): bool
    {
        return $this->options[self::NULL];
    }

    /**
     * Should the default value of a property be removed
     *
     * @return boolean
     */
    public function removeDefaultValue(): bool
    {
        return $this->options[self::REMOVE_DEFAULT_VALUE];
    }

    /**
     * Serialize to the version
     *
     * @return string
     */
    public function version(): ?string
    {
        return $this->options[self::VERSION];
    }

    /**
     * Should add metadata of type into the serialization
     *
     * @return bool
     */
    public function includeMetaType(): bool
    {
        return $this->options[self::META_TYPE];
    }

    /**
     * Should add metadata of type into the serialization
     *
     * @return bool
     */
    public function throwsOnAccessorError(): bool
    {
        return $this->options[self::THROWS_ON_ACCESSOR_ERROR];
    }

    /**
     * Skip the property by its value
     *
     * @param PropertyMetadata $property
     * @param mixed $value
     *
     * @return boolean   Returns true if skipped
     */
    public function skipPropertyValue(PropertyMetadata $property, $value): bool
    {
        if ($value === null) {
            return !$this->shouldAddNull();
        }

        // This does not remove the 'null' default value.
        if ($this->removeDefaultValue()) {
            return $property->defaultValue === $value;
        }

        return false;
    }

    /**
     * Should the property be skipped
     *
     * @param PropertyMetadata $property
     *
     * @return boolean   Returns true if skipped
     *
     * @todo Add custom filters
     */
    public function skipProperty(PropertyMetadata $property): bool
    {
        $groups = $this->groups();

        // A group has been set and the property is not in that group: we skip the property
        if ($groups !== null && !$property->hasGroups($groups)) {
            return true;
        }

        $version = $this->version();

        // A version has been set and the property does not match this version
        if ($version !== null && !$property->matchVersion($version)) {
            return true;
        }

        return !$this->shouldNormalizeProperty($property->class, $property->name);
    }

    /**
     * @param string $class
     * @param string $property
     *
     * @return bool
     */
    public function shouldNormalizeProperty(string $class, string $property): bool
    {
        $path = "${class}::${property}";

        $excludes = $this->excludeProperties();

        if ($excludes !== null && (isset($excludes[$property]) || isset($excludes[$path]))) {
            return false;
        }

        $includes = $this->includeProperties();

        if ($includes !== null && !isset($includes[$property]) && !isset($includes[$path])) {
            return false;
        }

        return true;
    }

    /**
     * Detects if the configured circular reference limit is reached.
     *
     * @param object $object
     *
     * @return string The object hash
     *
     * @throws CircularReferenceException If circular reference found
     */
    public function assertNoCircularReference($object): string
    {
        $objectHash = spl_object_hash($object);

        if (!isset($this->objectReferences[$objectHash])) {
            $this->objectReferences[$objectHash] = 1;

            return $objectHash;
        }

        if ($this->objectReferences[$objectHash] < $this->options[self::CIRCULAR_REFERENCE_LIMIT]) {
            $this->objectReferences[$objectHash]++;

            return $objectHash;
        }

        unset($this->objectReferences[$objectHash]);

        throw new CircularReferenceException(
            'A circular reference has been detected when serializing the object of class "'.get_class($object).'" (configured limit: '.$this->options[self::CIRCULAR_REFERENCE_LIMIT].')'
        );
    }

    /**
     * Release the object
     *
     * @param string $objectHash
     */
    public function releaseReference(string $objectHash): void
    {
        // Release the memory if depth is equal to 1
        if ($this->objectReferences[$objectHash] === 1) {
            unset($this->objectReferences[$objectHash]);

            return;
        }

        $this->objectReferences[$objectHash]--;
    }

    /**
     * {@inheritdoc}
     */
    protected function prepareOptions(array $options): void
    {
        foreach ($options as $name => $value) {
            switch ($name) {
                case 'group':
                case self::GROUPS:
                    $this->options[self::GROUPS] = (array)$value;
                    break;

                case 'serializeNull':
                case 'serialize_null':
                case self::NULL:
                    $this->options[self::NULL] = (bool)$value;
                    break;

                case self::EXCLUDES:
                    $this->options[self::EXCLUDES] = array_flip((array)$value);
                    break;

                case self::INCLUDES:
                    $this->options[self::INCLUDES] = array_flip((array)$value);
                    break;

                default:
                    $this->options[$name] = $value;
                    break;
            }
        }
    }
}

1		<?php
2
3		namespace Bdf\Serializer\Context;
4
5		use Bdf\Serializer\Exception\CircularReferenceException;
6		use Bdf\Serializer\Metadata\PropertyMetadata;
7		use Bdf\Serializer\Normalizer\NormalizerInterface;
8
9		/**
10		* NormalizationContext
11		*
12		* context used by normalization
13		*/
14		class NormalizationContext extends Context
15		{
16		//List of denormalization options
17		const EXCLUDES = 'exclude';
18		const INCLUDES = 'include';
19		const GROUPS = 'groups';
20		const NULL = 'null';
21		const META_TYPE = 'include_type';
22		const VERSION = 'version';
23		const DATETIME_FORMAT = 'dateFormat';
24		const TIMEZONE = 'dateTimezone';
25		const CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit';
26		const REMOVE_DEFAULT_VALUE = 'remove_default_value';
27		const THROWS_ON_ACCESSOR_ERROR = 'throws_on_accessor_error';
28
29		/**
30		* The default options of this context
31		*
32		* @var array
33		*/
34		protected $defaultOptions = [
35		/**
36		* Properties to exclude from normalization
37		*
38		* @var array
39		*/
40		self::EXCLUDES => null,
41		/**
42		* Properties to include from normalization
43		*
44		* @var array
45		*/
46		self::INCLUDES => null,
47		/**
48		* Groups of properties to include
49		*
50		* @var array
51		*/
52		self::GROUPS => null,
53		/**
54		* Null value will be added if true
55		*
56		* @var boolean
57		*/
58		self::NULL => false,
59		/**
60		* Include the metadata '@type' in the payload
61		*
62		* @var boolean
63		*/
64		self::META_TYPE => false,
65		/**
66		* The version of the object.
67		*
68		* @var string\|null
69		*/
70		self::VERSION => null,
71		/**
72		* The circular reference limit
73		*
74		* @var integer
75		*/
76		self::CIRCULAR_REFERENCE_LIMIT => 1,
77		/**
78		* Default value will be removed if true
79		*
80		* @var boolean
81		*/
82		self::REMOVE_DEFAULT_VALUE => false,
83		/**
84		* Throws exception if accessor has error
85		*
86		* @var boolean
87		*/
88		self::THROWS_ON_ACCESSOR_ERROR => false,
89		];
90
91		/**
92		* The object reference for circular reference
93		*
94		* @var array
95		*/
96		private $objectReferences = [];
97
98		/**
99		* {@inheritdoc}
100		*/
101	75	public function __construct(NormalizerInterface $normalizer, array $options = [])
102		{
103	75	parent::__construct($normalizer, $this->defaultOptions);
104
105	75	$this->prepareOptions($options);
106	75	}
107
108		/**
109		* Get the context groups
110		*
111		* @return null\|array
112		*/
113	56	public function groups(): ?array
114		{
115	56	return $this->options[self::GROUPS];
116		}
117
118		/**
119		* Get the context exclude properties
120		*
121		* @return null\|array
122		*/
123	51	public function excludeProperties(): ?array
124		{
125	51	return $this->options[self::EXCLUDES];
126		}
127
128		/**
129		* Get the context include properties
130		*
131		* @return null\|array
132		*/
133	49	public function includeProperties(): ?array
134		{
135	49	return $this->options[self::INCLUDES];
136		}
137
138		/**
139		* Should the self::NULL value be included
140		*
141		* @return boolean
142		*/
143	8	public function shouldAddNull(): bool
144		{
145	8	return $this->options[self::NULL];
146		}
147
148		/**
149		* Should the default value of a property be removed
150		*
151		* @return boolean
152		*/
153	38	public function removeDefaultValue(): bool
154		{
155	38	return $this->options[self::REMOVE_DEFAULT_VALUE];
156		}
157
158		/**
159		* Serialize to the version
160		*
161		* @return string
162		*/
163	53	public function version(): ?string
164		{
165	53	return $this->options[self::VERSION];
166		}
167
168		/**
169		* Should add metadata of type into the serialization
170		*
171		* @return bool
172		*/
173	45	public function includeMetaType(): bool
174		{
175	45	return $this->options[self::META_TYPE];
176		}
177
178		/**
179		* Should add metadata of type into the serialization
180		*
181		* @return bool
182		*/
183		public function throwsOnAccessorError(): bool
184		{
185		return $this->options[self::THROWS_ON_ACCESSOR_ERROR];
186		}
187
188		/**
189		* Skip the property by its value
190		*
191		* @param PropertyMetadata $property
192		* @param mixed $value
193		*
194		* @return boolean Returns true if skipped
195		*/
196	39	public function skipPropertyValue(PropertyMetadata $property, $value): bool
197		{
198	39	if ($value === null) {
199	4	return !$this->shouldAddNull();
200		}
201
202		// This does not remove the 'null' default value.
203	38	if ($this->removeDefaultValue()) {
204	2	return $property->defaultValue === $value;
205		}
206
207	38	return false;
208		}
209
210		/**
211		* Should the property be skipped
212		*
213		* @param PropertyMetadata $property
214		*
215		* @return boolean Returns true if skipped
216		*
217		* @todo Add custom filters
218		*/
219	52	public function skipProperty(PropertyMetadata $property): bool
220		{
221	52	$groups = $this->groups();
222
223		// A group has been set and the property is not in that group: we skip the property
224	52	if ($groups !== null && !$property->hasGroups($groups)) {
225	3	return true;
226		}
227
228	51	$version = $this->version();
229
230		// A version has been set and the property does not match this version
231	51	if ($version !== null && !$property->matchVersion($version)) {
232	4	return true;
233		}
234
235	49	return !$this->shouldNormalizeProperty($property->class, $property->name);
236		}
237
238		/**
239		* @param string $class
240		* @param string $property
241		*
242		* @return bool
243		*/
244	49	public function shouldNormalizeProperty(string $class, string $property): bool
245		{
246	49	$path = "${class}::${property}";
247
248	49	$excludes = $this->excludeProperties();
249
250	49	if ($excludes !== null && (isset($excludes[$property]) \|\| isset($excludes[$path]))) {
251	4	return false;
252		}
253
254	47	$includes = $this->includeProperties();
255
256	47	if ($includes !== null && !isset($includes[$property]) && !isset($includes[$path])) {
257	3	return false;
258		}
259
260	46	return true;
261		}
262
263		/**
264		* Detects if the configured circular reference limit is reached.
265		*
266		* @param object $object
267		*
268		* @return string The object hash
269		*
270		* @throws CircularReferenceException If circular reference found
271		*/
272	46	public function assertNoCircularReference($object): string
273		{
274	46	$objectHash = spl_object_hash($object);
275
276	46	if (!isset($this->objectReferences[$objectHash])) {
277	46	$this->objectReferences[$objectHash] = 1;
278
279	46	return $objectHash;
280		}
281
282	5	if ($this->objectReferences[$objectHash] < $this->options[self::CIRCULAR_REFERENCE_LIMIT]) {
283	3	$this->objectReferences[$objectHash]++;
284
285	3	return $objectHash;
286		}
287
288	3	unset($this->objectReferences[$objectHash]);
289
290	3	throw new CircularReferenceException(
291	3	'A circular reference has been detected when serializing the object of class "'.get_class($object).'" (configured limit: '.$this->options[self::CIRCULAR_REFERENCE_LIMIT].')'
292		);
293		}
294
295		/**
296		* Release the object
297		*
298		* @param string $objectHash
299		*/
300	41	public function releaseReference(string $objectHash): void
301		{
302		// Release the memory if depth is equal to 1
303	41	if ($this->objectReferences[$objectHash] === 1) {
304	40	unset($this->objectReferences[$objectHash]);
305
306	40	return;
307		}
308
309	1	$this->objectReferences[$objectHash]--;
310	1	}
311
312		/**
313		* {@inheritdoc}
314		*/
315	75	protected function prepareOptions(array $options): void
316		{
317	75	foreach ($options as $name => $value) {
318		switch ($name) {
319	42	case 'group':
320	40	case self::GROUPS:
321	7	$this->options[self::GROUPS] = (array)$value;
322	7	break;
323
324	38	case 'serializeNull':
325	35	case 'serialize_null':
326	35	case self::NULL:
327	9	$this->options[self::NULL] = (bool)$value;
328	9	break;
329
330	34	case self::EXCLUDES:
331	6	$this->options[self::EXCLUDES] = array_flip((array)$value);
332	6	break;
333
334	29	case self::INCLUDES:
335	6	$this->options[self::INCLUDES] = array_flip((array)$value);
336	6	break;
337
338		default:
339	24	$this->options[$name] = $value;
340	42	break;
341		}
342		}
343		}
344		}

b2pweb / bdf-serializer

Push — master ( f65755...df5a12 )

NormalizationContext::prepareOptions() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like