GraphLookup::alias() - Code Metrics - Inspection of "Merge pull request #1958 from Seb33300/patch-1" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7b9f4b...1cd743 )

by Andreas

created 2019-02-15 05:34 UTC

GraphLookup::alias() A

↳ Parent: GraphLookup

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace Doctrine\ODM\MongoDB\Aggregation\Stage;

use Doctrine\Common\Persistence\Mapping\MappingException as BaseMappingException;
use Doctrine\ODM\MongoDB\Aggregation\Builder;
use Doctrine\ODM\MongoDB\Aggregation\Expr;
use Doctrine\ODM\MongoDB\Aggregation\Stage;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use Doctrine\ODM\MongoDB\Mapping\MappingException;
use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
use Doctrine\ODM\MongoDB\Types\Type;
use LogicException;
use function array_map;
use function is_array;
use function is_string;
use function substr;

class GraphLookup extends Stage
{
    /** @var string */
    private $from;

    /** @var string|Expr|array */
    private $startWith;

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

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

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

    /** @var int */
    private $maxDepth;

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

    /** @var Stage\GraphLookup\Match */
    private $restrictSearchWithMatch;

    /** @var DocumentManager */
    private $dm;

    /** @var ClassMetadata */
    private $class;

    /** @var ClassMetadata|null */
    private $targetClass;

    /**
     * @param string $from Target collection for the $graphLookup operation to
     * search, recursively matching the connectFromField to the connectToField.
     */
    public function __construct(Builder $builder, string $from, DocumentManager $documentManager, ClassMetadata $class)
    {
        parent::__construct($builder);

        $this->dm                      = $documentManager;
        $this->class                   = $class;
        $this->restrictSearchWithMatch = new GraphLookup\Match($this->builder, $this);
        $this->from($from);
    }

    /**
     * Name of the array field added to each output document.
     *
     * Contains the documents traversed in the $graphLookup stage to reach the
     * document.
     */
    public function alias(string $alias) : self
    {
        $this->as = $alias;

        return $this;
    }

    /**
     * Field name whose value $graphLookup uses to recursively match against the
     * connectToField of other documents in the collection.
     *
     * Optionally, connectFromField may be an array of field names, each of
     * which is individually followed through the traversal process.
     */
    public function connectFromField(string $connectFromField) : self
    {
        // No targetClass mapping - simply use field name as is
        if (! $this->targetClass) {
            $this->connectFromField = $connectFromField;
            return $this;
        }

        // connectFromField doesn't have to be a reference - in this case, just convert the field name
        if (! $this->targetClass->hasReference($connectFromField)) {
            $this->connectFromField = $this->convertTargetFieldName($connectFromField);
            return $this;
        }

        // connectFromField is a reference - do a sanity check
        $referenceMapping = $this->targetClass->getFieldMapping($connectFromField);
        if ($referenceMapping['targetDocument'] !== $this->targetClass->name) {
            throw MappingException::connectFromFieldMustReferenceSameDocument($connectFromField);
        }

        $this->connectFromField = $this->getReferencedFieldName($connectFromField, $referenceMapping);
        return $this;
    }

    /**
     * Field name in other documents against which to match the value of the
     * field specified by the connectFromField parameter.
     */
    public function connectToField(string $connectToField) : self
    {
        $this->connectToField = $this->convertTargetFieldName($connectToField);
        return $this;
    }

    /**
     * Name of the field to add to each traversed document in the search path.
     *
     * The value of this field is the recursion depth for the document,
     * represented as a NumberLong. Recursion depth value starts at zero, so the
     * first lookup corresponds to zero depth.
     */
    public function depthField(string $depthField) : self
    {
        $this->depthField = $depthField;

        return $this;
    }

