AbstractEntityRepository::createNativeNamedQuery() - Code Metrics - Inspection of "UUID field type" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#131)

by joseph

created 2018-09-07 17:43 UTC

AbstractEntityRepository::createNativeNamedQuery() 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
dl	0
loc	3
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1
crap	2

<?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\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;

    /**
     * AbstractEntityRepositoryFactory constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param ClassMetadata|null     $metaData
     * @param NamespaceHelper|null   $namespaceHelper
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        ?ClassMetadata $metaData = null,
        ?NamespaceHelper $namespaceHelper = null
    ) {
        $this->entityManager   = $entityManager;
        $this->metaData        = $metaData;
        $this->namespaceHelper = ($namespaceHelper ?? new NamespaceHelper());
        $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->entityRepository->findAll();
    }

    /**
     * @return array|EntityInterface[]
     */
    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
    {
        return $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);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        } 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 $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 || $entity instanceof EntityInterface) {
            return $entity;
        }
    }

    /**
     * @param array      $criteria
     * @param array|null $orderBy
     *
     * @return EntityInterface
     */
    public function getOneBy(array $criteria, ?array $orderBy = null)
    {
        $result = $this->findOneBy($criteria, $orderBy);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        if ($result === null) {

            throw new \RuntimeException('Could not find the entity');
        }

        return $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 || $entity instanceof EntityInterface) {
            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 $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\Interfaces\EntityInterface;
16		use EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException;
17
18		/**
19		* Class AbstractEntityRepository
20		*
21		* This provides a base class that handles instantiating the correctly configured EntityRepository and provides an
22		* extensible baseline for further customisation
23		*
24		* We have extracted an interface from the standard Doctrine EntityRepository and implemented that
25		* However, so we can add type safety, we can't "actually" implement it
26		*
27		* We have also deliberately left out the magic calls. Please make real methods in your concrete repository class
28		*
29		* Note, there are quite a few PHPMD warnings, however it needs to respect the legacy interface so they are being
30		* suppressed
31		*
32		* @package EdmondsCommerce\DoctrineStaticMeta\Entity\Repositories
33		* @SuppressWarnings(PHPMD.TooManyPublicMethods)
34		* @SuppressWarnings(PHPMD.ExcessivePublicCount)
35		* @SuppressWarnings(PHPMD.NumberOfChildren)
36		* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
37		*/
38		abstract class AbstractEntityRepository implements EntityRepositoryInterface
39		{
40		/**
41		* @var EntityManagerInterface
42		*/
43		protected $entityManager;
44		/**
45		* @var EntityRepository
46		*/
47		protected $entityRepository;
48		/**
49		* @var string
50		*/
51		protected $repositoryFactoryFqn;
52		/**
53		* @var ClassMetadata\|null
54		*/
55		protected $metaData;
56		/**
57		* @var NamespaceHelper
58		*/
59		protected $namespaceHelper;
60
61		/**
62		* AbstractEntityRepositoryFactory constructor.
63		*
64		* @param EntityManagerInterface $entityManager
65		* @param ClassMetadata\|null $metaData
66		* @param NamespaceHelper\|null $namespaceHelper
67		*/
68	3	public function __construct(
69		EntityManagerInterface $entityManager,
70		?ClassMetadata $metaData = null,
71		?NamespaceHelper $namespaceHelper = null
72		) {
73	3	$this->entityManager = $entityManager;
74	3	$this->metaData = $metaData;
75	3	$this->namespaceHelper = ($namespaceHelper ?? new NamespaceHelper());
76	3	$this->initRepository();
77	3	}
78
79	2	protected function initRepository(): void
80		{
81	2	if (null === $this->metaData) {
82	2	$entityFqn = $this->getEntityFqn();
83	2	$this->metaData = $this->entityManager->getClassMetadata($entityFqn);
84		}
85
86	2	$this->entityRepository = new EntityRepository($this->entityManager, $this->metaData);
87	2	}
88
89	2	protected function getEntityFqn(): string
90		{
91	2	return '\\' . \str_replace(
92		[
93	2	'Entity\\Repositories',
94		],
95		[
96	2	'Entities',
97		],
98	2	$this->namespaceHelper->cropSuffix(static::class, 'Repository')
99		);
100		}
101
102		/**
103		* @return array\|EntityInterface[]
104		*/
105	1	public function findAll(): array
106		{
107	1	return $this->entityRepository->findAll();
108		}
109
110		/**
111		* @return array\|EntityInterface[]
112		*/
113	1	public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
114		{
115	1	return $this->entityRepository->findBy($criteria, $orderBy, $limit, $offset);
116		}
117
118		/**
119		* @param mixed $id
120		* @param int\|null $lockMode
121		* @param int\|null $lockVersion
122		*
123		* @return EntityInterface
124		* @throws DoctrineStaticMetaException
125		*/
126	2	public function get($id, ?int $lockMode = null, ?int $lockVersion = null)
127		{
128		try {
129	2	$entity = $this->find($id, $lockMode, $lockVersion);
		0 ignored issues – show Bug introduced 2018-08-24 15:41 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$entity` is correct as `$this->find($id, $lockMode, $lockVersion)` targeting `EdmondsCommerce\Doctrine...ntityRepository::find()` seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
130	1	} catch (ConversionException $e) {
131	1	$error = 'Failed getting by id ' . $id
132	1	. ', unless configured as an int ID entity, this should be a valid UUID';
133	1	throw new DoctrineStaticMetaException($error, $e->getCode(), $e);
134		}
135	1	if ($entity === null) {
		0 ignored issues – show introduced 2018-09-07 18:17 UTC by Report Bug Copy Issue Report The condition `$entity === null` is always `true`. Loading history...
136		throw new DoctrineStaticMetaException('Could not find the entity with id ' . $id);
137		}
138
139	1	return $entity;
140		}
141
142		/**
143		* @param mixed $id
144		* @param int\|null $lockMode
145		* @param int\|null $lockVersion
146		*
147		* @return EntityInterface\|null
148		*/
149	1	public function find($id, ?int $lockMode = null, ?int $lockVersion = null)
150		{
151	1	$entity = $this->entityRepository->find($id, $lockMode, $lockVersion);
152	1	if (null === $entity \|\| $entity instanceof EntityInterface) {
153	1	return $entity;
154		}
155		}
156
157		/**
158		* @param array $criteria
159		* @param array\|null $orderBy
160		*
161		* @return EntityInterface
162		*/
163		public function getOneBy(array $criteria, ?array $orderBy = null)
164		{
165		$result = $this->findOneBy($criteria, $orderBy);
		0 ignored issues – show Bug introduced 2018-08-24 15:41 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$result` is correct as `$this->findOneBy($criteria, $orderBy)` targeting `EdmondsCommerce\Doctrine...Repository::findOneBy()` seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
166		if ($result === null) {
		0 ignored issues – show introduced 2018-08-24 15:41 UTC by Report Bug Copy Issue Report The condition `$result === null` is always `true`. Loading history...
167		throw new \RuntimeException('Could not find the entity');
168		}
169
170		return $result;
171		}
172
173		/**
174		* @param array $criteria
175		* @param array\|null $orderBy
176		*
177		* @return EntityInterface\|null
178		*/
179	1	public function findOneBy(array $criteria, ?array $orderBy = null)
180		{
181	1	$entity = $this->entityRepository->findOneBy($criteria, $orderBy);
182	1	if (null === $entity \|\| $entity instanceof EntityInterface) {
183	1	return $entity;
184		}
185		}
186
187	2	public function getClassName(): string
188		{
189	2	return $this->entityRepository->getClassName();
190		}
191
192	1	public function matching(Criteria $criteria): LazyCriteriaCollection
193		{
194	1	$collection = $this->entityRepository->matching($criteria);
195	1	if ($collection instanceof LazyCriteriaCollection) {
		0 ignored issues – show introduced 2018-07-25 17:51 UTC by Report Bug Copy Issue Report `$collection` is always a sub-type of `Doctrine\ORM\LazyCriteriaCollection`. Loading history...
196	1	return $collection;
197		}
		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 195 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...
198		}
199
200	1	public function createQueryBuilder(string $alias, string $indexBy = null): QueryBuilder
201		{
202	1	return $this->entityRepository->createQueryBuilder($alias, $indexBy);
203		}
204
205	1	public function createResultSetMappingBuilder(string $alias): Query\ResultSetMappingBuilder
206		{
207	1	return $this->entityRepository->createResultSetMappingBuilder($alias);
208		}
209
210		public function createNamedQuery(string $queryName): Query
211		{
212		return $this->entityRepository->createNamedQuery($queryName);
213		}
214
215		public function createNativeNamedQuery(string $queryName): NativeQuery
216		{
217		return $this->entityRepository->createNativeNamedQuery($queryName);
218		}
219
220	1	public function clear(): void
221		{
222	1	$this->entityRepository->clear();
223	1	}
224
225	1	public function count(array $criteria): int
226		{
227	1	return $this->entityRepository->count($criteria);
228		}
229		}
230

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#131)

AbstractEntityRepository::createNativeNamedQuery() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like