SchemaBootloader::embeddings() - Code Metrics - Inspection of "embeddings added" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b222de...2f2094 )

by Anton

created 2019-06-05 15:33 UTC

SchemaBootloader::embeddings() A

↳ Parent: SchemaBootloader

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
declare(strict_types=1);

namespace Spiral\Bootloader\Cycle;

use Cycle\Annotated;
use Cycle\ORM\RepositoryInterface;
use Cycle\ORM\Schema;
use Cycle\ORM\SchemaInterface;
use Cycle\ORM\Select\Repository;
use Cycle\Schema\Generator;
use Cycle\Schema\GeneratorInterface;
use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Boot\Bootloader\DependedInterface;
use Spiral\Boot\MemoryInterface;
use Spiral\Bootloader\Database\DatabaseBootloader;
use Spiral\Bootloader\TokenizerBootloader;
use Spiral\Config\ConfiguratorInterface;
use Spiral\Core\Container;
use Spiral\Tokenizer\ClassesInterface;

final class SchemaBootloader extends Bootloader implements DependedInterface, Container\SingletonInterface
{
    public const BINDINGS = [
        SchemaInterface::class             => [self::class, 'schema'],

        // annotated entities
        Annotated\Embeddings::class        => [self::class, 'embeddings'],
        Annotated\Entities::class          => [self::class, 'entities'],
        Annotated\MergeColumns::class      => [self::class, 'mergeColumns'],
        Annotated\MergeIndexes::class      => [self::class, 'mergeIndexes'],

        // relations
        Generator\GenerateRelations::class => [self::class, 'relations'],
    ];

    /** @var Container */
    private $container;

    /** @var ConfiguratorInterface */
    private $generators;

    /**
     * CycleSchemaBootloader constructor.
     *
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
        $this->generators = [

            Annotated\Embeddings::class,
            Annotated\Entities::class,
            Generator\ResetTables::class,
            Annotated\MergeColumns::class,
            Generator\GenerateRelations::class,
            Generator\ValidateEntities::class,
            Generator\RenderTables::class,
            Generator\RenderRelations::class,
            Annotated\MergeIndexes::class,
            Generator\GenerateTypecast::class
        ];
    }

    /**
     * @param SchemaInterface|null $schema
     */
    public function boot(SchemaInterface $schema = null)
    {
        if (!is_null($schema)) {
            $this->bootRepositories($schema);
        }
    }

    /**
     * @param SchemaInterface $schema
     */
    public function bootRepositories(SchemaInterface $schema)
    {
        foreach ($schema->getRoles() as $role) {
            $repository = $schema->define($role, Schema::REPOSITORY);
            if ($repository === Repository::class || $repository === null) {
                // default repository can not be wired
                continue;
            }

            // initiate all repository dependencies using factory method forwarded to ORM
            $this->container->bind(
                $repository,
                new Container\Autowire(RepositoryInterface::class, ['role' => $role])
                /** @scrutinizer ignore-type */ new Container\Autowire(RepositoryInterface::class, ['role' => $role])
            );
        }
    }

    /**
     * @return array
     */
    public function defineDependencies(): array
    {
        return [
            TokenizerBootloader::class,
            DatabaseBootloader::class
        ];
    }

    /**
     * @param mixed $generator
     */
    public function addGenerator($generator)
    {
        $this->generators[] = $generator;
    }

    /**
     * @return GeneratorInterface[]
     */
    public function getGenerators(): array
    {
        $result = [];
        foreach ($this->generators as $generator) {
            if (is_object($generator) && !$generator instanceof Container\Autowire) {
                $result[] = $generator;
            } else {
                $result[] = $this->container->get($generator);
            }
        }

        return $result;
    }

    /**
     * @param MemoryInterface $memory
     * @return SchemaInterface|null
     */
    protected function schema(MemoryInterface $memory): ?SchemaInterface
    {
        $schema = $memory->loadData('cycle');
        if (is_null($schema)) {
            return null;
        }

        return new Schema($schema);
        return new Schema(/** @scrutinizer ignore-type */ $schema);
    }

    /**
     * @param ClassesInterface $classes
     * @return Annotated\Embeddings
     */
    protected function embeddings(ClassesInterface $classes): Annotated\Embeddings
    {
        return new Annotated\Embeddings($classes);
    }

    /**
     * @param ClassesInterface $classes
     * @return Annotated\Entities
     */
    protected function entities(ClassesInterface $classes): Annotated\Entities
    {
        return new Annotated\Entities($classes);
    }

    /**
     * @return Annotated\MergeColumns
     */
    protected function mergeColumns(): Annotated\MergeColumns
    {
        return new Annotated\MergeColumns();
    }

    /**
     * @return Annotated\MergeIndexes
     */
    protected function mergeIndexes(): Annotated\MergeIndexes
    {
        return new Annotated\MergeIndexes();
    }

    /**
     * @return Generator\GenerateRelations
     */
    protected function relations(): Generator\GenerateRelations
    {
        return new Generator\GenerateRelations();
    }
}

spiral / framework

Push — master ( b222de...2f2094 )

SchemaBootloader::embeddings() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like