SlayerBirden\DataFlowServer\Doctrine\SimpleRegistry

Complexity

Total Complexity

21

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

37.74%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	getDefaultConnectionName()	0	4	1
A	getConnection()	0	12	3
A	getConnections()	0	4	1
A	getConnectionNames()	0	4	1
A	getDefaultManagerName()	0	4	1
A	getManager()	0	16	4
A	getManagers()	0	4	1
A	resetManager()	0	19	3
A	getAliasNamespace()	0	4	1
A	getManagerNames()	0	4	1
A	getRepository()	0	9	2
A	getManagerForClass()	0	6	1

<?php
declare(strict_types=1);

namespace SlayerBirden\DataFlowServer\Doctrine;

use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityManagerInterface;

final class SimpleRegistry implements ManagerRegistry
{
    const DEFAULT_CONNECTION_NAME = 'default';
    const DEFAULT_MANAGER_NAME = 'default';

    /**
     * @var Connection[]
     */
    private $connections = [];
    /**
     * @var EntityManagerInterface[]
     */
    private $managers = [];
    /**
     * Custom Entity=>Manager config
     * @var array
     */
    private $entityManagerMapping = [];

    public function __construct(
        array $connections,
        array $managers,
        array $entityManagerMapping = []
    ) {
        $this->connections = $connections;
        $this->managers = $managers;
        $this->entityManagerMapping = $entityManagerMapping;
    }

    /**
     * @inheritdoc
     */
    public function getDefaultConnectionName(): string
    {
        return self::DEFAULT_CONNECTION_NAME;
    }

    /**
     * @inheritdoc
     */
    public function getConnection($name = null): Connection
    {
        if ($name === null) {
            $name = $this->getDefaultConnectionName();
        }

        if (isset($this->connections[$name])) {
            return $this->connections[$name];
        }

        throw new \InvalidArgumentException(sprintf('Could not find Doctrine connection with name %s', $name));
    }

    /**
     * {@inheritdoc}
     * @return Connection[]
     */
    public function getConnections(): array
    {
        return $this->connections;
    }

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

    /**
     * @inheritdoc
     */
    public function getDefaultManagerName(): string
    {
        return self::DEFAULT_MANAGER_NAME;
    }

    /**
     * @inheritdoc
     * @throws \Doctrine\ORM\ORMException
     */
    public function getManager($name = null): EntityManagerInterface
    {
        if ($name === null) {
            $name = $this->getDefaultManagerName();
        }

        if (isset($this->managers[$name])) {
            $manager = $this->managers[$name];
            if (!$manager->isOpen()) {
                return $this->resetManager($name);
            }
            return $manager;
        }

        throw new \InvalidArgumentException(sprintf('Could not find Doctrine manager with name %s', $name));
    }

    /**
     * {@inheritdoc}
     * @return EntityManagerInterface[]
     */
    public function getManagers(): array
    {
        return $this->managers;
    }

    /**
     * @inheritdoc
     * @throws \Doctrine\ORM\ORMException
     */
    public function resetManager($name = null): EntityManagerInterface
    {
        if ($name === null) {
            $name = $this->getDefaultManagerName();
        }

        if (!isset($this->managers[$name])) {
            throw new \InvalidArgumentException(sprintf('Could not find Doctrine manager with name %s', $name));
        }

        $manager = $this->managers[$name];
        $this->managers[$name] = EntityManager::create(
            $manager->getConnection(),
            $manager->getConfiguration(),
            $manager->getEventManager()
        );

        return $this->getManager($name);
    }

    /**
     * @inheritdoc
     * @unsupported
     */
    public function getAliasNamespace($alias): string
    {
        return $alias;
    }

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

    /**
     * @inheritdoc
     * @throws \Doctrine\ORM\ORMException
     */
    public function getRepository($persistentObject, $persistentManagerName = null): ObjectRepository
    {
        if ($persistentManagerName) {

The expression $persistentManagerName of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $manager = $this->getManager($persistentManagerName);
        } else {
            $manager = $this->getManagerForClass($persistentObject);
        }
        return $manager->getRepository($persistentObject);
    }

    /**
     * @inheritdoc
     * @throws \Doctrine\ORM\ORMException
     */
    public function getManagerForClass($class): EntityManagerInterface
    {
        $name = $this->entityManagerMapping[$class] ?? $this->getDefaultManagerName();

        return $this->getManager($name);
    }
}