Daikon\Entity\EntityType\NestedEntityAttribute

Complexity

Total Complexity

14

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

97.14%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	define()	0	8	1
A	getValueType()	0	4	1
B	makeValue()	0	13	5
A	getName()	0	4	1
A	getEntityType()	0	4	1
A	getParent()	0	4	1
A	__construct()	0	11	2
A	makeEntity()	0	11	2

<?php

namespace Daikon\Entity\EntityType;

use Daikon\Entity\Assert\Assertion;
use Daikon\Entity\Entity\EntityInterface;
use Daikon\Entity\Entity\NestedEntity;
use Daikon\Entity\Entity\TypedEntityInterface;
use Daikon\Entity\Error\CorruptValues;
use Daikon\Entity\Error\MissingImplementation;
use Daikon\Entity\Error\UnexpectedValue;
use Daikon\Entity\ValueObject\Nil;
use Daikon\Entity\ValueObject\ValueObjectInterface;

class NestedEntityAttribute implements AttributeInterface
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var EntityTypeInterface
     */
    private $entityType;

    /**
     * @var EntityTypeMap
     */
    private $allowedTypes;

    public static function define(
        string $name,
        $entityTypeClasses,
        EntityTypeInterface $entityType
    ): AttributeInterface {
        Assertion::isArray($entityTypeClasses);
        return new static($name, $entityType, $entityTypeClasses);
    }

    public function getValueType(): EntityTypeMap
    {
        return $this->allowedTypes;
    }

    public function makeValue($value = null, EntityInterface $parent = null): ValueObjectInterface
    {
        if ($value instanceof NestedEntity) {
            foreach ($this->getValueType() as $type) {
                if ($type === $value->getEntityType()) {
                    return $value;
                }
            }
            throw new UnexpectedValue("Given entity-type is not allowed for attribute ".$this->getName());
        }
        Assertion::nullOrisArray($value);
        return is_array($value) ? $this->makeEntity($value, $parent) : Nil::fromNative($value);

It seems like $parent defined by parameter $parent on line 46 can also be of type object<Daikon\Entity\Entity\EntityInterface>; however, Daikon\Entity\EntityType\NestedEntityAttribute::makeEntity() does only seem to accept null|object<Daikon\Entity\Entity\TypedEntityInterface>, maybe add an additional type check?

    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getEntityType(): EntityTypeInterface
    {
        return $this->entityType;
    }

    public function getParent(): ?AttributeInterface
    {
        return $this->getEntityType()->getParentAttribute();
    }

    protected function __construct(string $name, EntityTypeInterface $entityType, array $allowedTypeClasses)
    {
        $this->name = $name;
        $this->entityType = $entityType;
        $this->allowedTypes = new EntityTypeMap(array_map(function (string $typeFqcn) {
            if (!class_exists($typeFqcn)) {
                throw new MissingImplementation("Unable to load given entity-type class: '$typeFqcn'");
            }
            return new $typeFqcn($this);
        }, $allowedTypeClasses));
    }

    private function makeEntity(array $entityValues, TypedEntityInterface $parentEntity = null): NestedEntity
    {
        Assertion::keyExists($entityValues, TypedEntityInterface::ENTITY_TYPE);
        $typePrefix = $entityValues[TypedEntityInterface::ENTITY_TYPE];
        if (!$this->allowedTypes->has($typePrefix)) {
            throw new CorruptValues("Unknown type prefix given within nested-entity values.");
        }
        /* @var NestedEntity $entity */
        $entity = $this->allowedTypes->get($typePrefix)->makeEntity($entityValues, $parentEntity);
        return $entity;
    }
}