Cycle\Schema\Renderer\MermaidRenderer\MermaidRenderer

Complexity

Total Complexity

21

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	formatTypecast()	0	21	5
F	render()	0	95	15
A	getClassShortName()	0	5	1

<?php

declare(strict_types=1);

namespace Cycle\Schema\Renderer\MermaidRenderer;

use Cycle\ORM\Relation;
use Cycle\ORM\SchemaInterface;
use Cycle\Schema\Renderer\MermaidRenderer\Entity\EntityArrow;
use Cycle\Schema\Renderer\MermaidRenderer\Entity\EntityTable;
use Cycle\Schema\Renderer\MermaidRenderer\Exception\RelationNotFoundException;
use Cycle\Schema\Renderer\MermaidRenderer\Schema\ClassDiagram;
use Cycle\Schema\Renderer\SchemaRenderer;

final class MermaidRenderer implements SchemaRenderer
{
    private const METHOD_FORMAT = '%s: %s';

    /**
     * @throws RelationNotFoundException
     */
    public function render(array $schema): string
    {
        $class = new ClassDiagram();
        $relationMapper = new RelationMapper();

        foreach ($schema as $key => $value) {
            if (!isset($value[SchemaInterface::COLUMNS])) {
                continue;
            }

            $role = $key;

            if (class_exists($role)) {
                $role = $value[SchemaInterface::ROLE];
            }

            if (strpos($role, ':') !== false) {
                $role = $key;
            }

            $table = new EntityTable($role);
            $arrow = new EntityArrow();

            foreach ($value[SchemaInterface::COLUMNS] as $column) {
                $typecast = $this->formatTypecast($value[SchemaInterface::TYPECAST][$column] ?? 'string');

                $table->addRow($typecast, $column);
            }

            foreach ($value[SchemaInterface::RELATIONS] ?? [] as $relationKey => $relation) {
                if (!isset($relation[Relation::TARGET], $relation[Relation::SCHEMA])) {
                    continue;
                }

                $target = $relation[Relation::TARGET];

                if (class_exists($target)) {
                    $target = lcfirst($this->getClassShortName($target));
                }

                $isNullable = $relation[Relation::SCHEMA][Relation::NULLABLE] ?? false;

                $mappedRelation = $relationMapper->mapWithNode($relation[Relation::TYPE], $isNullable);

                switch ($relation[Relation::TYPE]) {
                    case Relation::MANY_TO_MANY:
                        $throughEntity = $relation[Relation::SCHEMA][Relation::THROUGH_ENTITY] ?? null;

                        if ($throughEntity) {
                            if (class_exists($throughEntity)) {
                                $throughEntity = lcfirst($this->getClassShortName($throughEntity));
                            }

                            $table->addMethod($relationKey, sprintf(self::METHOD_FORMAT, $mappedRelation[0], $target));

                            // tag --* post : posts
                            $arrow->addArrow($role, $target, $relationKey, $mappedRelation[1]);
                            // postTag ..> tag : tag.posts
                            $arrow->addArrow($throughEntity, $role, "$role.$relationKey", '..>');
                            // postTag ..> post : tag.posts
                            $arrow->addArrow($throughEntity, $target, "$role.$relationKey", '..>');
                        }
                        break;
                    case Relation::EMBEDDED:
                        // explode string like user:credentials
                        $methodTarget = explode(':', $target);

                        $table->addMethod(
                            $methodTarget[1] ?? $target,
                            sprintf(self::METHOD_FORMAT, $mappedRelation[0], $relationKey)
                        );

                        $arrowTarget = str_replace(':', '&#58', $target);

                        $arrow->addArrow($role, $relationKey, $arrowTarget, $mappedRelation[1]);
                        break;
                    default:
                        $table->addMethod($relationKey, sprintf(self::METHOD_FORMAT, $mappedRelation[0], $target));
                        $arrow->addArrow($role, $target, $relationKey, $mappedRelation[1]);
                }
            }

            foreach ($value[SchemaInterface::CHILDREN] ?? [] as $children) {
                $arrow->addArrow($role, $children, 'STI', '--|>');
            }

            if (isset($value[SchemaInterface::PARENT])) {
                $arrow->addArrow($value[SchemaInterface::PARENT], $role, 'JTI', '--|>');
            }

            $class->addEntity($table);
            $class->addEntity($arrow);
        }

        return (string)$class;
    }

    private function getClassShortName($class): string
    {
        $ref = new \ReflectionClass($class);

        return $ref->getShortName();
    }

    private function formatTypecast($typecast): string
    {
        if (is_array($typecast)) {
            $typecast[0] = $this->getClassShortName($typecast[0]);

            return sprintf("[%s, '%s']", "$typecast[0]::class", $typecast[1]);
        }

        if ($typecast instanceof \Closure) {
            return 'Closure';
        }

        if (class_exists($typecast)) {
            if ($typecast === 'datetime') {
                return $typecast;
            }

            return $this->getClassShortName($typecast) . '::class';
        }

        return \htmlentities($typecast);
    }
}