Yiisoft\Yii\Cycle\Schema\Converter\SchemaToPHP\SchemaRenderer

Complexity

Total Complexity

29

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	render()	0	7	2
A	renderMapper()	0	3	1
A	renderRelationSchemaKeys()	0	10	3
A	renderEntity()	0	3	1
A	renderTypecast()	0	3	1
A	renderDatabase()	0	3	1
A	renderPK()	0	3	1
A	renderScope()	0	3	1
A	renderRole()	0	25	4
A	renderFields()	0	3	1
A	renderTable()	0	3	1
A	renderRepository()	0	3	1
A	__construct()	0	3	1
A	renderRelations()	0	12	3
B	renderRelationOption()	0	16	7

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\Schema\Converter\SchemaToPHP;

use Cycle\ORM\Relation;
use Cycle\ORM\Schema;
use Cycle\ORM\SchemaInterface;
use Cycle\Schema\Relation\RelationSchema;

final class SchemaRenderer
{
    private const RELATION = [
        Relation::HAS_ONE => 'Relation::HAS_ONE',
        Relation::HAS_MANY => 'Relation::HAS_MANY',
        Relation::BELONGS_TO => 'Relation::BELONGS_TO',
        Relation::REFERS_TO => 'Relation::REFERS_TO',
        Relation::MANY_TO_MANY => 'Relation::MANY_TO_MANY',
        Relation::BELONGS_TO_MORPHED => 'Relation::BELONGS_TO_MORPHED',
        Relation::MORPHED_HAS_ONE => 'Relation::MORPHED_HAS_ONE',
        Relation::MORPHED_HAS_MANY => 'Relation::MORPHED_HAS_MANY',
    ];
    private const RELATION_OPTION = [
        Relation::MORPH_KEY => 'Relation::MORPH_KEY',
        Relation::CASCADE => 'Relation::CASCADE',
        Relation::NULLABLE => 'Relation::NULLABLE',
        Relation::OUTER_KEY => 'Relation::OUTER_KEY',
        Relation::INNER_KEY => 'Relation::INNER_KEY',
        Relation::WHERE => 'Relation::WHERE',
        Relation::THROUGH_INNER_KEY => 'Relation::THROUGH_INNER_KEY',
        Relation::THROUGH_OUTER_KEY => 'Relation::THROUGH_OUTER_KEY',
        Relation::THROUGH_ENTITY => 'Relation::THROUGH_ENTITY',
        Relation::THROUGH_WHERE => 'Relation::THROUGH_WHERE',
        RelationSchema::INDEX_CREATE => 'RelationSchema::INDEX_CREATE',
        RelationSchema::FK_CREATE => 'RelationSchema::FK_CREATE',
        RelationSchema::FK_ACTION => 'RelationSchema::FK_ACTION',
        RelationSchema::INVERSE => 'RelationSchema::INVERSE',
        RelationSchema::MORPH_KEY_LENGTH => 'RelationSchema::MORPH_KEY_LENGTH',
    ];
    private const PREFETCH_MODE = [
        Relation::LOAD_PROMISE => 'Relation::LOAD_PROMISE',
        Relation::LOAD_EAGER => 'Relation::LOAD_EAGER',
    ];
    private const GENERAL_OPTION = [
        Relation::TYPE => 'Relation::TYPE',
        Relation::TARGET => 'Relation::TARGET',
        Relation::SCHEMA => 'Relation::SCHEMA',
        Relation::LOAD => 'Relation::LOAD',
    ];

    private SchemaInterface $schema;

    public function __construct(SchemaInterface $schema)
    {
        $this->schema = $schema;
    }

    public function render(): string
    {
        $arrayToString = new ArrayItemRenderer(null);
        foreach ($this->schema->getRoles() as $role) {
            $arrayToString->value[] = $this->renderRole($role);
        }
        return (string)$arrayToString;
    }

    private function renderRole(string $role): ?ArrayItemRenderer
    {
        $aliasOf = $this->schema->resolveAlias($role);
        if ($aliasOf !== null && $aliasOf !== $role) {
            // This role is an alias
            return null;
        }
        if ($this->schema->defines($role) === false) {
            // Role has not a definition within the schema
            return null;
        }
        $declaration = new ArrayItemRenderer($role, [
            $this->renderDatabase($role),
            $this->renderTable($role),
            $this->renderEntity($role),
            $this->renderMapper($role),
            $this->renderRepository($role),
            $this->renderScope($role),
            $this->renderPK($role),
            $this->renderFields($role),
            $this->renderTypecast($role),
            $this->renderRelations($role),
        ], true);

        return $declaration;
    }
    private function renderDatabase(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::DATABASE', $this->schema->define($role, Schema::DATABASE));
    }
    private function renderTable(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::TABLE', $this->schema->define($role, Schema::TABLE));
    }
    private function renderEntity(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::ENTITY', $this->schema->define($role, Schema::ENTITY));
    }
    private function renderMapper(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::MAPPER', $this->schema->define($role, Schema::MAPPER));
    }
    private function renderRepository(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::REPOSITORY', $this->schema->define($role, Schema::REPOSITORY));
    }
    private function renderScope(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::CONSTRAIN', $this->schema->define($role, Schema::CONSTRAIN));
    }
    private function renderPK(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::PRIMARY_KEY', $this->schema->define($role, Schema::PRIMARY_KEY));
    }
    private function renderFields(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::COLUMNS', $this->schema->define($role, Schema::COLUMNS));
    }
    private function renderTypecast(string $role): ArrayItemRenderer
    {
        return new ArrayItemRenderer('Schema::TYPECAST', $this->schema->define($role, Schema::TYPECAST));
    }
    private function renderRelations(string $role): ArrayItemRenderer
    {
        $relations = $this->schema->define($role, Schema::RELATIONS);
        $results = [];
        foreach ($relations as $field => $relation) {
            $relationResult = [];
            foreach ($relation as $option => $value) {
                $relationResult[] = $this->renderRelationOption($option, $value);
            }
            $results[] = new ArrayItemRenderer($field, $relationResult, true);
        }
        return new ArrayItemRenderer('Schema::RELATIONS', $results);
    }
    private function renderRelationOption(int $option, $value): ArrayItemRenderer
    {
        $item = new ArrayItemRenderer(self::GENERAL_OPTION[$option] ?? (string)$option, $value);

        // replace numeric keys and values to constants
        if ($option === Relation::LOAD && array_key_exists($value, self::PREFETCH_MODE)) {
            $item->value = self::PREFETCH_MODE[$value];
            $item->wrapValue = false;
        } elseif ($option === Relation::TYPE && array_key_exists($value, self::RELATION)) {
            $item->value = self::RELATION[$value];
            $item->wrapValue = false;
        } elseif ($option === Relation::SCHEMA && is_array($value)) {
            $item->value = $this->renderRelationSchemaKeys($value);
        }

        return $item;
    }
    private function renderRelationSchemaKeys(array $value): array
    {
        $result = [];
        foreach ($value as $listKey => $listValue) {
            $result[] = new ArrayItemRenderer(
                array_key_exists($listKey, self::RELATION_OPTION) ? self::RELATION_OPTION[$listKey] : (string)$listKey,
                $listValue
            );
        }
        return $result;
    }
}