UnionType::sameType() - Code Metrics - spatie/typed - Measure and Improve Code Quality continuously with Scrutinizer

UnionType::sameType() B
last analyzed 2020-10-12 09:07 UTC

↳ Parent: UnionType

Complexity

Conditions	7
Paths	4

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	7
nc	4
nop	3
dl	0
loc	15
rs	8.8333
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Spatie\Typed\Types;

use TypeError;
use Spatie\Typed\Type;
use Spatie\Typed\ValidatesType;
use Spatie\Typed\Excpetions\WrongType;

class UnionType implements Type
{
    use Nullable, ValidatesType;

    /** @var \Spatie\Typed\Type[] */
    private $types;

    public function __construct(Type ...$types)
    {
        $this->types = $types;
    }

    public function validate($value)
    {
        $initialValue = $this->copyValue($value);

        foreach ($this->types as $type) {
            $currentValue = $this->copyValue($initialValue);

            try {
                $currentValue = $type->validate($currentValue);
            } catch (TypeError $typeError) {
                continue;
            }

            if (! $this->sameType($initialValue, $currentValue, $type)) {
                continue;
            }

            return $initialValue;
        }

        throw WrongType::withMessage("Type must be either one of: {$this->getAvailableTypesString()}");
    }

    public function __toString(): string
    {
        return 'union';
    }

    private function copyValue($value)
    {
        if (is_object($value)) {
            return clone $value;
        }

        return $value;
    }

    private function sameType($currentValue, $initialValue, Type $type): bool
    {
        if ($type instanceof NullType && $initialValue === null) {
            return true;
        }

        if (is_scalar($initialValue) && $currentValue === $initialValue) {
            return true;
        }

        if (is_object($initialValue) && get_class($initialValue) === get_class($currentValue)) {
            return true;
        }

        return false;
    }

    private function getAvailableTypesString(): string
    {
        return implode(', ', array_map(function (Type $type) {
            return (string) $type;
        }, $this->types));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Spatie\Typed\Types;
6
7			use TypeError;
8			use Spatie\Typed\Type;
9			use Spatie\Typed\ValidatesType;
10			use Spatie\Typed\Excpetions\WrongType;
11
12			class UnionType implements Type
13			{
14			use Nullable, ValidatesType;
15
16			/** @var \Spatie\Typed\Type[] */
17			private $types;
18
19			public function __construct(Type ...$types)
20			{
21			$this->types = $types;
22			}
23
24			public function validate($value)
25			{
26			$initialValue = $this->copyValue($value);
27
28			foreach ($this->types as $type) {
29			$currentValue = $this->copyValue($initialValue);
30
31			try {
32			$currentValue = $type->validate($currentValue);
33			} catch (TypeError $typeError) {
34			continue;
35			}
36
37			if (! $this->sameType($initialValue, $currentValue, $type)) {
38			continue;
39			}
40
41			return $initialValue;
42			}
43
44			throw WrongType::withMessage("Type must be either one of: {$this->getAvailableTypesString()}");
45			}
46
47			public function __toString(): string
48			{
49			return 'union';
50			}
51
52			private function copyValue($value)
53			{
54			if (is_object($value)) {
55			return clone $value;
56			}
57
58			return $value;
59			}
60
61			private function sameType($currentValue, $initialValue, Type $type): bool
62			{
63			if ($type instanceof NullType && $initialValue === null) {
64			return true;
65			}
66
67			if (is_scalar($initialValue) && $currentValue === $initialValue) {
68			return true;
69			}
70
71			if (is_object($initialValue) && get_class($initialValue) === get_class($currentValue)) {
72			return true;
73			}
74
75			return false;
76			}
77
78			private function getAvailableTypesString(): string
79			{
80			return implode(', ', array_map(function (Type $type) {
81			return (string) $type;
82			}, $this->types));
83			}
84			}
85

spatie / typed

GitHub Access Token became invalid

UnionType::sameType() B last analyzed 2020-10-12 09:07 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

UnionType::sameType() B
last analyzed 2020-10-12 09:07 UTC