AbstractClassMetadataLoader - Code Metrics - Inspection of "[Exclusion] Fix policy handling" - egeloen/ivory-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 41c5cb...fa48f7 )

by Eric

created 2016-09-22 22:02 UTC

AbstractClassMetadataLoader C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	333
Duplicated Lines	20.72 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	67
lcom	1
cbo	5
dl	69
loc	333
rs	5.7097
c	0
b	0
f	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	2
A	loadClassMetadata()	0	16	3
	loadData()	0	1	?
B	doLoadClassMetadata()	0	20	6
F	loadPropertyMetadata()	0	38	10
A	loadPropertyMetadataAlias()	17	17	4
A	loadPropertyMetadataType()	0	11	3
A	loadPropertyMetadataSinceVersion()	17	17	4
A	loadPropertyMetadataUntilVersion()	17	17	4
B	loadPropertyMetadataMaxDepth()	0	20	6
C	loadPropertyMetadataGroups()	0	28	7
B	getExclusionPolicy()	0	30	6
A	validatePropertyMetadataExclude()	9	9	3
A	validatePropertyMetadataExpose()	9	9	3
B	isPropertyMetadataExposed()	0	7	6

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractClassMetadataLoader often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractClassMetadataLoader, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the Ivory Serializer package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\Serializer\Mapping\Loader;

use Ivory\Serializer\Exclusion\ExclusionPolicy;
use Ivory\Serializer\Mapping\ClassMetadataInterface;
use Ivory\Serializer\Mapping\PropertyMetadata;
use Ivory\Serializer\Mapping\PropertyMetadataInterface;
use Ivory\Serializer\Type\Parser\TypeParser;
use Ivory\Serializer\Type\Parser\TypeParserInterface;

/**
 * @author GeLo <[email protected]>
 */
abstract class AbstractClassMetadataLoader implements ClassMetadataLoaderInterface
{
    /**
     * @var TypeParserInterface
     */
    private $typeParser;

    /**
     * @var mixed[][]
     */
    private $data = [];

    /**
     * @param TypeParserInterface|null $typeParser
     */
    public function __construct(TypeParserInterface $typeParser = null)
    {
        $this->typeParser = $typeParser ?: new TypeParser();
    }

    /**
     * {@inheritdoc}
     */
    public function loadClassMetadata(ClassMetadataInterface $classMetadata)
    {
        $class = $classMetadata->getName();

        if (!array_key_exists($class, $this->data)) {
            $this->data[$class] = $this->loadData($class);
        }

        if (!is_array($data = $this->data[$class])) {
            return false;
        }

        $this->doLoadClassMetadata($classMetadata, $data);

        return true;
    }

    /**
     * @param string $class
     *
     * @return mixed[]|null
     */
    abstract protected function loadData($class);

    /**
     * @param ClassMetadataInterface $classMetadata
     * @param mixed[]                $data
     *
     * @return bool
     */
    private function doLoadClassMetadata(ClassMetadataInterface $classMetadata, array $data)
    {
        if (!isset($data['properties']) || empty($data['properties'])) {
            throw new \InvalidArgumentException(sprintf(
                'No mapping properties found for "%s".',
                $classMetadata->getName()
            ));
        }

        $policy = $this->getExclusionPolicy($data);

        foreach ($data['properties'] as $property => $value) {
            $propertyMetadata = $classMetadata->getProperty($property) ?: new PropertyMetadata($property);
            $this->loadPropertyMetadata($propertyMetadata, $value);

            if ($this->isPropertyMetadataExposed($value, $policy)) {
                $classMetadata->addProperty($propertyMetadata);
            }
        }
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param mixed                     $data
     */
    private function loadPropertyMetadata(PropertyMetadataInterface $propertyMetadata, $data)
    {
        if (!is_array($data)) {
            return;
        }

        if (array_key_exists('exclude', $data)) {
            $this->validatePropertyMetadataExclude($data['exclude']);
        }

        if (array_key_exists('expose', $data)) {
            $this->validatePropertyMetadataExpose($data['expose']);
        }

        if (array_key_exists('alias', $data)) {
            $this->loadPropertyMetadataAlias($propertyMetadata, $data['alias']);
        }

        if (array_key_exists('type', $data)) {
            $this->loadPropertyMetadataType($propertyMetadata, $data['type']);
        }

        if (array_key_exists('since', $data)) {
            $this->loadPropertyMetadataSinceVersion($propertyMetadata, $data['since']);
        }

        if (array_key_exists('until', $data)) {
            $this->loadPropertyMetadataUntilVersion($propertyMetadata, $data['until']);
        }

        if (array_key_exists('max_depth', $data)) {
            $this->loadPropertyMetadataMaxDepth($propertyMetadata, $data['max_depth']);
        }

        if (array_key_exists('groups', $data)) {
            $this->loadPropertyMetadataGroups($propertyMetadata, $data['groups']);
        }
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string                    $alias
     */
    private function loadPropertyMetadataAlias(PropertyMetadataInterface $propertyMetadata, $alias)

    {
        if (!is_string($alias)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property alias must be a non empty string, got "%s".',
                is_object($alias) ? get_class($alias) : gettype($alias)
            ));
        }

        $alias = trim($alias);

        if (empty($alias)) {
            throw new \InvalidArgumentException('The mapping property alias must be a non empty string.');
        }

        $propertyMetadata->setAlias($alias);
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string                    $type
     */
    private function loadPropertyMetadataType(PropertyMetadataInterface $propertyMetadata, $type)
    {
        if (!is_string($type)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property type must be a non empty string, got "%s".',
                is_object($type) ? get_class($type) : gettype($type)
            ));
        }

