AbstractClassMetadataLoader::validatePropertyMetadataExclude() - Code Metrics - Inspection of "[Mapping] Add order properies support" - egeloen/ivory-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d8a83b...76c960 )

by Eric

created 2016-09-23 19:07 UTC

validatePropertyMetadataExclude() A

↳ Parent: AbstractClassMetadataLoader

Complexity

Conditions	3
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	9
Ratio	100 %

Importance

Changes

Metric	Value
dl	9
loc	9
rs	9.6666
c	0
b	0
f	0
cc	3
eloc	5
nc	2
nop	1

<?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
     */
    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()
            ));
        }

        $properties = $classMetadata->getProperties();
        $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)) {
                $properties[$property] = $propertyMetadata;
            }
        }

        if (($order = $this->getOrder($data, $properties)) !== null) {
            $properties = $this->sortProperties($properties, $order);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }

        $classMetadata->setProperties($properties);
    }

    /**
     * @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(array $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 mixed[]                     $data
     * @param PropertyMetadataInterface[] $properties
     *
     * @return string|string[]|null
     */
    private function getOrder(array $data, array $properties)
    {
        if (!isset($data['order'])) {
            return;
        }

        $order = $data['order'];

        if (is_string($order)) {
            $order = trim($order);

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

            if (strcasecmp($order, 'ASC') === 0 || strcasecmp($order, 'DESC') === 0) {
                return strtoupper($order);
            }

            $order = explode(',', $order);
        } elseif (!is_array($order)) {
            throw new \InvalidArgumentException(
                'The mapping order must be an non empty strings or an array of non empty strings.'
            );
        }

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

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

            $property = trim($property);

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

            if (!isset($properties[$property])) {
                throw new \InvalidArgumentException(sprintf(
                    'The property "%s" defined in the mapping order does not exist.',
                    $property
                ));
            }
        }

        return $order;
    }

    /**
     * @param PropertyMetadataInterface[] $properties
     * @param string|string[]             $order
     *
     * @return PropertyMetadataInterface[]
     */
    private function sortProperties(array $properties, $order)
    {
        if (is_string($order)) {
            if ($order === 'ASC') {
                ksort($properties);
            } else {
                krsort($properties);
            }
        } elseif (is_array($order)) {
            $properties = array_merge(array_flip($order), $properties);
        }

        return $properties;
    }

    /**
     * @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		private function doLoadClassMetadata(ClassMetadataInterface $classMetadata, array $data)
76		{
77		if (!isset($data['properties']) \|\| empty($data['properties'])) {
78		throw new \InvalidArgumentException(sprintf(
79		'No mapping properties found for "%s".',
80		$classMetadata->getName()
81		));
82		}
83
84		$properties = $classMetadata->getProperties();
85		$policy = $this->getExclusionPolicy($data);
86
87		foreach ($data['properties'] as $property => $value) {
88		$propertyMetadata = $classMetadata->getProperty($property) ?: new PropertyMetadata($property);
89		$this->loadPropertyMetadata($propertyMetadata, $value);
90
91		if ($this->isPropertyMetadataExposed($value, $policy)) {
92		$properties[$property] = $propertyMetadata;
93		}
94		}
95
96		if (($order = $this->getOrder($data, $properties)) !== null) {
97		$properties = $this->sortProperties($properties, $order);
		0 ignored issues – show Bug introduced 2016-09-23 19:10 UTC by Report Bug Copy Issue Report It seems like `$order` defined by `$this->getOrder($data, $properties)` on line `96` can also be of type `array`; however, `Ivory\Serializer\Mapping...oader::sortProperties()` does only seem to accept `string\|array<integer,string>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
98		}
99
100		$classMetadata->setProperties($properties);
101		}
102
103		/**
104		* @param PropertyMetadataInterface $propertyMetadata
105		* @param mixed $data
106		*/
107		private function loadPropertyMetadata(PropertyMetadataInterface $propertyMetadata, $data)
108		{
109		if (!is_array($data)) {
110		return;
111		}
112
113		if (array_key_exists('exclude', $data)) {
114		$this->validatePropertyMetadataExclude($data['exclude']);
115		}
116
117		if (array_key_exists('expose', $data)) {
118		$this->validatePropertyMetadataExpose($data['expose']);
119		}
120
121		if (array_key_exists('alias', $data)) {
122		$this->loadPropertyMetadataAlias($propertyMetadata, $data['alias']);
123		}
124
125		if (array_key_exists('type', $data)) {
126		$this->loadPropertyMetadataType($propertyMetadata, $data['type']);
127		}
128
129		if (array_key_exists('since', $data)) {
130		$this->loadPropertyMetadataSinceVersion($propertyMetadata, $data['since']);
131		}
132
133		if (array_key_exists('until', $data)) {
134		$this->loadPropertyMetadataUntilVersion($propertyMetadata, $data['until']);
135		}
136
137		if (array_key_exists('max_depth', $data)) {
138		$this->loadPropertyMetadataMaxDepth($propertyMetadata, $data['max_depth']);
139		}
140
141		if (array_key_exists('groups', $data)) {
142		$this->loadPropertyMetadataGroups($propertyMetadata, $data['groups']);
143		}
144		}
145
146		/**
147		* @param PropertyMetadataInterface $propertyMetadata
148		* @param string $alias
149		*/
150	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...
151		{
152		if (!is_string($alias)) {
153		throw new \InvalidArgumentException(sprintf(
154		'The mapping property alias must be a non empty string, got "%s".',
155		is_object($alias) ? get_class($alias) : gettype($alias)
156		));
157		}
158
159		$alias = trim($alias);
160
161		if (empty($alias)) {
162		throw new \InvalidArgumentException('The mapping property alias must be a non empty string.');
163		}
164
165		$propertyMetadata->setAlias($alias);
166		}
167
168		/**
169		* @param PropertyMetadataInterface $propertyMetadata
170		* @param string $type
171		*/
172		private function loadPropertyMetadataType(PropertyMetadataInterface $propertyMetadata, $type)
173		{
174		if (!is_string($type)) {
175		throw new \InvalidArgumentException(sprintf(
176		'The mapping property type must be a non empty string, got "%s".',
177		is_object($type) ? get_class($type) : gettype($type)
178		));
179		}
180
181		$propertyMetadata->setType($this->typeParser->parse($type));
182		}
183
184		/**
185		* @param PropertyMetadataInterface $propertyMetadata
186		* @param string $version
187		*/
188	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...
189		{
190		if (!is_string($version)) {
191		throw new \InvalidArgumentException(sprintf(
192		'The mapping property since version must be a non empty string, got "%s".',
193		is_object($version) ? get_class($version) : gettype($version)
194		));
195		}
196
197		$version = trim($version);
198
199		if (empty($version)) {
200		throw new \InvalidArgumentException('The mapping property since version must be a non empty string.');
201		}
202
203		$propertyMetadata->setSinceVersion($version);
204		}
205
206		/**
207		* @param PropertyMetadataInterface $propertyMetadata
208		* @param string $version
209		*/
210	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...
211		{
212		if (!is_string($version)) {
213		throw new \InvalidArgumentException(sprintf(
214		'The mapping property until version must be a non empty string, got "%s".',
215		is_object($version) ? get_class($version) : gettype($version)
216		));
217		}
218
219		$version = trim($version);
220
221		if (empty($version)) {
222		throw new \InvalidArgumentException('The mapping property until version must be a non empty string.');
223		}
224
225		$propertyMetadata->setUntilVersion($version);
226		}
227
228		/**
229		* @param PropertyMetadataInterface $propertyMetadata
230		* @param string\|int $maxDepth
231		*/
232		private function loadPropertyMetadataMaxDepth(PropertyMetadataInterface $propertyMetadata, $maxDepth)
233		{
234		if (!is_int($maxDepth) && !is_string($maxDepth) && !ctype_digit($maxDepth)) {
235		throw new \InvalidArgumentException(sprintf(
236		'The mapping property max depth must be a positive integer, got "%s".',
237		is_object($maxDepth) ? get_class($maxDepth) : gettype($maxDepth)
238		));
239		}
240
241		$maxDepth = (int) $maxDepth;
242
243		if ($maxDepth <= 0) {
244		throw new \InvalidArgumentException(sprintf(
245		'The mapping property max depth must be a positive integer, got "%d".',
246		$maxDepth
247		));
248		}
249
250		$propertyMetadata->setMaxDepth($maxDepth);
251		}
252
253		/**
254		* @param PropertyMetadataInterface $propertyMetadata
255		* @param string[] $groups
256		*/
257		private function loadPropertyMetadataGroups(PropertyMetadataInterface $propertyMetadata, $groups)
258		{
259		if (!is_array($groups)) {
260		throw new \InvalidArgumentException(sprintf(
261		'The mapping property groups must be an array of non empty strings, got "%s".',
262		is_object($groups) ? get_class($groups) : gettype($groups)
263		));
264		}
265
266		foreach ($groups as $group) {
267		if (!is_string($group)) {
268		throw new \InvalidArgumentException(sprintf(
269		'The mapping property groups must be an array of non empty strings, got "%s".',
270		is_object($group) ? get_class($group) : gettype($group)
271		));
272		}
273
274		$group = trim($group);
275
276		if (empty($group)) {
277		throw new \InvalidArgumentException(
278		'The mapping property groups must be an array of non empty strings.'
279		);
280		}
281
282		$propertyMetadata->addGroup($group);
283		}
284		}
285
286		/**
287		* @param mixed[] $data
288		*
289		* @return string\|null
290		*/
291		private function getExclusionPolicy(array $data)
292		{
293		if (!isset($data['exclusion_policy'])) {
294		return ExclusionPolicy::NONE;
295		}
296
297		$policy = $data['exclusion_policy'];
298
299		if (!is_string($policy)) {
300		throw new \InvalidArgumentException(sprintf(
301		'The mapping exclusion policy must be "%s" or "%s", got "%s".',
302		ExclusionPolicy::ALL,
303		ExclusionPolicy::NONE,
304		is_object($policy) ? get_class($policy) : gettype($policy)
305		));
306		}
307
308		$policy = strtolower(trim($policy));
309
310		if ($policy !== ExclusionPolicy::ALL && $policy !== ExclusionPolicy::NONE) {
311		throw new \InvalidArgumentException(sprintf(
312		'The mapping exclusion policy must be "%s" or "%s", got "%s".',
313		ExclusionPolicy::ALL,
314		ExclusionPolicy::NONE,
315		$policy
316		));
317		}
318
319		return $policy;
320		}
321
322		/**
323		* @param mixed[] $data
324		* @param PropertyMetadataInterface[] $properties
325		*
326		* @return string\|string[]\|null
327		*/
328		private function getOrder(array $data, array $properties)
329		{
330		if (!isset($data['order'])) {
331		return;
332		}
333
334		$order = $data['order'];
335
336		if (is_string($order)) {
337		$order = trim($order);
338
339		if (empty($order)) {
340		throw new \InvalidArgumentException(
341		'The mapping order must be an non empty strings or an array of non empty strings.'
342		);
343		}
344
345		if (strcasecmp($order, 'ASC') === 0 \|\| strcasecmp($order, 'DESC') === 0) {
346		return strtoupper($order);
347		}
348
349		$order = explode(',', $order);
350		} elseif (!is_array($order)) {
351		throw new \InvalidArgumentException(
352		'The mapping order must be an non empty strings or an array of non empty strings.'
353		);
354		}
355
356		if (empty($order)) {
357		throw new \InvalidArgumentException(
358		'The mapping order must be an non empty strings or an array of non empty strings.'
359		);
360		}
361
362		foreach ($order as &$property) {
363		if (!is_string($property)) {
364		throw new \InvalidArgumentException(sprintf(
365		'The mapping order must be an non empty strings or an array of non empty strings, got "%s".',
366		is_object($property) ? get_class($property) : gettype($property)
367		));
368		}
369
370		$property = trim($property);
371
372		if (empty($property)) {
373		throw new \InvalidArgumentException(
374		'The mapping order must be an non empty strings or an array of non empty strings.'
375		);
376		}
377
378		if (!isset($properties[$property])) {
379		throw new \InvalidArgumentException(sprintf(
380		'The property "%s" defined in the mapping order does not exist.',
381		$property
382		));
383		}
384		}
385
386		return $order;
387		}
388
389		/**
390		* @param PropertyMetadataInterface[] $properties
391		* @param string\|string[] $order
392		*
393		* @return PropertyMetadataInterface[]
394		*/
395		private function sortProperties(array $properties, $order)
396		{
397		if (is_string($order)) {
398		if ($order === 'ASC') {
399		ksort($properties);
400		} else {
401		krsort($properties);
402		}
403		} elseif (is_array($order)) {
404		$properties = array_merge(array_flip($order), $properties);
405		}
406
407		return $properties;
408		}
409
410		/**
411		* @param bool $exclude
412		*/
413	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...
414		{
415		if (!is_bool($exclude)) {
416		throw new \InvalidArgumentException(sprintf(
417		'The mapping property exclude must be a boolean, got "%s".',
418		is_object($exclude) ? get_class($exclude) : gettype($exclude)
419		));
420		}
421		}
422
423		/**
424		* @param bool $expose
425		*/
426	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...
427		{
428		if (!is_bool($expose)) {
429		throw new \InvalidArgumentException(sprintf(
430		'The mapping property expose must be a boolean, got "%s".',
431		is_object($expose) ? get_class($expose) : gettype($expose)
432		));
433		}
434		}
435
436		/**
437		* @param mixed[] $property
438		* @param string $policy
439		*
440		* @return bool
441		*/
442		private function isPropertyMetadataExposed($property, $policy)
443		{
444		$expose = isset($property['expose']) && $property['expose'];
445		$exclude = isset($property['exclude']) && $property['exclude'];
446
447		return ($policy === ExclusionPolicy::ALL && $expose) \|\| ($policy === ExclusionPolicy::NONE && !$exclude);
448		}
449		}
450

egeloen / ivory-serializer

Push — master ( d8a83b...76c960 )

validatePropertyMetadataExclude() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like