DoctrineOrmManagerRegistry::getManager() - Code Metrics - Inspection of "enhance DoctrineOrmManagerRegistry and its tests" - chubbyphp/chubbyphp-service-provider - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e42f4b...a9b120 )

by Dominik

created 2018-08-01 19:57 UTC

DoctrineOrmManagerRegistry::getManager() A

↳ Parent: DoctrineOrmManagerRegistry

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	8
cts	8
cp	1
rs	9.7333
c	0
b	0
f	0
cc	3
nc	3
nop	1
crap	3

<?php

declare(strict_types=1);

namespace Chubbyphp\ServiceProvider\Registry;

use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\Common\Persistence\Proxy;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\ORMException;
use Pimple\Container;

final class DoctrineOrmManagerRegistry implements ManagerRegistry
{
    /**
     * @var Container
     */
    private $container;

    /**
     * @var Container|Connection[]
     */
    private $connections;

    /**
     * @var string
     */
    private $defaultConnectionName;

    /**
     * @var Container|EntityManager[]
     */
    private $originalManagers;

    /**
     * @var EntityManager[]
     */
    private $resetedManagers = [];

    /**
     * @var string
     */
    private $defaultManagerName;

    /**
     * @param Container $container
     */
    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    /**
     * @return string
     */
    public function getDefaultConnectionName(): string
    {
        $this->loadConnections();

        return $this->defaultConnectionName;
    }

    /**
     * @param string|null $name
     *
     * @return Connection
     *
     * @throws \InvalidArgumentException
     */
    public function getConnection($name = null): Connection
    {
        $this->loadConnections();

        $name = $name ?? $this->getDefaultConnectionName();

        if (!isset($this->connections[$name])) {
            throw new \InvalidArgumentException(sprintf('Missing connection with name "%s".', $name));
        }

        return $this->connections[$name];
    }

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

        $connections = array();
        foreach ($this->connections->keys() as $name) {
            $connections[$name] = $this->connections[$name];
        }