        $propertyMetadata->setType($this->typeParser->parse($type));
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string                    $version
     */
    private function loadPropertyMetadataSinceVersion(PropertyMetadataInterface $propertyMetadata, $version)

    {
        if (!is_string($version)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property since version must be a non empty string, got "%s".',
                is_object($version) ? get_class($version) : gettype($version)
            ));
        }

        $version = trim($version);

        if (empty($version)) {
            throw new \InvalidArgumentException('The mapping property since version must be a non empty string.');
        }

        $propertyMetadata->setSinceVersion($version);
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string                    $version
     */
    private function loadPropertyMetadataUntilVersion(PropertyMetadataInterface $propertyMetadata, $version)

    {
        if (!is_string($version)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property until version must be a non empty string, got "%s".',
                is_object($version) ? get_class($version) : gettype($version)
            ));
        }

        $version = trim($version);

        if (empty($version)) {
            throw new \InvalidArgumentException('The mapping property until version must be a non empty string.');
        }

        $propertyMetadata->setUntilVersion($version);
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string|int                $maxDepth
     */
    private function loadPropertyMetadataMaxDepth(PropertyMetadataInterface $propertyMetadata, $maxDepth)
    {
        if (!is_int($maxDepth) && !is_string($maxDepth) && !ctype_digit($maxDepth)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property max depth must be a positive integer, got "%s".',
                is_object($maxDepth) ? get_class($maxDepth) : gettype($maxDepth)
            ));
        }

        $maxDepth = (int) $maxDepth;

        if ($maxDepth <= 0) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property max depth must be a positive integer, got "%d".',
                $maxDepth
            ));
        }

        $propertyMetadata->setMaxDepth($maxDepth);
    }

    /**
     * @param PropertyMetadataInterface $propertyMetadata
     * @param string[]                  $groups
     */
    private function loadPropertyMetadataGroups(PropertyMetadataInterface $propertyMetadata, $groups)
    {
        if (!is_array($groups)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property groups must be an array of non empty strings, got "%s".',
                is_object($groups) ? get_class($groups) : gettype($groups)
            ));
        }

        foreach ($groups as $group) {
            if (!is_string($group)) {
                throw new \InvalidArgumentException(sprintf(
                    'The mapping property groups must be an array of non empty strings, got "%s".',
                    is_object($group) ? get_class($group) : gettype($group)
                ));
            }

            $group = trim($group);

            if (empty($group)) {
                throw new \InvalidArgumentException(
                    'The mapping property groups must be an array of non empty strings.'
                );
            }

            $propertyMetadata->addGroup($group);
        }
    }

    /**
     * @param mixed[] $data
     *
     * @return string|null
     */
    private function getExclusionPolicy($data)
    {
        if (!isset($data['exclusion_policy'])) {
            return ExclusionPolicy::NONE;
        }

        $policy = $data['exclusion_policy'];

        if (!is_string($policy)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping exclusion policy must be "%s" or "%s", got "%s".',
                ExclusionPolicy::ALL,
                ExclusionPolicy::NONE,
                is_object($policy) ? get_class($policy) : gettype($policy)
            ));
        }

        $policy = strtolower(trim($policy));

        if ($policy !== ExclusionPolicy::ALL && $policy !== ExclusionPolicy::NONE) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping exclusion policy must be "%s" or "%s", got "%s".',
                ExclusionPolicy::ALL,
                ExclusionPolicy::NONE,
                $policy
            ));
        }

        return $policy;
    }

    /**
     * @param bool $exclude
     */
    private function validatePropertyMetadataExclude($exclude)

    {
        if (!is_bool($exclude)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property exclude must be a boolean, got "%s".',
                is_object($exclude) ? get_class($exclude) : gettype($exclude)
            ));
        }
    }

    /**
     * @param bool $expose
     */
    private function validatePropertyMetadataExpose($expose)

    {
        if (!is_bool($expose)) {
            throw new \InvalidArgumentException(sprintf(
                'The mapping property expose must be a boolean, got "%s".',
                is_object($expose) ? get_class($expose) : gettype($expose)
            ));
        }
    }

    /**
     * @param mixed[] $property
     * @param string  $policy
     *
     * @return bool
     */
    private function isPropertyMetadataExposed($property, $policy)
    {
        $expose = isset($property['expose']) && $property['expose'];
        $exclude = isset($property['exclude']) && $property['exclude'];

        return ($policy === ExclusionPolicy::ALL && $expose) || ($policy === ExclusionPolicy::NONE && !$exclude);
    }
}


