AbstractEntityRepository::matching() - Code Metrics - Inspection of "Snags and tweaks pending version 6" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#154)

by Ross

created 2018-11-29 15:42 UTC

AbstractEntityRepository::matching() A

↳ Parent: AbstractEntityRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.032

Importance

Changes

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	5
ccs	4
cts	5
cp	0.8
crap	2.032
rs	10
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories;

use Doctrine\Common\Collections\Criteria;
use Doctrine\DBAL\Types\ConversionException;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\LazyCriteriaCollection;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\NativeQuery;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactory;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactoryInterface;
use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
use EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException;

/**
 * Class AbstractEntityRepository
 *
 * This provides a base class that handles instantiating the correctly configured EntityRepository and provides an
 * extensible baseline for further customisation
 *
 * We have extracted an interface from the standard Doctrine EntityRepository and implemented that
 * However, so we can add type safety, we can't "actually" implement it
 *
 * We have also deliberately left out the magic calls. Please make real methods in your concrete repository class
 *
 * Note, there are quite a few PHPMD warnings, however it needs to respect the legacy interface so they are being
 * suppressed
 *
 * @package EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 * @SuppressWarnings(PHPMD.ExcessivePublicCount)
 * @SuppressWarnings(PHPMD.NumberOfChildren)
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
abstract class AbstractEntityRepository implements EntityRepositoryInterface
{
    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;
    /**
     * @var EntityRepository
     */
    protected $entityRepository;
    /**
     * @var string
     */
    protected $repositoryFactoryFqn;
    /**
     * @var ClassMetadata|null
     */
    protected $metaData;
    /**
     * @var NamespaceHelper
     */
    protected $namespaceHelper;
    /**
     * @var EntityFactoryInterface
     */
    private $entityFactory;

    /**
     * AbstractEntityRepositoryFactory constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param EntityFactoryInterface $entityFactory
     * @param NamespaceHelper|null   $namespaceHelper
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        EntityFactoryInterface $entityFactory,
        NamespaceHelper $namespaceHelper
    ) {
        $this->entityManager   = $entityManager;
        $this->namespaceHelper = $namespaceHelper;
        $this->entityFactory   = $entityFactory;
        $this->initRepository();
    }

    protected function initRepository(): void
    {
        if (null === $this->metaData) {
            $entityFqn      = $this->getEntityFqn();
            $this->metaData = $this->entityManager->getClassMetadata($entityFqn);
        }

        $this->entityRepository = new EntityRepository($this->entityManager, $this->metaData);
    }

    protected function getEntityFqn(): string
    {
        return '\\' . \str_replace(
            [
                    'Entity\\Repositories',
                ],
            [
                    'Entities',
                ],
            $this->namespaceHelper->cropSuffix(static::class, 'Repository')
        );
    }

    /**
     * @return array|EntityInterface[]
     */
    public function findAll(): array
    {
        return $this->initialiseEntities($this->entityRepository->findAll());
    }

    private function initialiseEntities($entities)
    {
        foreach ($entities as $entity) {
            $this->initialiseEntity($entity);
        }

        return $entities;
    }

    private function initialiseEntity(EntityInterface $entity)
    {
        $this->entityFactory->initialiseEntity($entity);

        return $entity;
    }

    /**
     * @return array|EntityInterface[]
     */
    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
    {
        return $this->initialiseEntities($this->entityRepository->findBy($criteria, $orderBy, $limit, $offset));
    }

    /**
     * @param mixed    $id
     * @param int|null $lockMode
     * @param int|null $lockVersion
     *
     * @return EntityInterface
     * @throws DoctrineStaticMetaException
     */
    public function get($id, ?int $lockMode = null, ?int $lockVersion = null)
    {
        try {
            $entity = $this->find($id, $lockMode, $lockVersion);
        } catch (ConversionException $e) {
            $error = 'Failed getting by id ' . $id
                     . ', unless configured as an int ID entity, this should be a valid UUID';
            throw new DoctrineStaticMetaException($error, $e->getCode(), $e);
        }
        if ($entity === null) {
            throw new DoctrineStaticMetaException('Could not find the entity with id ' . $id);
        }

        return $this->initialiseEntity($entity);
    }

    /**
     * @param mixed    $id
     * @param int|null $lockMode
     * @param int|null $lockVersion
     *
     * @return EntityInterface|null
     */
    public function find($id, ?int $lockMode = null, ?int $lockVersion = null)
    {
        $entity = $this->entityRepository->find($id, $lockMode, $lockVersion);
        if (null === $entity) {
            return null;
        }
        if ($entity instanceof EntityInterface) {
            $this->initialiseEntity($entity);

            return $entity;
        }
    }

    /**
     * @param array      $criteria
     * @param array|null $orderBy
     *
     * @return EntityInterface
     */
    public function getOneBy(array $criteria, ?array $orderBy = null)
    {
        $result = $this->findOneBy($criteria, $orderBy);
        if ($result === null) {
            throw new \RuntimeException('Could not find the entity');
        }

        return $this->initialiseEntity($result);
    }

    /**
     * @param array      $criteria
     * @param array|null $orderBy
     *
     * @return EntityInterface|null
     */
    public function findOneBy(array $criteria, ?array $orderBy = null)
    {
        $entity = $this->entityRepository->findOneBy($criteria, $orderBy);
        if (null === $entity) {
            return null;
        }
        if ($entity instanceof EntityInterface) {
            $this->initialiseEntity($entity);

            return $entity;
        }
    }

    public function getClassName(): string
    {
        return $this->entityRepository->getClassName();
    }

    public function matching(Criteria $criteria): LazyCriteriaCollection
    {
        $collection = $this->entityRepository->matching($criteria);
        if ($collection instanceof LazyCriteriaCollection) {

            return $this->initialiseEntities($collection);
        }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }

    public function createQueryBuilder(string $alias, string $indexBy = null): QueryBuilder
    {
        return $this->entityRepository->createQueryBuilder($alias, $indexBy);
    }

    public function createResultSetMappingBuilder(string $alias): Query\ResultSetMappingBuilder
    {
        return $this->entityRepository->createResultSetMappingBuilder($alias);
    }

    public function createNamedQuery(string $queryName): Query
    {
        return $this->entityRepository->createNamedQuery($queryName);
    }

    public function createNativeNamedQuery(string $queryName): NativeQuery
    {
        return $this->entityRepository->createNativeNamedQuery($queryName);
    }

    public function clear(): void
    {
        $this->entityRepository->clear();
    }

    public function count(array $criteria = []): int
    {
        return $this->entityRepository->count($criteria);
    }
}


