PhUml\Code\Variables\TypeDeclaration

Complexity

Total Complexity

16

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	fromNullable()	0	3	1
A	removeArraySuffix()	0	3	1
A	isBuiltInArray()	0	3	1
A	isArray()	0	3	1
A	from()	0	3	1
A	__toString()	0	3	2
A	__construct()	0	4	3
A	isPresent()	0	3	1
A	isNullable()	0	3	1
A	isBuiltIn()	0	7	3
A	absent()	0	3	1

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

namespace PhUml\Code\Variables;

use PhUml\Code\Name;
use PhUml\Code\Named;
use PhUml\Code\WithName;

/**
 * It represents a variable's type declaration
 */
final class TypeDeclaration implements Named
{
    use WithName;

    /** @var string[] All valid types for PHP 7.1, pseudo-types, and aliases */
    private static array $builtInTypes = [
        'int', 'bool', 'string', 'array', 'float', 'callable', 'iterable',
        // pseudo-types
        'mixed', 'number', 'object', 'resource', 'self',
        // aliases
        'boolean', 'integer', 'double',
    ];

    private bool $isNullable;

    public static function absent(): TypeDeclaration
    {
        return new TypeDeclaration(null);
    }

    public static function from(?string $type): TypeDeclaration
    {
        return new TypeDeclaration($type);
    }

    public static function fromNullable(string $type): TypeDeclaration
    {
        return new TypeDeclaration($type, true);
    }

    public function isPresent(): bool
    {
        return $this->name !== null;
    }

    /**
     * It helps building the relationships between classes/interfaces since built-in
     * types are not part of a UML class diagram
     *
     * @see \PhUml\Code\Variables\WithTypeDeclaration::isAReference() for more details
     */
    public function isBuiltIn(): bool
    {
        $type = (string) $this->name;
        if ($this->isArray()) {
            $type = $this->removeArraySuffix();
        }
        return $this->isPresent() && \in_array($type, self::$builtInTypes, true);
    }

    public function isBuiltInArray(): bool
    {
        return (string) $this->name === 'array';
    }

    public function isArray(): bool
    {
        return strpos((string) $this->name, '[]') === \strlen((string) $this->name) - 2;
    }

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

    public function removeArraySuffix(): string
    {
        return substr((string) $this->name, 0, -2);
    }

    public function __toString()
    {
        return ($this->isNullable ? '?' : '') . $this->name;
    }

    private function __construct(?string $name, bool $isNullable = false)
    {
        $this->name = $name !== null ? new Name($name) : null;
        $this->isNullable = $name !== null && $isNullable;
    }
}