1		<?php
2
3		/*
4		* This file is part of the Ivory Serializer package.
5		*
6		* (c) Eric GELOEN <[email protected]>
7		*
8		* For the full copyright and license information, please read the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Ivory\Serializer\Mapping\Loader;
13
14		use Ivory\Serializer\Exclusion\ExclusionPolicy;
15		use Ivory\Serializer\Mapping\ClassMetadataInterface;
16		use Ivory\Serializer\Mapping\PropertyMetadata;
17		use Ivory\Serializer\Mapping\PropertyMetadataInterface;
18		use Ivory\Serializer\Type\Parser\TypeParser;
19		use Ivory\Serializer\Type\Parser\TypeParserInterface;
20
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		abstract class AbstractClassMetadataLoader implements ClassMetadataLoaderInterface
25		{
26		/**
27		* @var TypeParserInterface
28		*/
29		private $typeParser;
30
31		/**
32		* @var mixed[][]
33		*/
34		private $data = [];
35
36		/**
37		* @param TypeParserInterface\|null $typeParser
38		*/
39		public function __construct(TypeParserInterface $typeParser = null)
40		{
41		$this->typeParser = $typeParser ?: new TypeParser();
42		}
43
44		/**
45		* {@inheritdoc}
46		*/
47		public function loadClassMetadata(ClassMetadataInterface $classMetadata)
48		{
49		$class = $classMetadata->getName();
50
51		if (!array_key_exists($class, $this->data)) {
52		$this->data[$class] = $this->loadData($class);
53		}
54
55		if (!is_array($data = $this->data[$class])) {
56		return false;
57		}
58
59		$this->doLoadClassMetadata($classMetadata, $data);
60
61		return true;
62		}
63
64		/**
65		* @param string $class
66		*
67		* @return mixed[]\|null
68		*/
69		abstract protected function loadData($class);
70
71		/**
72		* @param ClassMetadataInterface $classMetadata
73		* @param mixed[] $data
74		*
75		* @return bool
76		*/
77		private function doLoadClassMetadata(ClassMetadataInterface $classMetadata, array $data)
78		{
79		if (!isset($data['properties']) \|\| empty($data['properties'])) {
80		throw new \InvalidArgumentException(sprintf(
81		'No mapping properties found for "%s".',
82		$classMetadata->getName()
83		));
84		}
85
86		$policy = $this->getExclusionPolicy($data);
87
88		foreach ($data['properties'] as $property => $value) {
89		$propertyMetadata = $classMetadata->getProperty($property) ?: new PropertyMetadata($property);
90		$this->loadPropertyMetadata($propertyMetadata, $value);
91
92		if ($this->isPropertyMetadataExposed($value, $policy)) {
93		$classMetadata->addProperty($propertyMetadata);
94		}
95		}
96		}
97
98		/**
99		* @param PropertyMetadataInterface $propertyMetadata
100		* @param mixed $data
101		*/
102		private function loadPropertyMetadata(PropertyMetadataInterface $propertyMetadata, $data)
103		{
104		if (!is_array($data)) {
105		return;
106		}
107
108		if (array_key_exists('exclude', $data)) {
109		$this->validatePropertyMetadataExclude($data['exclude']);
110		}
111
112		if (array_key_exists('expose', $data)) {
113		$this->validatePropertyMetadataExpose($data['expose']);
114		}
115
116		if (array_key_exists('alias', $data)) {
117		$this->loadPropertyMetadataAlias($propertyMetadata, $data['alias']);
118		}
119
120		if (array_key_exists('type', $data)) {
121		$this->loadPropertyMetadataType($propertyMetadata, $data['type']);
122		}
123
124		if (array_key_exists('since', $data)) {
125		$this->loadPropertyMetadataSinceVersion($propertyMetadata, $data['since']);
126		}
127
128		if (array_key_exists('until', $data)) {
129		$this->loadPropertyMetadataUntilVersion($propertyMetadata, $data['until']);
130		}
131
132		if (array_key_exists('max_depth', $data)) {
133		$this->loadPropertyMetadataMaxDepth($propertyMetadata, $data['max_depth']);
134		}
135
136		if (array_key_exists('groups', $data)) {
137		$this->loadPropertyMetadataGroups($propertyMetadata, $data['groups']);
138		}
139		}
140
141		/**
142		* @param PropertyMetadataInterface $propertyMetadata
143		* @param string $alias
144		*/
145	View Code Duplication	private function loadPropertyMetadataAlias(PropertyMetadataInterface $propertyMetadata, $alias)
		0 ignored issues – show Duplication introduced 2016-09-21 22:14 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