1		<?php declare(strict_types=1);
2
3		namespace EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories;
4
5		use Doctrine\Common\Collections\Criteria;
6		use Doctrine\DBAL\Types\ConversionException;
7		use Doctrine\ORM\EntityManagerInterface;
8		use Doctrine\ORM\EntityRepository;
9		use Doctrine\ORM\LazyCriteriaCollection;
10		use Doctrine\ORM\Mapping\ClassMetadata;
11		use Doctrine\ORM\NativeQuery;
12		use Doctrine\ORM\Query;
13		use Doctrine\ORM\QueryBuilder;
14		use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
15		use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactory;
16		use EdmondsCommerce\DoctrineStaticMeta\Entity\Factory\EntityFactoryInterface;
17		use EdmondsCommerce\DoctrineStaticMeta\Entity\Interfaces\EntityInterface;
18		use EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException;
19
20		/**
21		* Class AbstractEntityRepository
22		*
23		* This provides a base class that handles instantiating the correctly configured EntityRepository and provides an
24		* extensible baseline for further customisation
25		*
26		* We have extracted an interface from the standard Doctrine EntityRepository and implemented that
27		* However, so we can add type safety, we can't "actually" implement it
28		*
29		* We have also deliberately left out the magic calls. Please make real methods in your concrete repository class
30		*
31		* Note, there are quite a few PHPMD warnings, however it needs to respect the legacy interface so they are being
32		* suppressed
33		*
34		* @package EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories
35		* @SuppressWarnings(PHPMD.TooManyPublicMethods)
36		* @SuppressWarnings(PHPMD.ExcessivePublicCount)
37		* @SuppressWarnings(PHPMD.NumberOfChildren)
38		* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
39		*/
40		abstract class AbstractEntityRepository implements EntityRepositoryInterface
41		{
42		/**
43		* @var EntityManagerInterface
44		*/
45		protected $entityManager;
46		/**
47		* @var EntityRepository
48		*/
49		protected $entityRepository;
50		/**
51		* @var string
52		*/
53		protected $repositoryFactoryFqn;
54		/**
55		* @var ClassMetadata\|null
56		*/
57		protected $metaData;
58		/**
59		* @var NamespaceHelper
60		*/
61		protected $namespaceHelper;
62		/**
63		* @var EntityFactoryInterface
64		*/
65		private $entityFactory;
66
67		/**
68		* AbstractEntityRepositoryFactory constructor.
69		*
70		* @param EntityManagerInterface $entityManager
71		* @param EntityFactoryInterface $entityFactory
72		* @param NamespaceHelper\|null $namespaceHelper
73		*/
74	14	public function __construct(
75		EntityManagerInterface $entityManager,
76		EntityFactoryInterface $entityFactory,
77		NamespaceHelper $namespaceHelper
78		) {
79	14	$this->entityManager = $entityManager;
80	14	$this->namespaceHelper = $namespaceHelper;
81	14	$this->entityFactory = $entityFactory;
82	14	$this->initRepository();
83	14	}
84
85	14	protected function initRepository(): void
86		{
87	14	if (null === $this->metaData) {
88	14	$entityFqn = $this->getEntityFqn();
89	14	$this->metaData = $this->entityManager->getClassMetadata($entityFqn);
90		}
91
92	14	$this->entityRepository = new EntityRepository($this->entityManager, $this->metaData);
93	14	}
94
95	14	protected function getEntityFqn(): string
96		{
97	14	return '\\' . \str_replace(
98		[
99	14	'Entity\\Repositories',
100		],
101		[
102	14	'Entities',
103		],
104	14	$this->namespaceHelper->cropSuffix(static::class, 'Repository')
105		);
106		}
107
108		/**
109		* @return array\|EntityInterface[]
110		*/
111	1	public function findAll(): array
112		{
113	1	return $this->initialiseEntities($this->entityRepository->findAll());
114		}
115
116	3	private function initialiseEntities($entities)
117		{
118	3	foreach ($entities as $entity) {
119	3	$this->initialiseEntity($entity);
120		}
121
122	3	return $entities;
123		}
124
125	7	private function initialiseEntity(EntityInterface $entity)
126		{
127	7	$this->entityFactory->initialiseEntity($entity);
128
129	7	return $entity;
130		}
131
132		/**
133		* @return array\|EntityInterface[]
134		*/
135	1	public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
136		{
137	1	return $this->initialiseEntities($this->entityRepository->findBy($criteria, $orderBy, $limit, $offset));
138		}
139
140		/**
141		* @param mixed $id
142		* @param int\|null $lockMode
143		* @param int\|null $lockVersion
144		*
145		* @return EntityInterface
146		* @throws DoctrineStaticMetaException
147		*/
148	2	public function get($id, ?int $lockMode = null, ?int $lockVersion = null)
149		{
150		try {
151	2	$entity = $this->find($id, $lockMode, $lockVersion);
152	1	} catch (ConversionException $e) {
153	1	$error = 'Failed getting by id ' . $id
154	1	. ', unless configured as an int ID entity, this should be a valid UUID';
155	1	throw new DoctrineStaticMetaException($error, $e->getCode(), $e);
156		}
157	1	if ($entity === null) {
158		throw new DoctrineStaticMetaException('Could not find the entity with id ' . $id);
159		}
160
161	1	return $this->initialiseEntity($entity);
162		}
163
164		/**
165		* @param mixed $id
166		* @param int\|null $lockMode
167		* @param int\|null $lockVersion
168		*
169		* @return EntityInterface\|null
170		*/
171	3	public function find($id, ?int $lockMode = null, ?int $lockVersion = null)
172		{
173	3	$entity = $this->entityRepository->find($id, $lockMode, $lockVersion);
174	2	if (null === $entity) {
175		return null;
176		}
177	2	if ($entity instanceof EntityInterface) {
178	2	$this->initialiseEntity($entity);
179
180	2	return $entity;
181		}
182		}
183
184		/**
185		* @param array $criteria
186		* @param array\|null $orderBy
187		*
188		* @return EntityInterface
189		*/
190		public function getOneBy(array $criteria, ?array $orderBy = null)
191		{
192		$result = $this->findOneBy($criteria, $orderBy);
193		if ($result === null) {
194		throw new \RuntimeException('Could not find the entity');
195		}
196
197		return $this->initialiseEntity($result);
198		}
199
200		/**
201		* @param array $criteria
202		* @param array\|null $orderBy
203		*
204		* @return EntityInterface\|null
205		*/
206	3	public function findOneBy(array $criteria, ?array $orderBy = null)
207		{
208	3	$entity = $this->entityRepository->findOneBy($criteria, $orderBy);
209	3	if (null === $entity) {
210	1	return null;
211		}
212	2	if ($entity instanceof EntityInterface) {
213	2	$this->initialiseEntity($entity);
214
215	2	return $entity;
216		}
217		}
218
219	1	public function getClassName(): string
220		{
221	1	return $this->entityRepository->getClassName();
222		}
223
224	1	public function matching(Criteria $criteria): LazyCriteriaCollection
225		{
226	1	$collection = $this->entityRepository->matching($criteria);
227	1	if ($collection instanceof LazyCriteriaCollection) {
		0 ignored issues – show introduced 2018-10-29 16:55 UTC by Report Bug Copy Issue Report `$collection` is always a sub-type of `Doctrine\ORM\LazyCriteriaCollection`. Loading history...
228	1	return $this->initialiseEntities($collection);
229		}
		0 ignored issues – show Bug Best Practice introduced 2018-08-22 20:10 UTC by Report Bug Copy Issue Report The function implicitly returns `null` when the `if` condition on line 227 is `false`. This is incompatible with the type-hinted return `Doctrine\ORM\LazyCriteriaCollection`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
230		}
231
232	1	public function createQueryBuilder(string $alias, string $indexBy = null): QueryBuilder
233		{
234	1	return $this->entityRepository->createQueryBuilder($alias, $indexBy);
235		}
236
237	1	public function createResultSetMappingBuilder(string $alias): Query\ResultSetMappingBuilder
238		{
239	1	return $this->entityRepository->createResultSetMappingBuilder($alias);
240		}
241
242		public function createNamedQuery(string $queryName): Query
243		{
244		return $this->entityRepository->createNamedQuery($queryName);
245		}
246
247		public function createNativeNamedQuery(string $queryName): NativeQuery
248		{
249		return $this->entityRepository->createNativeNamedQuery($queryName);
250		}
251
252	1	public function clear(): void
253		{
254	1	$this->entityRepository->clear();
255	1	}
256
257	1	public function count(array $criteria = []): int
258		{
259	1	return $this->entityRepository->count($criteria);
260		}
261		}
262

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#154)

AbstractEntityRepository::matching() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like