PhUml\Code\ClassDefinition

Complexity

Total Complexity

12

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

<?php declare(strict_types=1);
final class ClassDefinition extends Definition implements HasProperties, HasConstants, CanBeAbstract, UseTraits
{
    use WithProperties;
    use WithConstants;
    use WithTraits;

    /**
     * @param Method[] $methods
     * @param Constant[] $constants
     * @param Property[] $properties
     * @param Name[] $interfaces
     * @param Name[] $traits
     */
    public function __construct(
        Name $name,
        array $methods = [],
        array $constants = [],
        private readonly ?Name $parent = null,

A parse error occurred: Syntax error, unexpected '?', expecting T_VARIABLE on line 42 at column 25

        array $properties = [],
        private readonly array $interfaces = [],
        array $traits = [],
        private readonly bool $isAttribute = false
    ) {
        parent::__construct($name, $methods);
        $this->constants = $constants;
        $this->properties = $properties;
        $this->traits = $traits;
    }

    /**
     * This method is used by the `AssociationsBuilder` class to discover associations with other
     * classes via the constructor
     *
     * @return Parameter[]
     * @see \PhUml\Graphviz\Builders\AssociationsBuilder::fromProperties() for more details
     */
    public function constructorParameters(): array
    {
        $constructors = array_filter($this->methods, static fn (Method $method): bool => $method->isConstructor());
        $constructor = reset($constructors);

        return $constructor === false ? [] : $constructor->parameters();
    }

    /**
     * This method is used to build the `Summary` of a `Codebase`
     *
     * @see Summary::propertiesSummary() for more details
     */
    public function countPropertiesByVisibility(Visibility $modifier): int
    {
        return \count(array_filter(
            $this->properties,
            static fn (Property $property): bool => $property->hasVisibility($modifier)
        ));
    }

    /**
     * This method is used to build the `Summary` of a `Codebase`
     *
     * @see Summary::propertiesSummary() for more details
     */
    public function countTypedPropertiesByVisibility(Visibility $modifier): int
    {
        return \count(array_filter(
            $this->properties,
            static fn (Property $property): bool =>
                $property->hasTypeDeclaration() && $property->hasVisibility($modifier)
        ));
    }

    /**
     * It is used by the `ClassGraphBuilder` to create the edges to represent implementation
     * associations
     *
     * @return Name[]
     * @see \PhUml\Graphviz\Builders\ClassGraphBuilder::extractFrom() for more details
     */
    public function interfaces(): array
    {
        return $this->interfaces;
    }

    /**
     * It is used by the `ClassGraphBuilder` to create the edge to represent inheritance
     *
     * @see \PhUml\Graphviz\Builders\ClassGraphBuilder::extractFrom() for more details
     */
    public function parent(): Name
    {
        if ($this->parent === null) {
            throw new BadMethodCallException('This class does not have a parent class');
        }
        return $this->parent;
    }

    /**
     * It is used by the `ClassGraphBuilder` to determine if an inheritance association should be
     * created
     *
     * @see \PhUml\Graphviz\Builders\ClassGraphBuilder::extractFrom() for more details
     */
    public function hasParent(): bool
    {
        return $this->parent !== null;
    }

    /**
     * This method is used when the commands are called with the option `hide-empty-blocks`
     *
     * It counts both the properties and the constants of a class
     *
     * @see Definition::hasProperties() for more details
     */
    public function hasProperties(): bool
    {
        return \count($this->constants) + \count($this->properties) > 0;
    }

    /**
     * This method is used to determine if the class name should be shown in italics
     */
    public function isAbstract(): bool
    {
        return array_filter($this->methods(), static fn (Method $method): bool => $method->isAbstract()) !== [];
    }

    public function isAttribute(): bool
    {