Cycle\Annotated\MergeColumns

Complexity

Total Complexity

17

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Test Coverage

Coverage

87.88%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	21	5
B	copy()	0	34	6
A	getColumns()	0	18	5
A	__construct()	0	5	1

<?php

declare(strict_types=1);

namespace Cycle\Annotated;

use Cycle\Annotated\Annotation\Column;
use Cycle\Annotated\Annotation\Table;
use Cycle\Annotated\Exception\AnnotationException;
use Cycle\Annotated\Utils\EntityUtils;
use Cycle\Schema\Definition\Entity as EntitySchema;
use Cycle\Schema\GeneratorInterface;
use Cycle\Schema\Registry;
use Doctrine\Common\Annotations\Reader as DoctrineReader;
use Spiral\Attributes\ReaderInterface;

/**
 * Copy column definitions from Mapper/Repository to Entity.
 */
final class MergeColumns implements GeneratorInterface
{
    private ReaderInterface $reader;

    private Configurator $generator;
    private EntityUtils $utils;

    public function __construct(DoctrineReader|ReaderInterface $reader = null, ?EntityUtils $utils = null)
    {
        $this->reader = ReaderFactory::create($reader);
        $this->generator = new Configurator($this->reader);
        $this->utils = $utils ?? new EntityUtils($this->reader);
    }

    public function run(Registry $registry): Registry
    {
        foreach ($registry as $e) {
            if ($e->getClass() === null || !$registry->hasTable($e)) {
                continue;
            }

            $this->copy($e, $e->getClass());

            // copy from related classes
            $this->copy($e, $e->getMapper());
            $this->copy($e, $e->getRepository());
            $this->copy($e, $e->getSource());
            $this->copy($e, $e->getScope());

            foreach ($registry->getChildren($e) as $child) {
                $this->copy($child, $child->getClass());
            }
        }

        return $registry;
    }

    /**
     * @param class-string|null  $class

The doc comment class-string|null at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string|null.

     */
    private function copy(EntitySchema $e, ?string $class): void
    {
        if ($class === null) {
            return;
        }

        try {
            $class = new \ReflectionClass($class);
        } catch (\ReflectionException) {
            return;
        }

        try {
            $columns = [];
            foreach ($this->utils->findParents($class->getName()) as $parent) {
                $columns = \array_merge($columns, $this->getColumns($parent));
            }
            $columns = \array_merge($columns, $this->getColumns($class));
        } catch (\Exception $e) {
            throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
        }

        $columns = \array_filter(
            $columns,
            static fn (string $field): bool => !$e->getFields()->has($field),
            \ARRAY_FILTER_USE_KEY
        );

        if ($columns === []) {
            return;
        }

        // additional columns (mapped to local fields automatically)
        $this->generator->initColumns($e, $columns, $class);
    }

    private function getColumns(\ReflectionClass $class): array
    {
        $columns = [];

        /** @var Table|null $table */
        $table = $this->reader->firstClassMetadata($class, Table::class);
        foreach ($table === null ? [] : $table->getColumns() as $name => $column) {
            if (\is_numeric($name)) {
                $name = $column->getProperty() ?? $column->getColumn();
            }
            $columns[$name] = $column;
        }

        foreach ($this->reader->getClassMetadata($class, Column::class) as $column) {
            $columns[$column->getProperty() ?? $column->getColumn()] = $column;
        }

        return $columns;
    }
}