AbstractEntityRepository::findAll() - Code Metrics - Inspection of "Required relations" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#152)

by joseph

created 2018-10-29 17:36 UTC

AbstractEntityRepository::findAll() A

↳ Parent: AbstractEntityRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	3
cp	0
crap	2
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			public function __construct(
75			EntityManagerInterface $entityManager,
76			EntityFactoryInterface $entityFactory,
77			NamespaceHelper $namespaceHelper
78			) {
79			$this->entityManager = $entityManager;
80			$this->namespaceHelper = $namespaceHelper;
81			$this->entityFactory = $entityFactory;
82			$this->initRepository();
83			}
84
85			protected function initRepository(): void
86			{
87			if (null === $this->metaData) {
88			$entityFqn = $this->getEntityFqn();
89			$this->metaData = $this->entityManager->getClassMetadata($entityFqn);
90			}
91
92			$this->entityRepository = new EntityRepository($this->entityManager, $this->metaData);
93			}
94
95			protected function getEntityFqn(): string
96			{
97			return '\\' . \str_replace(
98			[
99			'Entity\\Repositories',
100			],
101			[
102			'Entities',
103			],
104			$this->namespaceHelper->cropSuffix(static::class, 'Repository')
105			);
106			}
107
108			/**
109			* @return array\|EntityInterface[]
110			*/
111			public function findAll(): array
112			{
113			return $this->initialiseEntities($this->entityRepository->findAll());
114			}
115
116			private function initialiseEntities($entities)
117			{
118			foreach ($entities as $entity) {
119			$this->initialiseEntity($entity);
120			}
121
122			return $entities;
123			}
124
125			private function initialiseEntity(EntityInterface $entity)
126			{
127			$this->entityFactory->initialiseEntity($entity);
128
129			return $entity;
130			}
131
132			/**
133			* @return array\|EntityInterface[]
134			*/
135			public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
136			{
137			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			public function get($id, ?int $lockMode = null, ?int $lockVersion = null)
149			{
150			try {
151			$entity = $this->find($id, $lockMode, $lockVersion);
152			} catch (ConversionException $e) {
153			$error = 'Failed getting by id ' . $id
154			. ', unless configured as an int ID entity, this should be a valid UUID';
155			throw new DoctrineStaticMetaException($error, $e->getCode(), $e);
156			}
157			if ($entity === null) {
158			throw new DoctrineStaticMetaException('Could not find the entity with id ' . $id);
159			}
160
161			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			public function find($id, ?int $lockMode = null, ?int $lockVersion = null)
172			{
173			$entity = $this->entityRepository->find($id, $lockMode, $lockVersion);
174			if (null === $entity) {
175			return null;
176			}
177			if ($entity instanceof EntityInterface) {
178			$this->initialiseEntity($entity);
179
180			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			public function findOneBy(array $criteria, ?array $orderBy = null)
207			{
208			$entity = $this->entityRepository->findOneBy($criteria, $orderBy);
209			if (null === $entity) {
210			return null;
211			}
212			if ($entity instanceof EntityInterface) {
213			$this->initialiseEntity($entity);
214
215			return $entity;
216			}
217			}
218
219			public function getClassName(): string
220			{
221			return $this->entityRepository->getClassName();
222			}
223
224			public function matching(Criteria $criteria): LazyCriteriaCollection
225			{
226			$collection = $this->entityRepository->matching($criteria);
227			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			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			public function createQueryBuilder(string $alias, string $indexBy = null): QueryBuilder
233			{
234			return $this->entityRepository->createQueryBuilder($alias, $indexBy);
235			}
236
237			public function createResultSetMappingBuilder(string $alias): Query\ResultSetMappingBuilder
238			{
239			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			public function clear(): void
253			{
254			$this->entityRepository->clear();
255			}
256
257			public function count(array $criteria = []): int
258			{
259			return $this->entityRepository->count($criteria);
260			}
261			}
262

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#152)

AbstractEntityRepository::findAll() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like