    /**
     * Target collection for the $graphLookup operation to search, recursively
     * matching the connectFromField to the connectToField.
     *
     * The from collection cannot be sharded and must be in the same database as
     * any other collections used in the operation.
     */
    public function from(string $from) : self
    {
        // $from can either be
        // a) a field name indicating a reference to a different document. Currently, only REFERENCE_STORE_AS_ID is supported
        // b) a Class name
        // c) a collection name
        // In cases b) and c) the local and foreign fields need to be filled
        if ($this->class->hasReference($from)) {
            return $this->fromReference($from);
        }

        // Check if mapped class with given name exists
        try {
            $this->targetClass = $this->dm->getClassMetadata($from);

        } catch (BaseMappingException $e) {
            $this->from = $from;
            return $this;
        }

        if ($this->targetClass->isSharded()) {
            throw MappingException::cannotUseShardedCollectionInLookupStages($this->targetClass->name);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        $this->from = $this->targetClass->getCollection();
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getExpression() : array
    {
        $restrictSearchWithMatch = $this->restrictSearchWithMatch->getExpression() ?: (object) [];

        $graphLookup = [
            'from' => $this->from,
            'startWith' => $this->convertExpression($this->startWith),
            'connectFromField' => $this->connectFromField,
            'connectToField' => $this->connectToField,
            'as' => $this->as,
            'restrictSearchWithMatch' => $restrictSearchWithMatch,
            'maxDepth' => $this->maxDepth,
            'depthField' => $this->depthField,
        ];

        foreach (['maxDepth', 'depthField'] as $field) {
            if ($graphLookup[$field] !== null) {
                continue;
            }

            unset($graphLookup[$field]);
        }

        return ['$graphLookup' => $graphLookup];
    }

    /**
     * Non-negative integral number specifying the maximum recursion depth.
     */
    public function maxDepth(int $maxDepth) : self
    {
        $this->maxDepth = $maxDepth;

        return $this;
    }

    /**
     * A document specifying additional conditions for the recursive search.
     */
    public function restrictSearchWithMatch() : GraphLookup\Match
    {
        return $this->restrictSearchWithMatch;
    }

    /**
     * Expression that specifies the value of the connectFromField with which to
     * start the recursive search.
     *
     * Optionally, startWith may be array of values, each of which is
     * individually followed through the traversal process.
     *
     * @param string|array|Expr $expression
     */
    public function startWith($expression) : self
    {
        $this->startWith = $expression;

        return $this;
    }

    /**
     * @throws MappingException
     */
    private function fromReference(string $fieldName) : self
    {
        if (! $this->class->hasReference($fieldName)) {
            MappingException::referenceMappingNotFound($this->class->name, $fieldName);
        }

        $referenceMapping  = $this->class->getFieldMapping($fieldName);
        $this->targetClass = $this->dm->getClassMetadata($referenceMapping['targetDocument']);

        if ($this->targetClass->isSharded()) {
            throw MappingException::cannotUseShardedCollectionInLookupStages($this->targetClass->name);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        $this->from = $this->targetClass->getCollection();

        $referencedFieldName = $this->getReferencedFieldName($fieldName, $referenceMapping);

        if ($referenceMapping['isOwningSide']) {
            $this
                ->startWith('$' . $referencedFieldName)
                ->connectToField('_id');
        } else {
            $this
                ->startWith('$' . $referencedFieldName)
                ->connectToField('_id');
        }

        // A self-reference indicates that we can also fill the "connectFromField" accordingly
        if ($this->targetClass->name === $this->class->name) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $this->connectFromField($referencedFieldName);
        }

        return $this;
    }

    private function convertExpression($expression)

    {
        if (is_array($expression)) {
            return array_map([$this, 'convertExpression'], $expression);
        } elseif (is_string($expression) && substr($expression, 0, 1) === '$') {
            return '$' . $this->getDocumentPersister($this->class)->prepareFieldName(substr($expression, 1));
        }

        return Type::convertPHPToDatabaseValue(Expr::convertExpression($expression));
    }

    private function convertTargetFieldName($fieldName)
    {
        if (is_array($fieldName)) {
            return array_map([$this, 'convertTargetFieldName'], $fieldName);
        }

        if (! $this->targetClass) {
            return $fieldName;
        }

        return $this->getDocumentPersister($this->targetClass)->prepareFieldName($fieldName);
    }

    private function getDocumentPersister(ClassMetadata $class) : DocumentPersister
    {
        return $this->dm->getUnitOfWork()->getDocumentPersister($class->name);
    }

    private function getReferencedFieldName(string $fieldName, array $mapping) : string
    {
        if (! $this->targetClass) {
            throw new LogicException('Cannot use getReferencedFieldName when no target mapping was given.');
        }

        if (! $mapping['isOwningSide']) {
            if (isset($mapping['repositoryMethod']) || ! isset($mapping['mappedBy'])) {
                throw MappingException::repositoryMethodLookupNotAllowed($this->class->name, $fieldName);
            }

            $mapping = $this->targetClass->getFieldMapping($mapping['mappedBy']);
        }

        switch ($mapping['storeAs']) {
            case ClassMetadata::REFERENCE_STORE_AS_ID:
            case ClassMetadata::REFERENCE_STORE_AS_REF:
                return ClassMetadata::getReferenceFieldName($mapping['storeAs'], $mapping['name']);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            default:
                throw MappingException::cannotLookupDbRefReference($this->class->name, $fieldName);
        }
    }
}


Push — master ( 7b9f4b...1cd743 )

GraphLookup::alias() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ODM\MongoDB\Aggregation\Stage;
6
7			use Doctrine\Common\Persistence\Mapping\MappingException as BaseMappingException;
8			use Doctrine\ODM\MongoDB\Aggregation\Builder;
9			use Doctrine\ODM\MongoDB\Aggregation\Expr;
10			use Doctrine\ODM\MongoDB\Aggregation\Stage;
11			use Doctrine\ODM\MongoDB\DocumentManager;
12			use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
13			use Doctrine\ODM\MongoDB\Mapping\MappingException;
14			use Doctrine\ODM\MongoDB\Persisters\DocumentPersister;
15			use Doctrine\ODM\MongoDB\Types\Type;
16			use LogicException;
17			use function array_map;
18			use function is_array;
19			use function is_string;
20			use function substr;
21
22			class GraphLookup extends Stage
23			{
24			/** @var string */
25			private $from;
26
27			/** @var string\|Expr\|array */
28			private $startWith;
29
30			/** @var string */
31			private $connectFromField;
32
33			/** @var string */
34			private $connectToField;
35
36			/** @var string */
37			private $as;
38
39			/** @var int */
40			private $maxDepth;
41
42			/** @var string */
43			private $depthField;
44
45			/** @var Stage\GraphLookup\Match */
46			private $restrictSearchWithMatch;
47
48			/** @var DocumentManager */
49			private $dm;
50
51			/** @var ClassMetadata */
52			private $class;
53
54			/** @var ClassMetadata\|null */
55			private $targetClass;
56
57			/**
58			* @param string $from Target collection for the $graphLookup operation to
59			* search, recursively matching the connectFromField to the connectToField.
60			*/
61	11		public function __construct(Builder $builder, string $from, DocumentManager $documentManager, ClassMetadata $class)
62			{
63	11		parent::__construct($builder);
64
65	11		$this->dm = $documentManager;
66	11		$this->class = $class;
67	11		$this->restrictSearchWithMatch = new GraphLookup\Match($this->builder, $this);
68	11		$this->from($from);
69	10		}
70
71			/**
72			* Name of the array field added to each output document.
73			*
74			* Contains the documents traversed in the $graphLookup stage to reach the
75			* document.
76			*/
77	9		public function alias(string $alias) : self
78			{
79	9		$this->as = $alias;
80
81	9		return $this;
82			}
83
84			/**
85			* Field name whose value $graphLookup uses to recursively match against the
86			* connectToField of other documents in the collection.
87			*
88			* Optionally, connectFromField may be an array of field names, each of
89			* which is individually followed through the traversal process.
90			*/
91	10		public function connectFromField(string $connectFromField) : self
92			{
93			// No targetClass mapping - simply use field name as is
94	10		if (! $this->targetClass) {
95	4		$this->connectFromField = $connectFromField;
96	4		return $this;
97			}
98
99			// connectFromField doesn't have to be a reference - in this case, just convert the field name
100	6		if (! $this->targetClass->hasReference($connectFromField)) {
101	2		$this->connectFromField = $this->convertTargetFieldName($connectFromField);
102	2		return $this;
103			}
104
105			// connectFromField is a reference - do a sanity check
106	4		$referenceMapping = $this->targetClass->getFieldMapping($connectFromField);
107	4		if ($referenceMapping['targetDocument'] !== $this->targetClass->name) {
108	1		throw MappingException::connectFromFieldMustReferenceSameDocument($connectFromField);
109			}
110
111	3		$this->connectFromField = $this->getReferencedFieldName($connectFromField, $referenceMapping);
112	3		return $this;
113			}
114
115			/**
116			* Field name in other documents against which to match the value of the
117			* field specified by the connectFromField parameter.
118			*/
119	10		public function connectToField(string $connectToField) : self
120			{
121	10		$this->connectToField = $this->convertTargetFieldName($connectToField);
122	10		return $this;
123			}
124
125			/**
126			* Name of the field to add to each traversed document in the search path.
127			*
128			* The value of this field is the recursion depth for the document,
129			* represented as a NumberLong. Recursion depth value starts at zero, so the
130			* first lookup corresponds to zero depth.
131			*/
132	3		public function depthField(string $depthField) : self
133			{
134	3		$this->depthField = $depthField;
135
136	3		return $this;
137			}
138
139			/**
140			* Target collection for the $graphLookup operation to search, recursively
141			* matching the connectFromField to the connectToField.
142			*
143			* The from collection cannot be sharded and must be in the same database as
144			* any other collections used in the operation.
145			*/
146	11		public function from(string $from) : self
147			{
148			// $from can either be
149			// a) a field name indicating a reference to a different document. Currently, only REFERENCE_STORE_AS_ID is supported
150			// b) a Class name
151			// c) a collection name
152			// In cases b) and c) the local and foreign fields need to be filled
153	11		if ($this->class->hasReference($from)) {
154	6		return $this->fromReference($from);
155			}
156
157			// Check if mapped class with given name exists
158			try {
159	5		$this->targetClass = $this->dm->getClassMetadata($from);
			0 ignored issues – show Documentation Bug introduced 2019-02-15 03:37 UTC by Report Bug Copy Issue Report It seems like `$this->dm->getClassMetadata($from)` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is incompatible with the declared type `object<Doctrine\ODM\Mong...ing\ClassMetadata>\|null` of property `$targetClass`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
160	4		} catch (BaseMappingException $e) {
161	4		$this->from = $from;
162	4		return $this;
163			}
164
165	1		if ($this->targetClass->isSharded()) {
166	1		throw MappingException::cannotUseShardedCollectionInLookupStages($this->targetClass->name);
			0 ignored issues – show Bug introduced 2018-10-09 20:27 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
167			}
168
169			$this->from = $this->targetClass->getCollection();
170			return $this;
171			}
172
173			/**
174			* {@inheritdoc}
175			*/
176	9		public function getExpression() : array
177			{
178	9		$restrictSearchWithMatch = $this->restrictSearchWithMatch->getExpression() ?: (object) [];
179
180			$graphLookup = [
181	9		'from' => $this->from,
182	9		'startWith' => $this->convertExpression($this->startWith),
183	9		'connectFromField' => $this->connectFromField,
184	9		'connectToField' => $this->connectToField,
185	9		'as' => $this->as,
186	9		'restrictSearchWithMatch' => $restrictSearchWithMatch,
187	9		'maxDepth' => $this->maxDepth,
188	9		'depthField' => $this->depthField,
189			];
190
191	9		foreach (['maxDepth', 'depthField'] as $field) {
192	9		if ($graphLookup[$field] !== null) {
193	3		continue;
194			}
195
196	6		unset($graphLookup[$field]);
197			}
198
199	9		return ['$graphLookup' => $graphLookup];
200			}
201
202			/**
203			* Non-negative integral number specifying the maximum recursion depth.
204			*/
205	3		public function maxDepth(int $maxDepth) : self
206			{
207	3		$this->maxDepth = $maxDepth;
208
209	3		return $this;
210			}
211
212			/**
213			* A document specifying additional conditions for the recursive search.
214			*/
215	1		public function restrictSearchWithMatch() : GraphLookup\Match
216			{
217	1		return $this->restrictSearchWithMatch;
218			}
219
220			/**
221			* Expression that specifies the value of the connectFromField with which to
222			* start the recursive search.
223			*
224			* Optionally, startWith may be array of values, each of which is
225			* individually followed through the traversal process.
226			*
227			* @param string\|array\|Expr $expression
228			*/
229	10		public function startWith($expression) : self
230			{
231	10		$this->startWith = $expression;
232
233	10		return $this;
234			}
235
236			/**
237			* @throws MappingException
238			*/
239	6		private function fromReference(string $fieldName) : self
240			{
241	6		if (! $this->class->hasReference($fieldName)) {
242			MappingException::referenceMappingNotFound($this->class->name, $fieldName);
243			}
244
245	6		$referenceMapping = $this->class->getFieldMapping($fieldName);
246	6		$this->targetClass = $this->dm->getClassMetadata($referenceMapping['targetDocument']);
			0 ignored issues – show Documentation Bug introduced 2019-02-15 03:37 UTC by Report Bug Copy Issue Report It seems like `$this->dm->getClassMetad...ping['targetDocument'])` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is incompatible with the declared type `object<Doctrine\ODM\Mong...ing\ClassMetadata>\|null` of property `$targetClass`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
247	6		if ($this->targetClass->isSharded()) {
248			throw MappingException::cannotUseShardedCollectionInLookupStages($this->targetClass->name);
			0 ignored issues – show Bug introduced 2018-10-09 20:27 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
249			}
250
251	6		$this->from = $this->targetClass->getCollection();
252
253	6		$referencedFieldName = $this->getReferencedFieldName($fieldName, $referenceMapping);
254
255	6		if ($referenceMapping['isOwningSide']) {
256			$this
257	5		->startWith('$' . $referencedFieldName)
258	5		->connectToField('_id');
259			} else {
260			$this
261	1		->startWith('$' . $referencedFieldName)
262	1		->connectToField('_id');
263			}
264
265			// A self-reference indicates that we can also fill the "connectFromField" accordingly
266	6		if ($this->targetClass->name === $this->class->name) {
			0 ignored issues – show Bug introduced 2018-10-09 20:27 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
267	3		$this->connectFromField($referencedFieldName);
268			}
269
270	6		return $this;
271			}
272
273	9	View Code Duplication	private function convertExpression($expression)
			0 ignored issues – show Duplication introduced 2017-12-14 12:06 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
274			{
275	9		if (is_array($expression)) {
276			return array_map([$this, 'convertExpression'], $expression);
277	9		} elseif (is_string($expression) && substr($expression, 0, 1) === '$') {
278	9		return '$' . $this->getDocumentPersister($this->class)->prepareFieldName(substr($expression, 1));
279			}
280
281			return Type::convertPHPToDatabaseValue(Expr::convertExpression($expression));
282			}
283
284	10		private function convertTargetFieldName($fieldName)
285			{
286	10		if (is_array($fieldName)) {
287			return array_map([$this, 'convertTargetFieldName'], $fieldName);
288			}
289
290	10		if (! $this->targetClass) {
291	4		return $fieldName;
292			}
293
294	6		return $this->getDocumentPersister($this->targetClass)->prepareFieldName($fieldName);
295			}
296
297	10		private function getDocumentPersister(ClassMetadata $class) : DocumentPersister
298			{
299	10		return $this->dm->getUnitOfWork()->getDocumentPersister($class->name);
300			}
301
302	6		private function getReferencedFieldName(string $fieldName, array $mapping) : string
303			{
304	6		if (! $this->targetClass) {
305			throw new LogicException('Cannot use getReferencedFieldName when no target mapping was given.');
306			}
307
308	6		if (! $mapping['isOwningSide']) {
309	1		if (isset($mapping['repositoryMethod']) \|\| ! isset($mapping['mappedBy'])) {
310			throw MappingException::repositoryMethodLookupNotAllowed($this->class->name, $fieldName);
311			}
312
313	1		$mapping = $this->targetClass->getFieldMapping($mapping['mappedBy']);
314			}
315
316	6		switch ($mapping['storeAs']) {
317			case ClassMetadata::REFERENCE_STORE_AS_ID:
318			case ClassMetadata::REFERENCE_STORE_AS_REF:
319	6		return ClassMetadata::getReferenceFieldName($mapping['storeAs'], $mapping['name']);
320			break;
			0 ignored issues – show Unused Code introduced 2017-10-16 15:26 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
321
322			default:
323			throw MappingException::cannotLookupDbRefReference($this->class->name, $fieldName);
324			}
325			}
326			}
327

doctrine / mongodb-odm

Push — master ( 7b9f4b...1cd743 )

GraphLookup::alias() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like