        return $connections;
    }

    /**
     * @return string[]
     */
    public function getConnectionNames(): array
    {
        $this->loadConnections();

        return $this->connections->keys();
    }

    /**
     * @return string
     */
    public function getDefaultManagerName(): string
    {
        $this->loadManagers();

        return $this->defaultManagerName;
    }

    /**
     * @param string|null $name
     *
     * @return EntityManager|ObjectManager
     */
    public function getManager($name = null): ObjectManager
    {
        $this->loadManagers();

        $name = $name ?? $this->getDefaultManagerName();

        if (!isset($this->originalManagers[$name])) {
            throw new \InvalidArgumentException(sprintf('Missing manager with name "%s".', $name));
        }

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

        return $this->originalManagers[$name];
    }

    /**
     * @return EntityManager[]|ObjectManager[]
     */
    public function getManagers(): array
    {
        $this->loadManagers();

        $managers = array();
        foreach ($this->originalManagers->keys() as $name) {
            if (isset($this->resetedManagers[$name])) {
                $manager = $this->resetedManagers[$name];
            } else {
                $manager = $this->originalManagers[$name];
            }

            $managers[$name] = $manager;
        }

        return $managers;
    }

    /**
     * @return array
     */
    public function getManagerNames(): array
    {
        $this->loadManagers();

        return $this->originalManagers->keys();
    }

    /**
     * @param string|null $name
     *
     * @return EntityManager|ObjectManager
     */
    public function resetManager($name = null)
    {
        $this->loadManagers();

        $name = $name ?? $this->getDefaultManagerName();

        if (!isset($this->originalManagers[$name])) {
            throw new \InvalidArgumentException(sprintf('Missing manager with name "%s".', $name));
        }

        $originalManager = $this->originalManagers[$name];

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

        return $this->resetedManagers[$name];
    }

    /**
     * @param string $alias
     *
     * @return string
     *
     * @throws ORMException
     */
    public function getAliasNamespace($alias): string
    {
        foreach ($this->getManagerNames() as $name) {
            try {
                return $this->getManager($name)->getConfiguration()->getEntityNamespace($alias);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            } catch (ORMException $e) {
                // throw the exception only if no manager can solve it
            }
        }
        throw ORMException::unknownEntityNamespace($alias);
    }

    /**
     * @param string $persistentObject
     * @param null   $persistentManagerName
     *
     * @return EntityRepository|ObjectRepository
     */
    public function getRepository($persistentObject, $persistentManagerName = null): ObjectRepository
    {
        return $this->getManager($persistentManagerName)->getRepository($persistentObject);
    }

    /**
     * @param string $class
     *
     * @return EntityManager|ObjectManager|null
     */
    public function getManagerForClass($class)
    {
        $proxyClass = new \ReflectionClass($class);
        if ($proxyClass->implementsInterface(Proxy::class)) {
            $class = $proxyClass->getParentClass()->getName();
        }

        foreach ($this->getManagerNames() as $name) {
            if (!$this->getManager($name)->getMetadataFactory()->isTransient($class)) {
                return $this->getManager($name);
            }
        }
    }

    private function loadConnections()
    {
        if (null === $this->connections) {
            $this->connections = $this->container['doctrine.dbal.dbs'];
            $this->defaultConnectionName = $this->container['doctrine.dbal.dbs.default'];
        }
    }

    private function loadManagers()
    {
        if (null === $this->originalManagers) {
            $this->originalManagers = $this->container['doctrine.orm.ems'];
            $this->defaultManagerName = $this->container['doctrine.orm.ems.default'];
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Chubbyphp\ServiceProvider\Registry;
6
7		use Doctrine\Common\Persistence\ManagerRegistry;
8		use Doctrine\Common\Persistence\ObjectManager;
9		use Doctrine\Common\Persistence\ObjectRepository;
10		use Doctrine\Common\Persistence\Proxy;
11		use Doctrine\DBAL\Connection;
12		use Doctrine\ORM\EntityManager;
13		use Doctrine\ORM\EntityRepository;
14		use Doctrine\ORM\ORMException;
15		use Pimple\Container;
16
17		final class DoctrineOrmManagerRegistry implements ManagerRegistry
18		{
19		/**
20		* @var Container
21		*/
22		private $container;
23
24		/**
25		* @var Container\|Connection[]
26		*/
27		private $connections;
28
29		/**
30		* @var string
31		*/
32		private $defaultConnectionName;
33
34		/**
35		* @var Container\|EntityManager[]
36		*/
37		private $originalManagers;
38
39		/**
40		* @var EntityManager[]
41		*/
42		private $resetedManagers = [];
43
44		/**
45		* @var string
46		*/
47		private $defaultManagerName;
48
49		/**
50		* @param Container $container
51		*/
52	17	public function __construct(Container $container)
53		{
54	17	$this->container = $container;
55	17	}
56
57		/**
58		* @return string
59		*/
60	3	public function getDefaultConnectionName(): string
61		{
62	3	$this->loadConnections();
63
64	3	return $this->defaultConnectionName;
65		}
66
67		/**
68		* @param string\|null $name
69		*
70		* @return Connection
71		*
72		* @throws \InvalidArgumentException
73		*/
74	2	public function getConnection($name = null): Connection
75		{
76	2	$this->loadConnections();
77
78	2	$name = $name ?? $this->getDefaultConnectionName();
79
80	2	if (!isset($this->connections[$name])) {
81	1	throw new \InvalidArgumentException(sprintf('Missing connection with name "%s".', $name));
82		}
83
84	1	return $this->connections[$name];
85		}
86
87		/**
88		* @return Connection[]
89		*/
90	1	public function getConnections(): array
91		{
92	1	$this->loadConnections();
93
94	1	$connections = array();
95	1	foreach ($this->connections->keys() as $name) {
96	1	$connections[$name] = $this->connections[$name];
97		}
98
99	1	return $connections;
100		}
101
102		/**
103		* @return string[]
104		*/
105	1	public function getConnectionNames(): array
106		{
107	1	$this->loadConnections();
108
109	1	return $this->connections->keys();
110		}
111
112		/**
113		* @return string
114		*/
115	6	public function getDefaultManagerName(): string
116		{
117	6	$this->loadManagers();
118
119	6	return $this->defaultManagerName;
120		}
121
122		/**
123		* @param string\|null $name
124		*
125		* @return EntityManager\|ObjectManager
126		*/
127	6	public function getManager($name = null): ObjectManager
128		{
129	6	$this->loadManagers();
130
131	6	$name = $name ?? $this->getDefaultManagerName();
132
133	6	if (!isset($this->originalManagers[$name])) {
134	1	throw new \InvalidArgumentException(sprintf('Missing manager with name "%s".', $name));
135		}
136
137	5	if (isset($this->resetedManagers[$name])) {
138	1	return $this->resetedManagers[$name];
139		}
140
141	4	return $this->originalManagers[$name];
142		}
143
144		/**
145		* @return EntityManager[]\|ObjectManager[]
146		*/
147	2	public function getManagers(): array
148		{
149	2	$this->loadManagers();
150
151	2	$managers = array();
152	2	foreach ($this->originalManagers->keys() as $name) {
153	2	if (isset($this->resetedManagers[$name])) {
154	1	$manager = $this->resetedManagers[$name];
155		} else {
156	1	$manager = $this->originalManagers[$name];
157		}
158
159	2	$managers[$name] = $manager;
160		}
161
162	2	return $managers;
163		}
164
165		/**
166		* @return array
167		*/
168	3	public function getManagerNames(): array
169		{
170	3	$this->loadManagers();
171
172	3	return $this->originalManagers->keys();
173		}
174
175		/**
176		* @param string\|null $name
177		*
178		* @return EntityManager\|ObjectManager
179		*/
180	2	public function resetManager($name = null)
181		{
182	2	$this->loadManagers();
183
184	2	$name = $name ?? $this->getDefaultManagerName();
185
186	2	if (!isset($this->originalManagers[$name])) {
187	1	throw new \InvalidArgumentException(sprintf('Missing manager with name "%s".', $name));
188		}
189
190	1	$originalManager = $this->originalManagers[$name];
191
192	1	$this->resetedManagers[$name] = EntityManager::create(
193	1	$originalManager->getConnection(),
194	1	$originalManager->getConfiguration(),
195	1	$originalManager->getEventManager()
196		);
197
198	1	return $this->resetedManagers[$name];
199		}
200
201		/**
202		* @param string $alias
203		*
204		* @return string
205		*
206		* @throws ORMException
207		*/
208	2	public function getAliasNamespace($alias): string
209		{
210	2	foreach ($this->getManagerNames() as $name) {
211		try {
212	2	return $this->getManager($name)->getConfiguration()->getEntityNamespace($alias);
		0 ignored issues – show Bug introduced 2018-06-02 15:02 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Doctrine\Common\Persistence\ObjectManager` as the method `getConfiguration()` does only exist in the following implementations of said interface: `Doctrine\ORM\Decorator\EntityManagerDecorator`, `Doctrine\ORM\EntityManager`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
213	1	} catch (ORMException $e) {
214		// throw the exception only if no manager can solve it
215		}
216		}
217	1	throw ORMException::unknownEntityNamespace($alias);
218		}
219
220		/**
221		* @param string $persistentObject
222		* @param null $persistentManagerName
223		*
224		* @return EntityRepository\|ObjectRepository
225		*/
226	1	public function getRepository($persistentObject, $persistentManagerName = null): ObjectRepository
227		{
228	1	return $this->getManager($persistentManagerName)->getRepository($persistentObject);
229		}
230
231		/**
232		* @param string $class
233		*
234		* @return EntityManager\|ObjectManager\|null
235		*/
236		public function getManagerForClass($class)
237		{
238		$proxyClass = new \ReflectionClass($class);
239		if ($proxyClass->implementsInterface(Proxy::class)) {
240		$class = $proxyClass->getParentClass()->getName();
241		}
242
243		foreach ($this->getManagerNames() as $name) {
244		if (!$this->getManager($name)->getMetadataFactory()->isTransient($class)) {
245		return $this->getManager($name);
246		}
247		}
248		}
249
250	5	private function loadConnections()
251		{
252	5	if (null === $this->connections) {
253	5	$this->connections = $this->container['doctrine.dbal.dbs'];
254	5	$this->defaultConnectionName = $this->container['doctrine.dbal.dbs.default'];
255		}
256	5	}
257
258	12	private function loadManagers()
259		{
260	12	if (null === $this->originalManagers) {
261	12	$this->originalManagers = $this->container['doctrine.orm.ems'];
262	12	$this->defaultManagerName = $this->container['doctrine.orm.ems.default'];
263		}
264	12	}
265		}
266

chubbyphp / chubbyphp-service-provider

Push — master ( e42f4b...a9b120 )

DoctrineOrmManagerRegistry::getManager() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like