PhUml\Parser\Code\Builders\Members\TypeBuilder

Complexity

Total Complexity

15

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	fromMethodReturnType()	0	18	4
A	fromCompositeType()	0	5	1
A	fromMethodParameter()	0	19	4
A	fromParsedType()	0	15	1
A	__construct()	0	2	1
A	fromPropertyType()	0	18	4

<?php declare(strict_types=1);
/**
 * This source file is subject to the license that is bundled with this package in the file LICENSE.
 */

namespace PhUml\Parser\Code\Builders\Members;

use PhpParser\Comment\Doc;

The type PhpParser\Comment\Doc was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\ComplexType;

The type PhpParser\Node\ComplexType was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\Identifier;

The type PhpParser\Node\Identifier was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\IntersectionType;

The type PhpParser\Node\IntersectionType was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\Name;

The type PhpParser\Node\Name was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\NullableType;

The type PhpParser\Node\NullableType was not found. Maybe you did not declare it correctly or list all dependencies?

use PhpParser\Node\UnionType;

The type PhpParser\Node\UnionType was not found. Maybe you did not declare it correctly or list all dependencies?

use PhUml\Code\UseStatements;
use PhUml\Code\Variables\CompositeType;

The type PhUml\Code\Variables\CompositeType was not found. Maybe you did not declare it correctly or list all dependencies?

use PhUml\Code\Variables\TypeDeclaration;
use PhUml\Parser\Code\TypeResolver;
use RuntimeException;

final class TypeBuilder
{
    public function __construct(private readonly TypeResolver $typeResolver)
    {
    }

    public function fromMethodParameter(
        Identifier|Name|ComplexType|null $type,
        ?Doc $docBlock,
        string $name,
        UseStatements $useStatements
    ): TypeDeclaration {
        $methodComment = $docBlock?->getText();
        if ($type === null) {
            return $this->typeResolver->resolveForParameter($methodComment, $name, $useStatements);
        }

        $typeDeclaration = $this->fromParsedType($type);
        if (! $typeDeclaration->isBuiltInArray()) {
            return $typeDeclaration;
        }

        $typeFromDocBlock = $this->typeResolver->resolveForParameter($methodComment, $name, $useStatements);

        return $typeFromDocBlock->isPresent() ? $typeFromDocBlock : $typeDeclaration;
    }

    public function fromMethodReturnType(
        Identifier|Name|ComplexType|null $type,
        ?Doc $docBlock,
        UseStatements $useStatements
    ): TypeDeclaration {
        $methodComment = $docBlock?->getText();
        if ($type === null) {
            return $this->typeResolver->resolveForReturn($methodComment, $useStatements);
        }

        $typeDeclaration = $this->fromParsedType($type);
        if (! $typeDeclaration->isBuiltInArray()) {
            return $typeDeclaration;
        }

        $typeFromDocBlock = $this->typeResolver->resolveForReturn($methodComment, $useStatements);

        return $typeFromDocBlock->isPresent() ? $typeFromDocBlock : $typeDeclaration;
    }

    public function fromPropertyType(
        Identifier|Name|ComplexType|null $type,
        ?Doc $docBlock,
        UseStatements $useStatements
    ): TypeDeclaration {
        $propertyComment = $docBlock?->getText();
        if ($type === null) {
            return $this->typeResolver->resolveForProperty($propertyComment, $useStatements);
        }

        $typeDeclaration = $this->fromParsedType($type);
        if (! $typeDeclaration->isBuiltInArray()) {
            return $typeDeclaration;
        }

        $typeFromDocBlock = $this->typeResolver->resolveForProperty($propertyComment, $useStatements);

        return $typeFromDocBlock->isPresent() ? $typeFromDocBlock : $typeDeclaration;
    }

    private function fromParsedType(Identifier|Name|ComplexType|null $type): TypeDeclaration
    {
        return match (true) {
            $type instanceof NullableType => TypeDeclaration::fromNullable((string) $type->type),
            $type instanceof Name, $type instanceof Identifier => TypeDeclaration::from((string) $type),
            $type === null => TypeDeclaration::absent(),
            $type instanceof UnionType => TypeDeclaration::fromCompositeType(
                $this->fromCompositeType($type),

It seems like $type can also be of type null; however, parameter $type of PhUml\Parser\Code\Builders\Members\TypeBuilder::fromCompositeType() does only seem to accept PhpParser\Node\IntersectionType|PhpParser\Node\UnionType, maybe add an additional type check?

                CompositeType::UNION
            ),
            $type instanceof IntersectionType => TypeDeclaration::fromCompositeType(
                $this->fromCompositeType($type),
                CompositeType::INTERSECTION
            ),
            default => throw new RuntimeException(sprintf('%s is not supported', $type::class)),
        };
    }

    /** @return string[] */
    private function fromCompositeType(UnionType|IntersectionType $type): array
    {
        return array_map(
            static fn (Identifier|Name $name): string => (string) $name,
            $type->types
        );
    }
}