SchemaValidator\Validator\UuidValidator

Complexity

Total Complexity

11

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Test Coverage

Coverage

96.3%

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	validate()	0	26	3
B	support()	0	15	7
A	__construct()	0	4	1

<?php
/**
 * Schema Validator
 *
 * @author Vlad Shashkov <root@myaza.info>
 * @copyright Copyright (c) 2021, The Myaza Software
 */

declare(strict_types=1);

namespace SchemaValidator\Validator;

use Ramsey\Uuid\UuidInterface;
use SchemaValidator\Argument;
use SchemaValidator\Context;
use function SchemaValidator\findUuidVersion;
use Symfony\Component\Uid\AbstractUid;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\Constraints\Uuid as SymfonyUuidConstraint;
use Symfony\Component\Validator\Util\PropertyPath;
use Symfony\Component\Validator\Validator\ValidatorInterface as SymfonyValidator;

final class UuidValidator implements ValidatorInterface
{
    private const INVALID_UUID_VERSION = 'This is not a valid UUID. Allowed Versions: %s';
    private const UUID_TYPES           = [
        UuidInterface::class,
        AbstractUid::class,
    ];

    /**
     * UuidValidator constructor.
     *
     * @param array<class-string|string> $uuids

The doc comment array<class-string|string> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string|string>.

     */
    public function __construct(
        private SymfonyValidator $validator,
        private array $uuids = self::UUID_TYPES,
    ) {
    }

    public function support(\ReflectionType $type): bool
    {
        if (!$type instanceof \ReflectionNamedType || $type->isBuiltin()) {
            return false;
        }

        $typeName = $type->getName();

        foreach ($this->uuids as $uuid) {
            if ((interface_exists($uuid) || class_exists($uuid)) && is_subclass_of($typeName, $uuid)) {
                return true;
            }
        }

        return false;
    }

    public function validate(Argument $argument, Context $context): void
    {
        $type = $argument->getType();

        if (!$type instanceof \ReflectionNamedType) {
            throw new \InvalidArgumentException('Type expected:' . \ReflectionNamedType::class);
        }

        /** @var string $value */
        $value = $argument->getValueByArgumentName();
        /** @var class-string $uuid */
        $uuid      = $type->getName();
        $execution = $context->getExecution();
        $version   = findUuidVersion($uuid);
        $options   = ['strict' => $context->isStrictTypes()];

        if (null !== $version) {
            $options['versions'] = [$version];
            $options['message']  = sprintf(self::INVALID_UUID_VERSION, $version);
        }

        $this->validator->inContext($execution)
            ->atPath(PropertyPath::append($context->getRootPath(), $argument->getName()))
            ->validate($value, [
                new NotBlank(),
                new SymfonyUuidConstraint($options),
            ])
        ;
    }
}