146		{
147		if (!is_string($alias)) {
148		throw new \InvalidArgumentException(sprintf(
149		'The mapping property alias must be a non empty string, got "%s".',
150		is_object($alias) ? get_class($alias) : gettype($alias)
151		));
152		}
153
154		$alias = trim($alias);
155
156		if (empty($alias)) {
157		throw new \InvalidArgumentException('The mapping property alias must be a non empty string.');
158		}
159
160		$propertyMetadata->setAlias($alias);
161		}
162
163		/**
164		* @param PropertyMetadataInterface $propertyMetadata
165		* @param string $type
166		*/
167		private function loadPropertyMetadataType(PropertyMetadataInterface $propertyMetadata, $type)
168		{
169		if (!is_string($type)) {
170		throw new \InvalidArgumentException(sprintf(
171		'The mapping property type must be a non empty string, got "%s".',
172		is_object($type) ? get_class($type) : gettype($type)
173		));
174		}
175
176		$propertyMetadata->setType($this->typeParser->parse($type));
177		}
178
179		/**
180		* @param PropertyMetadataInterface $propertyMetadata
181		* @param string $version
182		*/
183	View Code Duplication	private function loadPropertyMetadataSinceVersion(PropertyMetadataInterface $propertyMetadata, $version)
		0 ignored issues – show Duplication introduced 2016-09-21 00:53 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
184		{
185		if (!is_string($version)) {
186		throw new \InvalidArgumentException(sprintf(
187		'The mapping property since version must be a non empty string, got "%s".',
188		is_object($version) ? get_class($version) : gettype($version)
189		));
190		}
191
192		$version = trim($version);
193
194		if (empty($version)) {
195		throw new \InvalidArgumentException('The mapping property since version must be a non empty string.');
196		}
197
198		$propertyMetadata->setSinceVersion($version);
199		}
200
201		/**
202		* @param PropertyMetadataInterface $propertyMetadata
203		* @param string $version
204		*/
205	View Code Duplication	private function loadPropertyMetadataUntilVersion(PropertyMetadataInterface $propertyMetadata, $version)
		0 ignored issues – show Duplication introduced 2016-09-21 00:53 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
