Larapie\DataTransferObject\Resolvers\PropertyTypeResolver

Complexity

Total Complexity

13

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

92.31%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	resolvePossibleParentType()	0	7	4
A	resolve()	0	38	5
A	getParentType()	0	11	3
A	__construct()	0	4	1

<?php

namespace Larapie\DataTransferObject\Resolvers;

use Throwable;
use ReflectionProperty;
use Larapie\DataTransferObject\Annotations\Inherit;
use Larapie\DataTransferObject\Property\PropertyType;
use Larapie\DataTransferObject\Exceptions\ConstraintInheritanceException;

class PropertyTypeResolver
{
    /**
     * @var ReflectionProperty
     */
    protected $reflection;

    /**
     * @var array
     */
    protected $annotations;

    /**
     * TypeResolver constructor.
     * @param ReflectionProperty $reflection
     * @param array $annotations
     */
    final public function __construct(ReflectionProperty $reflection, array $annotations)
    {
        $this->reflection = $reflection;
        $this->annotations = $annotations;
    }

    /**
     * @return PropertyType
     */
    public function resolve(): PropertyType
    {
        $type = new PropertyType();

        $docComment = $this->reflection->getDocComment();

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

            if (($parentType = $this->resolvePossibleParentType()) !== null) {
                return $parentType;
            }

            return $type;
        }

        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)) {
            $type->setNullable(true);

            if (($parentType = $this->resolvePossibleParentType()) !== null) {
                return $parentType;
            }

            return $type;
        }

        $varDocComment = end($matches);

        $resolver = new VarTypeResolver($this->reflection);
        $types = $resolver->resolve($varDocComment);
        $type->setTypes($types);
        $type->setArrayTypes(str_replace('[]', '', $types));
        $type->setInitialized(true);
        $type->setNullable(strpos($varDocComment, 'null') !== false);

        return $type;
    }

    protected function resolvePossibleParentType()
    {
        foreach ($this->annotations as $annotation) {
            if ($annotation instanceof Inherit) {
                $type = $this->getParentType();
                if ($type->isInitialized()) {
                    return $type;
                }
            }
        }
    }

    protected function getParentType(): PropertyType
    {
        try {
            if ($parentClass = $this->reflection->getDeclaringClass()->getParentClass()) {
                $parentProperty = $parentClass->getProperty($this->reflection->getName());
            }
        } catch (Throwable $exception) {
            throw new ConstraintInheritanceException('There is no parent property to inherit from');
        }

        return (new static($parentProperty, (new AnnotationResolver($parentProperty))->resolve()))->resolve();

The variable $parentProperty does not seem to be defined for all execution paths leading up to this point.

    }
}