Spiral\Cycle\Schema

Complexity

Total Complexity

22

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	define()	0	12	3
A	__construct()	0	4	1
A	defines()	0	3	2
A	getRoles()	0	3	1
A	defineRelation()	0	9	2
B	normalize()	0	38	7
A	getRelations()	0	3	1
A	normalizeRelations()	0	11	3
A	resolveAlias()	0	8	2

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

namespace Spiral\Cycle;

use Spiral\Cycle\Exception\SchemaException;

/**
 * Static schema with automatic class name => role aliasing.
 */
final class Schema implements SchemaInterface
{
    /** @var array */
    private $aliases;

    /** @var array */
    private $schema = [];

    /**
     * @param array $schema
     */
    public function __construct(array $schema)
    {
        // split into two?
        list($this->schema, $this->aliases) = $this->normalize($schema);
    }

    /**
     * @inheritdoc
     */
    public function getRoles(): array
    {
        return array_keys($this->schema);
    }

    /**
     * @inheritdoc
     */
    public function defines(string $role): bool
    {
        return array_key_exists($role, $this->schema) || array_key_exists($role, $this->aliases);
    }

    /**
     * @inheritdoc
     */
    public function define(string $role, int $property)
    {
        $role = $this->resolveAlias($role);
        if (!isset($this->schema[$role])) {
            throw new SchemaException("Undefined schema `{$role}`, not found");
        }

        if (!array_key_exists($property, $this->schema[$role])) {
            return null;
        }

        return $this->schema[$role][$property];
    }

    /**
     * @inheritdoc
     */
    public function getRelations(string $role): array
    {
        return array_keys($this->define($role, self::RELATIONS));

It seems like $this->define($role, self::RELATIONS) can also be of type null; however, parameter $input of array_keys() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * @inheritdoc
     */
    public function defineRelation(string $role, string $relation): array
    {
        $relations = $this->define($role, self::RELATIONS);

        if (!isset($relations[$relation])) {
            throw new SchemaException("Undefined relation `{$role}`.`{$relation}`");
        }

        return $relations[$relation];
    }

    /**
     * @inheritdoc
     */
    public function resolveAlias(string $entity): ?string
    {
        // walk thought all children until parent entity found
        while (isset($this->aliases[$entity])) {
            $entity = $this->aliases[$entity];
        }

        return $entity;
    }


    /**
     * Automatically replace class names with their aliases.
     *
     * @param array $schema
     * @return array Pair of [schema, aliases]
     */
    protected function normalize(array $schema): array
    {
        $result = $aliases = [];

        foreach ($schema as $key => $item) {
            $role = $key;
            if (!isset($item[self::ENTITY])) {
                // legacy type of declaration (class => schema)
                $item[self::ENTITY] = $key;
            }

            if (class_exists($key)) {
                if (!isset($item[self::ROLE])) {
                    throw new SchemaException("Unable to create schema record without given role for `{$key}`");
                }

                // class => role type of definition
                $aliases[$key] = $item[self::ROLE];
                $role = $item[self::ROLE];
            }

            unset($item[self::ROLE]);
            $result[$role] = $item;
        }

        // normalizing relation associations
        foreach ($result as &$item) {
            if (isset($item[self::RELATIONS])) {
                $item[self::RELATIONS] = iterator_to_array($this->normalizeRelations(
                    $item[self::RELATIONS],
                    $aliases
                ));
            }

            unset($item);
        }

        return [$result, $aliases];
    }

    /**
     * @param array $relations
     * @param array $aliases
     * @return \Generator
     */
    private function normalizeRelations(array $relations, array $aliases): \Generator
    {
        foreach ($relations as $name => &$rel) {
            $target = $rel[Relation::TARGET];
            while (isset($aliases[$target])) {
                $target = $aliases[$target];
            }

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

            yield $name => $rel;
        }
    }
}