206		{
207		if (!is_string($version)) {
208		throw new \InvalidArgumentException(sprintf(
209		'The mapping property until version must be a non empty string, got "%s".',
210		is_object($version) ? get_class($version) : gettype($version)
211		));
212		}
213
214		$version = trim($version);
215
216		if (empty($version)) {
217		throw new \InvalidArgumentException('The mapping property until version must be a non empty string.');
218		}
219
220		$propertyMetadata->setUntilVersion($version);
221		}
222
223		/**
224		* @param PropertyMetadataInterface $propertyMetadata
225		* @param string\|int $maxDepth
226		*/
227		private function loadPropertyMetadataMaxDepth(PropertyMetadataInterface $propertyMetadata, $maxDepth)
228		{
229		if (!is_int($maxDepth) && !is_string($maxDepth) && !ctype_digit($maxDepth)) {
230		throw new \InvalidArgumentException(sprintf(
231		'The mapping property max depth must be a positive integer, got "%s".',
232		is_object($maxDepth) ? get_class($maxDepth) : gettype($maxDepth)
233		));
234		}
235
236		$maxDepth = (int) $maxDepth;
237
238		if ($maxDepth <= 0) {
239		throw new \InvalidArgumentException(sprintf(
240		'The mapping property max depth must be a positive integer, got "%d".',
241		$maxDepth
242		));
243		}
244
245		$propertyMetadata->setMaxDepth($maxDepth);
246		}
247
248		/**
249		* @param PropertyMetadataInterface $propertyMetadata
250		* @param string[] $groups
251		*/
252		private function loadPropertyMetadataGroups(PropertyMetadataInterface $propertyMetadata, $groups)
253		{
254		if (!is_array($groups)) {
255		throw new \InvalidArgumentException(sprintf(
256		'The mapping property groups must be an array of non empty strings, got "%s".',
257		is_object($groups) ? get_class($groups) : gettype($groups)
258		));
259		}
260
261		foreach ($groups as $group) {
262		if (!is_string($group)) {
263		throw new \InvalidArgumentException(sprintf(
264		'The mapping property groups must be an array of non empty strings, got "%s".',
265		is_object($group) ? get_class($group) : gettype($group)
266		));
267		}
268
269		$group = trim($group);
270
271		if (empty($group)) {
272		throw new \InvalidArgumentException(
273		'The mapping property groups must be an array of non empty strings.'
274		);
275		}
276
277		$propertyMetadata->addGroup($group);
278		}
279		}
280
281		/**
282		* @param mixed[] $data
283		*
284		* @return string\|null
285		*/
286		private function getExclusionPolicy($data)
287		{
288		if (!isset($data['exclusion_policy'])) {
289		return ExclusionPolicy::NONE;
290		}
291
292		$policy = $data['exclusion_policy'];
293
294		if (!is_string($policy)) {
295		throw new \InvalidArgumentException(sprintf(
296		'The mapping exclusion policy must be "%s" or "%s", got "%s".',
297		ExclusionPolicy::ALL,
298		ExclusionPolicy::NONE,
299		is_object($policy) ? get_class($policy) : gettype($policy)
300		));
301		}
302
303		$policy = strtolower(trim($policy));
304
305		if ($policy !== ExclusionPolicy::ALL && $policy !== ExclusionPolicy::NONE) {
306		throw new \InvalidArgumentException(sprintf(
307		'The mapping exclusion policy must be "%s" or "%s", got "%s".',
308		ExclusionPolicy::ALL,
309		ExclusionPolicy::NONE,
310		$policy
311		));
312		}
313
314		return $policy;
315		}
316
317		/**
318		* @param bool $exclude
319		*/
320	View Code Duplication	private function validatePropertyMetadataExclude($exclude)
		0 ignored issues – show Duplication introduced 2016-09-22 22:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
321		{
322		if (!is_bool($exclude)) {
323		throw new \InvalidArgumentException(sprintf(
324		'The mapping property exclude must be a boolean, got "%s".',
325		is_object($exclude) ? get_class($exclude) : gettype($exclude)
326		));
327		}
328		}
329
330		/**
331		* @param bool $expose
332		*/
333	View Code Duplication	private function validatePropertyMetadataExpose($expose)
		0 ignored issues – show Duplication introduced 2016-09-22 22:05 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
334		{
335		if (!is_bool($expose)) {
336		throw new \InvalidArgumentException(sprintf(
337		'The mapping property expose must be a boolean, got "%s".',
338		is_object($expose) ? get_class($expose) : gettype($expose)
339		));
340		}
341		}
342
343		/**
344		* @param mixed[] $property
345		* @param string $policy
346		*
347		* @return bool
348		*/
349		private function isPropertyMetadataExposed($property, $policy)
350		{
351		$expose = isset($property['expose']) && $property['expose'];
352		$exclude = isset($property['exclude']) && $property['exclude'];
353
354		return ($policy === ExclusionPolicy::ALL && $expose) \|\| ($policy === ExclusionPolicy::NONE && !$exclude);
355		}
356		}
357

egeloen / ivory-serializer