Configurator::initColumns() - Code Metrics - Inspection of "Scrutinizer: add analysis" - cycle/annotated - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 3.x ( 080893...4e5cb3 )

by Aleksei
created 2022-01-10 07:41 UTC
Configurator::initColumns() B

↳ Parent: Configurator
Complexity

Conditions	8
Paths	8
Size

Total Lines	32
Code Lines	19
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	16
CRAP Score	8.512
Importance

Changes
Metric	Value
cc	8
eloc	19
nc	8
nop	3
dl	0
loc	32
ccs	16
cts	20
cp	0.8
crap	8.512
rs	8.4444
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Cycle\Annotated;

use Cycle\Annotated\Annotation\Column;
use Cycle\Annotated\Annotation\Embeddable;
use Cycle\Annotated\Annotation\Entity;
use Cycle\Annotated\Annotation\Relation as RelationAnnotation;
use Cycle\Annotated\Exception\AnnotationException;
use Cycle\Annotated\Exception\AnnotationRequiredArgumentsException;
use Cycle\Annotated\Exception\AnnotationWrongTypeArgumentException;
use Cycle\Annotated\Utils\EntityUtils;
use Cycle\Schema\Definition\Entity as EntitySchema;
use Cycle\Schema\Definition\Field;
use Cycle\Schema\Definition\Relation;
use Cycle\Schema\Generator\SyncTables;
use Cycle\Schema\SchemaModifierInterface;
use Doctrine\Common\Annotations\Reader as DoctrineReader;
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\Rules\English\InflectorFactory;
use Exception;
use Spiral\Attributes\ReaderInterface;

final class Configurator
{
    private ReaderInterface $reader;
    private Inflector $inflector;
    private EntityUtils $utils;

    public function __construct(
        DoctrineReader|ReaderInterface $reader,
        private int $tableNamingStrategy = Entities::TABLE_NAMING_PLURAL,
    ) {
        $this->reader = ReaderFactory::create($reader);
        $this->inflector = (new InflectorFactory())->build();
        $this->utils = new EntityUtils($this->reader);
    }

    public function initEntity(Entity $ann, \ReflectionClass $class): EntitySchema
    {
        $e = new EntitySchema();
        $e->setClass($class->getName());

        $e->setRole($ann->getRole() ?? $this->inflector->camelize($class->getShortName()));

        // representing classes
        $e->setMapper($this->resolveName($ann->getMapper(), $class));
        $e->setRepository($this->resolveName($ann->getRepository(), $class));
        $e->setSource($this->resolveName($ann->getSource(), $class));
        $e->setScope($this->resolveName($ann->getScope(), $class));
        $e->setDatabase($ann->getDatabase());
        $e->setTableName(
            $ann->getTable() ?? $this->utils->tableName($e->getRole(), $this->tableNamingStrategy)
        );

        $typecast = $ann->getTypecast();
        if (is_array($typecast)) {
            $typecast = array_map(fn (string $value): string => $this->resolveName($value, $class), $typecast);
        } else {
            $typecast = $this->resolveName($typecast, $class);
        }

        $e->setTypecast($typecast);

        if ($ann->isReadonlySchema()) {
            $e->getOptions()->set(SyncTables::READONLY_SCHEMA, true);
        }

        return $e;
    }

    public function initEmbedding(Embeddable $emb, \ReflectionClass $class): EntitySchema
    {
        $e = new EntitySchema();
        $e->setClass($class->getName());

        $e->setRole($emb->getRole() ?? $this->inflector->camelize($class->getShortName()));

        // representing classes
        $e->setMapper($this->resolveName($emb->getMapper(), $class));

        return $e;
    }

    public function initFields(EntitySchema $entity, \ReflectionClass $class, string $columnPrefix = ''): void
    {
        foreach ($class->getProperties() as $property) {
            try {
                $column = $this->reader->firstPropertyMetadata($property, Column::class);
            } catch (Exception $e) {
                throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
            } catch (\ArgumentCountError $e) {
                throw AnnotationRequiredArgumentsException::createFor($property, Column::class, $e);
            } catch (\TypeError $e) {
                throw AnnotationWrongTypeArgumentException::createFor($property, $e);
            }

            if ($column === null) {
                continue;
            }

            $field = $this->initField($property->getName(), $column, $class, $columnPrefix);
            $field->setEntityClass($property->getDeclaringClass()->getName());
            $entity->getFields()->set($property->getName(), $field);
        }
    }

