Cycle\ORM\PromiseMapper\PromiseMapper

Complexity

Total Complexity

10

Size/Duplication

Total Lines	74
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	fetchRelations()	0	6	1
A	fetchFields()	0	6	1
A	extract()	0	4	1
A	hydrate()	0	18	5
A	init()	0	7	1

<?php

declare(strict_types=1);

namespace Cycle\ORM\PromiseMapper;

use Cycle\ORM\Mapper\DatabaseMapper;
use Cycle\ORM\Mapper\Traits\SingleTableTrait;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\Reference\Promise;
use Cycle\ORM\Reference\ReferenceInterface;
use Cycle\ORM\SchemaInterface;
use Doctrine\Instantiator;
use Laminas\Hydrator\HydratorInterface;
use Laminas\Hydrator\ReflectionHydrator;

/**
 * Provide the ability to carry data over the specific class instances. Supports table inheritance using
 * hidden entity field.
 */
class PromiseMapper extends DatabaseMapper
{
    use SingleTableTrait;

    protected string $entity;
    protected array $children = [];
    protected HydratorInterface $hydrator;
    protected Instantiator\Instantiator $instantiator;

    public function __construct(ORMInterface $orm, string $role)
    {
        parent::__construct($orm, $role);

        $this->schema = $orm->getSchema();
        $this->entity = $this->schema->define($role, SchemaInterface::ENTITY);
        $this->children = $this->schema->define($role, SchemaInterface::CHILDREN) ?? [];
        $this->discriminator = $this->schema->define($role, SchemaInterface::DISCRIMINATOR) ?? $this->discriminator;
        $this->hydrator = new ReflectionHydrator();

        $this->instantiator = new Instantiator\Instantiator();
    }

    #[\Override]
    public function init(array $data, ?string $role = null): object
    {
        /** @psalm-var class-string $class */
        $class = $this->resolveClass($data, $role);

        return $this->instantiator->instantiate($class);
    }

    #[\Override]
    public function hydrate(object $entity, array $data): object
    {
        // Force searching related entities in the Heap
        $relations = $this->relationMap->getRelations();
        foreach ($data as $k => $v) {
            if (!$v instanceof ReferenceInterface || !\array_key_exists($k, $relations)) {
                continue;
            }
            $relation = $relations[$k];
            $relation->resolve($v, false);

            $data[$k] = $v->hasValue()
                ? $relation->collect($v->getValue())
                : new Promise($relation, $v);
        }

        return $this->hydrator->hydrate($data, $entity);
    }

    #[\Override]
    public function extract(object $entity): array
    {
        return $this->hydrator->extract($entity);
    }

    /**
     * Get entity columns.
     */
    #[\Override]
    public function fetchFields(object $entity): array
    {
        $values = \array_intersect_key($this->extract($entity), $this->columns + $this->parentColumns);

        return $values + $this->getDiscriminatorValues($entity);
    }

    #[\Override]
    public function fetchRelations(object $entity): array
    {
        return \array_intersect_key(
            $this->extract($entity),
            $this->relationMap->getRelations(),
        );
    }
}