Spatie\Typed\Types\CompoundType

Complexity

Total Complexity

16

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	21	4
A	getAvailableTypesString()	0	5	1
A	copyValue()	0	7	2
A	__construct()	0	3	1
A	__toString()	0	3	1
B	sameType()	0	15	7

<?php

declare(strict_types=1);

namespace Spatie\Typed\Types;

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

class CompoundType implements Type
{
    use Nullable;

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

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

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

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

            try {
                $currentValue = ($type)($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 'compound';
    }

    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));
    }
}