Yiisoft\Yii\Cycle\Factory\RepositoryContainer

Complexity

Total Complexity

13

Size/Duplication

Total Lines	69
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	makeRepositoryList()	0	15	5
A	get()	0	11	3
A	makeRepository()	0	3	1
A	__construct()	0	3	1
A	has()	0	12	3

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Cycle\Factory;

use Closure;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\RepositoryInterface;
use Cycle\ORM\SchemaInterface;
use Psr\Container\ContainerInterface;
use Yiisoft\Di\Container;

The type Yiisoft\Di\Container was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Di\CompositeContainer;

The type Yiisoft\Di\CompositeContainer was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Di\Contracts\ServiceProviderInterface;

The type Yiisoft\Di\Contracts\ServiceProviderInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Yiisoft\Factory\Exception\NotFoundException;

The type Yiisoft\Factory\Exception\NotFoundException was not found. Maybe you did not declare it correctly or list all dependencies?

use function is_string;

final class RepositoryContainer implements ContainerInterface
{
    private ContainerInterface $rootContainer;
    private ORMInterface $orm;
    private array $roles = [];
    private array $instances;
    private bool $build = false;

    public function __construct(ContainerInterface $rootContainer)
    {
        $this->rootContainer = $rootContainer;
    }


    public function get($id)
    {
        if (isset($this->instances[$id])) {
            return $this->instances[$id];
        }

        if ($this->has($id)) {
            return $this->instances[$id] = $this->makeRepository($this->roles[$id]);
        }

        throw new NotFoundException("Repository $id doesn't exist.");
    }

    public function has($id): bool
    {
        if (!is_subclass_of($id, RepositoryInterface::class)) {
            return false;
        }

        if (!$this->build) {
            $this->makeRepositoryList();
            $this->build = true;
        }

        return isset($this->roles[$id]);
    }

    private function makeRepositoryList(): void
    {
        /** @var ORMInterface */
        $this->orm = $this->rootContainer->get(ORMInterface::class);

Accessing orm on the interface Cycle\ORM\ORMInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $schema = $this->orm->getSchema();
        $roles = [];
        foreach ($schema->getRoles() as $role) {
            $repository = $schema->define($role, SchemaInterface::REPOSITORY);
            if (is_string($repository)) {
                $roles[$repository][] = $role;
            }
        }
        foreach ($roles as $repo => $role) {
            if (count($role) === 1) {
                $this->roles[$repo] = current($role);
            }
        }
    }

    /**
     * @psalm-pure
     * @param ORMInterface $orm
     * @param string $role
     * @return Closure
     */
    private function makeRepository(string $role): RepositoryInterface
    {
        return $this->orm->getRepository($role);

The expression return $this->orm->getRepository($role) returns the type Cycle\ORM\RepositoryInterface which is incompatible with the documented return type Closure.

    }
}