Application\Traits\HasParent

Complexity

Total Complexity

16

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	assertNotCyclic()	0	14	4
A	setParent()	0	14	3
A	getChildren()	0	3	1
A	getAllChildren()	0	9	2
A	getParentHierarchy()	0	10	2
A	getParent()	0	3	1
A	getHierarchicName()	0	11	2
A	hasChildren()	0	3	1

<?php

declare(strict_types=1);

namespace Application\Traits;

use Doctrine\Common\Collections\Collection;
use InvalidArgumentException;

/**
 * Trait for all objects with a parent.
 *
 * ORM mapping must be defined in using class.
 */
trait HasParent
{
    private ?self $parent = null;

    /**
     * @var Collection<int, self>
     */
    private Collection $children;

    /**
     * Get the parent containing this object.
     *
     * @return null|self
     */
    public function getParent(): ?HasParentInterface
    {
        return $this->parent;

The expression return $this->parent could return the type Application\Traits\HasParent which is incompatible with the type-hinted return Application\Traits\HasParentInterface|null. Consider adding an additional type-check to rule them out.

    }

    /**
     * Set the parent containing this object.
     */
    public function setParent(?self $parent): void
    {
        // Remove from previous parent
        if ($this->parent) {
            $this->parent->getChildren()->removeElement($this);
        }

        // Add to new parent
        if ($parent) {
            $this->assertNotCyclic($parent);

$parent of type Application\Traits\HasParent is incompatible with the type Application\Traits\HasParentInterface expected by parameter $parentCandidate of Application\Traits\HasParent::assertNotCyclic().

            $parent->children->add($this);

Accessing children on the interface Application\Traits\HasParentInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        $this->parent = $parent;
    }

    /**
     * Get children.
     */
    public function getChildren(): Collection
    {
        return $this->children;
    }

    /**
     * Has children.
     */
    public function hasChildren(): bool
    {
        return $this->getChildren()->count() > 0;
    }

    private function assertNotCyclic(HasParentInterface $parentCandidate): void
    {
        if ($parentCandidate === $this) {

The condition $parentCandidate === $this is always false.

            throw new InvalidArgumentException('An object cannot be his own parent');
        }

        $allChildren = $this->getAllChildren();

        while ($parentCandidate) {
            if (in_array($parentCandidate, $allChildren, true)) {
                throw new InvalidArgumentException('Parent object is invalid because it would create a cyclic hierarchy');
            }

            $parentCandidate = $parentCandidate->getParent();
        }
    }

    /**
     * Get recursively all children and grand-children.
     *
     * @return HasParentInterface[]
     */
    private function getAllChildren(): array
    {
        $allChildren = [];
        foreach ($this->getChildren() as $child) {
            $allChildren[] = $child;
            $allChildren = array_merge($allChildren, $child->getAllChildren());
        }

        return $allChildren;
    }

    public function getHierarchicName(): string
    {
        $object = $this;
        $result = [];

        while ($object) {
            $result[] = $object->getName();

It seems like getName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $object = $object->getParent();
        }

        return implode(' > ', array_reverse($result));
    }

    /**
     * @return self[]
     */
    public function getParentHierarchy(): array
    {
        $list = [];
        $parent = $this->getParent();

        if ($parent) {
            return array_merge($parent->getParentHierarchy(), [$parent]);
        }

        return $list;
    }
}