Spiral\ORM\Schemas\RelationBuilder

Complexity

Total Complexity

17

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	registerRelation()	0	21	2
C	inverseRelations()	0	32	7
A	getRelations()	0	4	1
A	declareTables()	0	8	3
A	packRelations()	0	14	3

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */

namespace Spiral\ORM\Schemas;

use Spiral\Core\FactoryInterface;
use Spiral\ORM\Configs\RelationsConfig;
use Spiral\ORM\Exceptions\DefinitionException;
use Spiral\ORM\Schemas\Definitions\RelationDefinition;

/**
 * Subsection of SchemaBuilder used to configure tables and columns defined by model to model
 * relations.
 */
class RelationBuilder
{
    /**
     * @invisible
     * @var RelationsConfig
     */
    protected $config;

    /**
     * @invisible
     * @var FactoryInterface
     */
    protected $factory;

    /**
     * Set of relation definitions.
     *
     * @var RelationInterface[]
     */
    private $relations = [];

    /**
     * @param RelationsConfig  $config
     * @param FactoryInterface $factory
     */
    public function __construct(RelationsConfig $config, FactoryInterface $factory)
    {
        $this->config = $config;
        $this->factory = $factory;
    }

    /**
     * Registering new relation definition. At this moment function would not check if relation is
     * unique and will redeclare it.
     *
     * @param RelationDefinition $definition Relation options (definition).
     *
     * @throws DefinitionException
     */
    public function registerRelation(RelationDefinition $definition)
    {
        if (!$this->config->hasRelation($definition->getType())) {
            throw new DefinitionException(sprintf(
                "Undefined relation type '%s' in '%s'.'%s'",
                $definition->getType(),
                $definition->sourceContext()->getClass(),
                $definition->getName()
            ));
        }

        $class = $this->config->relationClass(
            $definition->getType(),
            RelationsConfig::SCHEMA_CLASS
        );

        //Creating relation schema
        $relation = $this->factory->make($class, compact('definition'));

        $this->relations[] = $relation;
    }

    /**
     * Create inverse relations where needed.
     *
     * @param SchemaBuilder $builder
     *
     * @throws DefinitionException
     */
    public function inverseRelations(SchemaBuilder $builder)
    {
        /**
         * Inverse process is relation specific.
         */
        foreach ($this->relations as $relation) {
            $definition = $relation->getDefinition();

            if ($definition->needInversion()) {
                if (!$relation instanceof InversableRelationInterface) {
                    throw new DefinitionException(sprintf(
                        "Unable to inverse relation '%s'.'%s', relation schema '%s' is non inversable",
                        $definition->sourceContext()->getClass(),
                        $definition->getName(),
                        get_class($relation)
                    ));
                }

                $inversed = $relation->inverseDefinition($builder, $definition->getInverse());

                if ($inversed instanceof RelationDefinition) {
                    //Inversed into singular relation
                    $this->registerRelation($inversed);
                } elseif (is_array($inversed)) {
                    //Inversed into multiple back relation (see morphed relations)
                    foreach ($inversed as $definition) {
                        $this->registerRelation($definition);
                    }
                }
            }
        }
    }

    /**
     * All declared relations.
     *
     * @return RelationInterface[]
     */
    public function getRelations(): array
    {
        return $this->relations;
    }

    /**
     * Declare set of tables for each relation. Method must return Generator of AbstractTable
     * sequentially (attention, non sequential processing will cause collision issues between
     * tables).
     *
     * @param SchemaBuilder $builder
     *
     * @return \Generator
     */
    public function declareTables(SchemaBuilder $builder): \Generator
    {
        foreach ($this->relations as $relation) {
            foreach ($relation->declareTables($builder) as $table) {
                yield $table;
            }
        }
    }

    /**
     * Pack relation schemas for specific model class in order to be saved in memory.
     *
     * @param string        $class
     * @param SchemaBuilder $builder
     *
     * @return array
     */
    public function packRelations(string $class, SchemaBuilder $builder): array
    {
        $result = [];
        foreach ($this->relations as $relation) {
            $definition = $relation->getDefinition();

            if ($definition->sourceContext()->getClass() == $class) {
                //Packing relation, relation schema are given with associated table
                $result[$definition->getName()] = $relation->packRelation($builder);
            }
        }

        return $result;
    }
}