Larapie\DataTransferObject\Property

Complexity

Total Complexity

70

Size/Duplication

Total Lines	363
Duplicated Lines	0 %

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	setDefault()	0	3	1
A	getDefault()	0	3	1
A	__construct()	0	4	1
A	getReader()	0	7	2
A	setVisible()	0	3	1
A	isOptional()	0	7	2
A	validate()	0	15	5
A	getValueFromReflection()	0	3	1
A	cast()	0	19	4
A	shouldBeCastToCollection()	0	17	5
A	setImmutable()	0	3	1
A	isInitialized()	0	3	1
A	immutable()	0	7	2
A	nullable()	0	3	1
A	isValidGenericCollection()	0	15	4
A	getValue()	0	7	3
A	getAnnotation()	0	3	1
A	setInitialized()	0	3	1
A	setReader()	0	4	1
A	getTypes()	0	3	1
A	assertTypeEquals()	0	12	5
A	getFqn()	0	3	1
A	isValidType()	0	19	6
A	castCollection()	0	25	5
A	getName()	0	3	1
A	setAnnotations()	0	7	2
A	resolveTypeDefinition()	0	27	3
A	set()	0	13	4
A	setNullable()	0	3	1
A	isVisible()	0	3	1
A	setRequired()	0	3	1
A	setOptional()	0	3	1

<?php

declare(strict_types=1);

namespace Larapie\DataTransferObject;

use Larapie\DataTransferObject\Exceptions\ValidatorException;
use ReflectionProperty;
use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\AnnotationReader;
use Larapie\DataTransferObject\Annotations\Optional;
use Larapie\DataTransferObject\Annotations\Immutable;
use Larapie\DataTransferObject\Contracts\DtoContract;
use Larapie\DataTransferObject\Contracts\PropertyContract;
use Larapie\DataTransferObject\Exceptions\InvalidTypeDtoException;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ValidatorBuilder;

class Property implements PropertyContract
{
    /** @var array */
    protected const TYPE_MAPPING = [
        'int' => 'integer',
        'bool' => 'boolean',
        'float' => 'double',
    ];

    /** @var bool */
    protected $hasTypeDeclaration = false;

    /** @var bool */
    protected $nullable = false;

    /** @var bool */
    protected $optional;

    /** @var bool */
    protected $initialised = false;

    /** @var bool */
    protected $immutable;

    /** @var bool */
    protected $visible = true;

    /** @var array */
    protected $types = [];

    /** @var array */
    protected $arrayTypes = [];

    /** @var mixed */
    protected $default;

    /** @var mixed */
    public $value;

    /** @var ReflectionProperty */
    protected $reflection;

    /** @var array */
    protected $annotations = [];

    /** @var ?Reader */
    protected static $reader;

    public function __construct(ReflectionProperty $reflectionProperty)
    {
        $this->reflection = $reflectionProperty;
        $this->resolveTypeDefinition();
    }

    protected function resolveTypeDefinition()
    {
        $docComment = $this->reflection->getDocComment();

        if (!$docComment) {
            $this->setNullable(true);

            return;
        }

        preg_match('/\@var ((?:(?:[\w|\\\\])+(?:\[\])?)+)/', $docComment, $matches);

It seems like $docComment can also be of type true; however, parameter $subject of preg_match() does only seem to accept string, maybe add an additional type check?

        if (!count($matches)) {
            $this->setNullable(true);

            return;
        }

        $varDocComment = end($matches);

        $this->types = explode('|', $varDocComment);
        $this->arrayTypes = str_replace('[]', '', $this->types);
        $this->setAnnotations();

        $this->hasTypeDeclaration = true;

        $this->setNullable(strpos($varDocComment, 'null') !== false);
    }

    protected function isValidType($value): bool
    {
        if (!$this->hasTypeDeclaration) {
            return true;
        }

        if ($this->nullable() && $value === null) {
            return true;
        }

        foreach ($this->types as $currentType) {
            $isValidType = $this->assertTypeEquals($currentType, $value);

            if ($isValidType) {
                return true;
            }
        }

        return false;
    }

    protected function cast($value)
    {
        $castTo = null;

        foreach ($this->types as $type) {
            if (!is_subclass_of($type, DtoContract::class)) {
                continue;
            }

            $castTo = $type;

            break;
        }

        if (!$castTo) {
            return $value;
        }

        return new $castTo($value);
    }

    protected function castCollection(array $values)
    {
        $castTo = null;

        foreach ($this->arrayTypes as $type) {
            if (!is_subclass_of($type, DtoContract::class)) {
                continue;
            }

            $castTo = $type;

            break;
        }

        if (!$castTo) {
            return $values;
        }

        $casts = [];

        foreach ($values as $value) {
            $casts[] = new $castTo($value);
        }

        return $casts;
    }