    public function initRelations(EntitySchema $entity, \ReflectionClass $class): void
    {
        foreach ($class->getProperties() as $property) {
            try {
                $metadata = $this->reader->getPropertyMetadata($property, RelationAnnotation\RelationInterface::class);
            } catch (Exception $e) {
                throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
            }

            foreach ($metadata as $meta) {
                assert($meta instanceof RelationAnnotation\RelationInterface);

                if ($meta->getTarget() === null) {
                    throw new AnnotationException(
                        "Relation target definition is required on `{$entity->getClass()}`.`{$property->getName()}`"
                    );
                }

                $relation = new Relation();
                $relation->setTarget($this->resolveName($meta->getTarget(), $class));
                $relation->setType($meta->getType());

                $inverse = $meta->getInverse() ?? $this->reader->firstPropertyMetadata(
                    $property,
                    RelationAnnotation\Inverse::class
                );
                if ($inverse !== null) {
                    $relation->setInverse(
                        $inverse->getName(),
                        $inverse->getType(),
                        $inverse->getLoadMethod()
                    );
                }

                foreach ($meta->getOptions() as $option => $value) {
                    $value = match ($option) {
                        'collection' => $this->resolveName($value, $class),
                        'though', 'through' => $this->resolveName($value, $class),
                        default => $value
                    };

                    $relation->getOptions()->set($option, $value);
                }

                // need relation definition
                $entity->getRelations()->set($property->getName(), $relation);
            }
        }
    }

    public function initModifiers(EntitySchema $entity, \ReflectionClass $class): void
    {
        try {
            $metadata = $this->reader->getClassMetadata($class, SchemaModifierInterface::class);
        } catch (Exception $e) {
            throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
        }

        foreach ($metadata as $meta) {
            assert($meta instanceof SchemaModifierInterface);

            // need relation definition
            $entity->addSchemaModifier($meta);
        }
    }

    /**
     * @param Column[] $columns
     */
    public function initColumns(EntitySchema $entity, array $columns, \ReflectionClass $class): void
    {
        foreach ($columns as $key => $column) {
            $isNumericKey = is_numeric($key);
            $propertyName = $column->getProperty();

            if (!$isNumericKey && $propertyName !== null && $key !== $propertyName) {
                throw new AnnotationException(
                    "Can not use name \"{$key}\" for Column of the `{$entity->getRole()}` role, because the "
                    . "\"property\" field of the metadata class has already been set to \"{$propertyName}\"."
                );
            }

            $propertyName = $propertyName ?? ($isNumericKey ? null : $key);
            $columnName = $column->getColumn() ?? $propertyName;
            $propertyName = $propertyName ?? $columnName;

            if ($columnName === null) {
                throw new AnnotationException(
                    "Column name definition is required on `{$entity->getClass()}`"
                );
            }

            if ($column->getType() === null) {
                throw new AnnotationException(
                    "Column type definition is required on `{$entity->getClass()}`.`{$columnName}`"
                );
            }

            $field = $this->initField($columnName, $column, $class, '');
            $field->setEntityClass($entity->getClass());
            $entity->getFields()->set($propertyName, $field);
            $entity->getFields()->set(/** @scrutinizer ignore-type */ $propertyName, $field);
        }
    }

    public function initField(string $name, Column $column, \ReflectionClass $class, string $columnPrefix): Field
    {
        $field = new Field();

        $field->setType($column->getType());
        $field->setColumn($columnPrefix . ($column->getColumn() ?? $this->inflector->tableize($name)));
        $field->setPrimary($column->isPrimary());

        $field->setTypecast($this->resolveTypecast($column->getTypecast(), $class));

        if ($column->isNullable()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_NULLABLE, true);
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_DEFAULT, null);
        }

        if ($column->hasDefault()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_DEFAULT, $column->getDefault());
        }

        if ($column->castDefault()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_CAST_DEFAULT, true);
        }

        return $field;
    }

    /**
     * Resolve class or role name relative to the current class.
     */
    public function resolveName(?string $name, \ReflectionClass $class): ?string
    {
        if ($name === null || class_exists($name, true) || interface_exists($name, true)) {
            return $name;
        }

        $resolved = sprintf(
            '%s\\%s',
            $class->getNamespaceName(),
            ltrim(str_replace('/', '\\', $name), '\\')
        );

        if (class_exists($resolved, true) || interface_exists($resolved, true)) {
            return ltrim($resolved, '\\');
        }

        return $name;
    }

    private function resolveTypecast(mixed $typecast, \ReflectionClass $class): mixed
    {
        if (is_string($typecast) && strpos($typecast, '::') !== false) {
            // short definition
            $typecast = explode('::', $typecast);

            // resolve class name
            $typecast[0] = $this->resolveName($typecast[0], $class);
        }

        if (is_string($typecast)) {
            $typecast = $this->resolveName($typecast, $class);
            if (class_exists($typecast)) {
                $typecast = [$typecast, 'typecast'];
            }
        }

        return $typecast;
    }
}

cycle / annotated

Push — 3.x ( 080893...4e5cb3 )

Configurator::initColumns() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
