UnionType::validate() - Code Metrics - Inspection of "Type hiearchy for property types and enums" - doctrine/annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#256)

by Michael

created 2019-03-14 16:49 UTC

UnionType::validate() A

↳ Parent: UnionType

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Type;

use Doctrine\Annotations\Type\Exception\CompositeTypeRequiresAtLeastTwoSubTypes;
use function array_map;
use function count;
use function implode;
use function sprintf;

/**
 * @internal
 */
final class UnionType implements CompositeType
{
    /** @var Type[] */
    private $subTypes;

    public function __construct(Type ...$subTypes)
    {
        if (count($subTypes) < 2) {
            throw CompositeTypeRequiresAtLeastTwoSubTypes::fromInsufficientAmount(count($subTypes));
        }

        $this->subTypes = $subTypes;
    }

    /**
     * @return Type[]
     */
    public function getSubTypes() : array
    {
        return $this->subTypes;
    }

    public function describe() : string
    {
        return implode(
            '|',
            array_map(
                static function (Type $subType) : string {
                    if ($subType instanceof CompositeType) {
                        return sprintf('(%s)', $subType->describe());
                    }

                    return $subType->describe();
                },
                $this->subTypes
            )
        );
    }

    /**
     * @param mixed $value
     */
    public function validate($value) : bool
    {
        foreach ($this->subTypes as $subType) {
            if (! $subType->validate($value)) {
                continue;
            }

            return true;
        }

        return false;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Annotations\Type;
6
7		use Doctrine\Annotations\Type\Exception\CompositeTypeRequiresAtLeastTwoSubTypes;
8		use function array_map;
9		use function count;
10		use function implode;
11		use function sprintf;
12
13		/**
14		* @internal
15		*/
16		final class UnionType implements CompositeType
17		{
18		/** @var Type[] */
19		private $subTypes;
20
21	31	public function __construct(Type ...$subTypes)
22		{
23	31	if (count($subTypes) < 2) {
24	1	throw CompositeTypeRequiresAtLeastTwoSubTypes::fromInsufficientAmount(count($subTypes));
25		}
26
27	31	$this->subTypes = $subTypes;
28	31	}
29
30		/**
31		* @return Type[]
32		*/
33	1	public function getSubTypes() : array
34		{
35	1	return $this->subTypes;
36		}
37
38	10	public function describe() : string
39		{
40	10	return implode(
41	10	'\|',
42	10	array_map(
43		static function (Type $subType) : string {
44	10	if ($subType instanceof CompositeType) {
45	2	return sprintf('(%s)', $subType->describe());
46		}
47
48	10	return $subType->describe();
49	10	},
50	10	$this->subTypes
51		)
52		);
53		}
54
55		/**
56		* @param mixed $value
57		*/
58	19	public function validate($value) : bool
59		{
60	19	foreach ($this->subTypes as $subType) {
61	19	if (! $subType->validate($value)) {
62	18	continue;
63		}
64
65	10	return true;
66		}
67
68	11	return false;
69		}
70		}
71

doctrine / annotations

Pull Request — master (#256)

UnionType::validate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like