    protected function shouldBeCastToCollection(array $values): bool
    {
        if (empty($values)) {
            return false;
        }

        foreach ($values as $key => $value) {
            if (is_string($key)) {
                return false;
            }

            if (!is_array($value)) {
                return false;
            }
        }

        return true;
    }

    protected function assertTypeEquals(string $type, $value): bool
    {
        if (strpos($type, '[]') !== false) {
            return $this->isValidGenericCollection($type, $value);
        }

        if ($type === 'mixed' && $value !== null) {
            return true;
        }

        return $value instanceof $type
            || gettype($value) === (self::TYPE_MAPPING[$type] ?? $type);
    }

    protected function isValidGenericCollection(string $type, $collection): bool
    {
        if (!is_array($collection)) {
            return false;
        }

        $valueType = str_replace('[]', '', $type);

        foreach ($collection as $value) {
            if (!$this->assertTypeEquals($valueType, $value)) {
                return false;
            }
        }

        return true;
    }

    public function set($value): void
    {
        if (is_array($value)) {
            $value = $this->shouldBeCastToCollection($value) ? $this->castCollection($value) : $this->cast($value);
        }

        if (!$this->isValidType($value)) {
            throw new InvalidTypeDtoException($this, $value);
        }

        $this->setInitialized(true);

        $this->value = $value;
    }

    public function setInitialized(bool $bool): void
    {
        $this->initialised = $bool;
    }

    public function isInitialized(): bool
    {
        return $this->initialised;
    }

    public function getTypes(): array
    {
        return $this->types;
    }

    public function getFqn(): string
    {
        return "{$this->reflection->getDeclaringClass()->getName()}::{$this->reflection->getName()}";
    }

    public function nullable(): bool
    {
        return $this->nullable;
    }

    public function setNullable(bool $bool): void
    {
        $this->nullable = $bool;
    }

    public function validate(): void
    {
        $constraints = [];
        foreach ($this->annotations as $annotation) {
            if ($annotation instanceof Constraint)
                $constraints[] = $annotation;
        }
        if (empty($constraints))
            return;
        $validator = new ValidatorBuilder();
        $violations = $validator->getValidator()->validate($this->getValue(), $constraints);

        if ($violations->count() > 0)
            throw new ValidatorException($this->getName(), $violations);
        return;
    }

    public function immutable(): bool
    {
        if (!isset($this->immutable)) {
            $this->immutable = $this->getAnnotation(Immutable::class) !== null;
        }

        return $this->immutable;
    }

    public function setImmutable(bool $immutable): void
    {
        $this->immutable = $immutable;
    }

    public function getDefault()
    {
        return $this->default;
    }

    public function setDefault($default): void
    {
        $this->default = $default;
    }

    public function isVisible(): bool
    {
        return $this->visible;
    }

    public function setVisible(bool $bool): bool
    {
        return $this->visible = $bool;
    }

    public function getValue()
    {
        if (!$this->nullable() && $this->value == null) {
            return $this->getDefault();
        }

        return $this->value;
    }

    public function getValueFromReflection($object)
    {
        return $this->reflection->getValue($object);
    }

    public function getName(): string
    {
        return $this->reflection->getName();
    }

    public function isOptional(): bool
    {
        if (!isset($this->optional)) {
            $this->optional = $this->getAnnotation(Optional::class) !== null;
        }

        return $this->optional;
    }

    public function setOptional(): bool
    {
        return $this->optional = true;
    }

    public function setRequired(): bool
    {
        return $this->optional = false;
    }

    protected function getReader(): Reader
    {
        if (self::$reader === null) {
            self::setReader(new CachedReader(new AnnotationReader(), new ArrayCache()));
        }

        return self::$reader;
    }

    public static function setReader(Reader $reader)
    {
        \Doctrine\Common\Annotations\AnnotationRegistry::registerUniqueLoader('class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerUniqueLoader() has been deprecated: this method is deprecated and will be removed in doctrine/annotations 2.0

        self::$reader = $reader;
    }

    protected function setAnnotations()
    {
        $annotations = [];
        foreach (self::getReader()->getPropertyAnnotations($this->reflection) as $annotation) {

The method Larapie\DataTransferObject\Property::getReader() is not static, but was called statically.

            $annotations[get_class($annotation)] = $annotation;
        }
        $this->annotations = $annotations;
    }

    protected function getAnnotation($annotation)
    {
        return $this->annotations[$annotation] ?? null;
    }
}