AnnotationDriver::loadMetadataForClass() - Code Metrics - Inspection of "Fix bug when priming references nested in embedded..." - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0.x (#1416)

by Maciej

created 2016-05-29 12:19 UTC

AnnotationDriver::loadMetadataForClass() F

↳ Parent: AnnotationDriver

Complexity

Conditions	61
Paths	> 20000

Size

Total Lines	168
Code Lines	109

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	130
CRAP Score	61.4965

Importance

Changes

Metric	Value
dl	0
loc	168
ccs	130
cts	137
cp	0.9489
rs	2
c	0
b	0
f	0
cc	61
eloc	109
nc	8697650
nop	2
crap	61.4965

How to fix Long Method Complexity

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Mapping\Driver;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
use Doctrine\ODM\MongoDB\Events;
use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
use Doctrine\ODM\MongoDB\Mapping\MappingException;

/**
 * The AnnotationDriver reads the mapping metadata from docblock annotations.
 *
 * @since       1.0
 * @author      Jonathan H. Wage <[email protected]>
 * @author      Roman Borschel <[email protected]>
 */
class AnnotationDriver extends AbstractAnnotationDriver
{
    protected $entityAnnotationClasses = array(
        'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Document' => 1,
        'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\MappedSuperclass' => 2,
        'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\EmbeddedDocument' => 3,
    );

    /**
     * Registers annotation classes to the common registry.
     *
     * This method should be called when bootstrapping your application.
     */
    public static function registerAnnotationClasses()
    {
        AnnotationRegistry::registerFile(__DIR__ . '/../Annotations/DoctrineAnnotations.php');
    }

    /**
     * {@inheritdoc}
     */
    public function loadMetadataForClass($className, ClassMetadata $class)
    {
        /** @var $class ClassMetadataInfo */
        $reflClass = $class->getReflectionClass();

        $classAnnotations = $this->reader->getClassAnnotations($reflClass);

        $documentAnnots = array();
        foreach ($classAnnotations as $annot) {
            $classAnnotations[get_class($annot)] = $annot;

            foreach ($this->entityAnnotationClasses as $annotClass => $i) {
                if ($annot instanceof $annotClass) {
                    $documentAnnots[$i] = $annot;
                    continue 2;
                }
            }

            // non-document class annotations
            if ($annot instanceof ODM\AbstractIndex) {
                $this->addIndex($class, $annot);
            }
            if ($annot instanceof ODM\Indexes) {
                foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
                    $this->addIndex($class, $index);
                }
            } elseif ($annot instanceof ODM\InheritanceType) {
                $class->setInheritanceType(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::INHERITANCE_TYPE_'.$annot->value));
            } elseif ($annot instanceof ODM\DiscriminatorField) {
                // $fieldName property is deprecated, but fall back for BC
                if (isset($annot->value)) {
                    $class->setDiscriminatorField($annot->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                } elseif (isset($annot->name)) {
                    $class->setDiscriminatorField($annot->name);
                } elseif (isset($annot->fieldName)) {

                    $class->setDiscriminatorField($annot->fieldName);

                }
            } elseif ($annot instanceof ODM\DiscriminatorMap) {
                $class->setDiscriminatorMap($annot->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            } elseif ($annot instanceof ODM\DiscriminatorValue) {
                $class->setDiscriminatorValue($annot->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            } elseif ($annot instanceof ODM\ChangeTrackingPolicy) {
                $class->setChangeTrackingPolicy(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::CHANGETRACKING_'.$annot->value));
            } elseif ($annot instanceof ODM\DefaultDiscriminatorValue) {
                $class->setDefaultDiscriminatorValue($annot->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            }

        }

        if ( ! $documentAnnots) {

            throw MappingException::classIsNotAValidDocument($className);
        }

        // find the winning document annotation
        ksort($documentAnnots);
        $documentAnnot = reset($documentAnnots);

        if ($documentAnnot instanceof ODM\MappedSuperclass) {
            $class->isMappedSuperclass = true;
        } elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
            $class->isEmbeddedDocument = true;
        }
        if (isset($documentAnnot->db)) {
            $class->setDatabase($documentAnnot->db);
        }
        if (isset($documentAnnot->collection)) {
            $class->setCollection($documentAnnot->collection);
        }
        if (isset($documentAnnot->repositoryClass) && !$class->isEmbeddedDocument) {
            $class->setCustomRepositoryClass($documentAnnot->repositoryClass);
        }
        if (isset($documentAnnot->indexes)) {
            foreach ($documentAnnot->indexes as $index) {
                $this->addIndex($class, $index);
            }
        }
        if (isset($documentAnnot->requireIndexes)) {
            $class->setRequireIndexes($documentAnnot->requireIndexes);
        }
        if (isset($documentAnnot->slaveOkay)) {
            $class->setSlaveOkay($documentAnnot->slaveOkay);
        }

        foreach ($reflClass->getProperties() as $property) {
            if (($class->isMappedSuperclass && ! $property->isPrivate())
                ||
                ($class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name)) {
                continue;
            }

            $indexes = array();
            $mapping = array('fieldName' => $property->getName());
            $fieldAnnot = null;

            foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
                if ($annot instanceof ODM\AbstractField) {
                    $fieldAnnot = $annot;
                }
                if ($annot instanceof ODM\AbstractIndex) {
                    $indexes[] = $annot;
                }
                if ($annot instanceof ODM\Indexes) {
                    foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
                        $indexes[] = $index;
                    }
                } elseif ($annot instanceof ODM\AlsoLoad) {
                    $mapping['alsoLoadFields'] = (array) $annot->value;
                } elseif ($annot instanceof ODM\Version) {
                    $mapping['version'] = true;
                } elseif ($annot instanceof ODM\Lock) {
                    $mapping['lock'] = true;
                }
            }

            if ($fieldAnnot) {
                $mapping = array_replace($mapping, (array) $fieldAnnot);
                $class->mapField($mapping);
            }

            if ($indexes) {

                foreach ($indexes as $index) {
                    $name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName'];
                    $keys = array($name => $index->order ?: 'asc');
                    $this->addIndex($class, $index, $keys);
                }
            }
        }

        /** @var $method \ReflectionMethod */
        foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
            /* Filter for the declaring class only. Callbacks from parent
             * classes will already be registered.
             */
            if ($method->getDeclaringClass()->name !== $reflClass->name) {
                continue;
            }

            foreach ($this->reader->getMethodAnnotations($method) as $annot) {
                if ($annot instanceof ODM\AlsoLoad) {
                    $class->registerAlsoLoadMethod($method->getName(), $annot->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                }

                if ( ! isset($classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\HasLifecycleCallbacks'])) {
                    continue;
                }

                if ($annot instanceof ODM\PrePersist) {
                    $class->addLifecycleCallback($method->getName(), Events::prePersist);
                } elseif ($annot instanceof ODM\PostPersist) {
                    $class->addLifecycleCallback($method->getName(), Events::postPersist);
                } elseif ($annot instanceof ODM\PreUpdate) {
                    $class->addLifecycleCallback($method->getName(), Events::preUpdate);
                } elseif ($annot instanceof ODM\PostUpdate) {
                    $class->addLifecycleCallback($method->getName(), Events::postUpdate);
                } elseif ($annot instanceof ODM\PreRemove) {
                    $class->addLifecycleCallback($method->getName(), Events::preRemove);
                } elseif ($annot instanceof ODM\PostRemove) {
                    $class->addLifecycleCallback($method->getName(), Events::postRemove);
                } elseif ($annot instanceof ODM\PreLoad) {
                    $class->addLifecycleCallback($method->getName(), Events::preLoad);
                } elseif ($annot instanceof ODM\PostLoad) {
                    $class->addLifecycleCallback($method->getName(), Events::postLoad);
                } elseif ($annot instanceof ODM\PreFlush) {
                    $class->addLifecycleCallback($method->getName(), Events::preFlush);
                }
            }
        }
    }

    private function addIndex(ClassMetadataInfo $class, $index, array $keys = array())
    {
        $keys = array_merge($keys, $index->keys);
        $options = array();
        $allowed = array('name', 'dropDups', 'background', 'safe', 'unique', 'sparse', 'expireAfterSeconds');
        foreach ($allowed as $name) {
            if (isset($index->$name)) {
                $options[$name] = $index->$name;
            }
        }
        $options = array_merge($options, $index->options);
        $class->addIndex($keys, $options);
    }

    /**
     * Factory method for the Annotation Driver
     *
     * @param array|string $paths
     * @param Reader $reader
     * @return AnnotationDriver
     */
    public static function create($paths = array(), Reader $reader = null)
    {
        if ($reader === null) {
            $reader = new AnnotationReader();
        }
        return new self($reader, $paths);

    }
}


1		<?php
2		/*
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license. For more information, see
17		* <http://www.doctrine-project.org>.
18		*/
19
20		namespace Doctrine\ODM\MongoDB\Mapping\Driver;
21
22		use Doctrine\Common\Annotations\AnnotationReader;
23		use Doctrine\Common\Annotations\AnnotationRegistry;
24		use Doctrine\Common\Annotations\Reader;
25		use Doctrine\Common\Persistence\Mapping\ClassMetadata;
26		use Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
27		use Doctrine\ODM\MongoDB\Events;
28		use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
29		use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
30		use Doctrine\ODM\MongoDB\Mapping\MappingException;
31
32		/**
33		* The AnnotationDriver reads the mapping metadata from docblock annotations.
34		*
35		* @since 1.0
36		* @author Jonathan H. Wage <[email protected]>
37		* @author Roman Borschel <[email protected]>
38		*/
39		class AnnotationDriver extends AbstractAnnotationDriver
40		{
41		protected $entityAnnotationClasses = array(
42		'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\Document' => 1,
43		'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\MappedSuperclass' => 2,
44		'Doctrine\\ODM\\MongoDB\\Mapping\\Annotations\\EmbeddedDocument' => 3,
45		);
46
47		/**
48		* Registers annotation classes to the common registry.
49		*
50		* This method should be called when bootstrapping your application.
51		*/
52		public static function registerAnnotationClasses()
53		{
54		AnnotationRegistry::registerFile(__DIR__ . '/../Annotations/DoctrineAnnotations.php');
55		}
56
57		/**
58		* {@inheritdoc}
59		*/
60	766	public function loadMetadataForClass($className, ClassMetadata $class)
61		{
62		/** @var $class ClassMetadataInfo */
63	766	$reflClass = $class->getReflectionClass();
64
65	766	$classAnnotations = $this->reader->getClassAnnotations($reflClass);
66
67	766	$documentAnnots = array();
68	766	foreach ($classAnnotations as $annot) {
69	764	$classAnnotations[get_class($annot)] = $annot;
70
71	764	foreach ($this->entityAnnotationClasses as $annotClass => $i) {
72	764	if ($annot instanceof $annotClass) {
73	764	$documentAnnots[$i] = $annot;
74	764	continue 2;
75		}
76	502	}
77
78		// non-document class annotations
79	321	if ($annot instanceof ODM\AbstractIndex) {
80	13	$this->addIndex($class, $annot);
81	13	}
82	321	if ($annot instanceof ODM\Indexes) {
83	37	foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
84	37	$this->addIndex($class, $index);
85	37	}
86	321	} elseif ($annot instanceof ODM\InheritanceType) {
87	242	$class->setInheritanceType(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::INHERITANCE_TYPE_'.$annot->value));
88	303	} elseif ($annot instanceof ODM\DiscriminatorField) {
89		// $fieldName property is deprecated, but fall back for BC
90	75	if (isset($annot->value)) {
91	19	$class->setDiscriminatorField($annot->value);
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report It seems like `$annot->value` can also be of type `array`; however, `Doctrine\ODM\MongoDB\Map...setDiscriminatorField()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
92	75	} elseif (isset($annot->name)) {
93		$class->setDiscriminatorField($annot->name);
94	72	} elseif (isset($annot->fieldName)) {
		0 ignored issues – show Deprecated Code introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The property `Doctrine\ODM\MongoDB\Map...inatorField::$fieldName` has been deprecated. This property has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the property will be removed from the class and what other property to use instead. Loading history...
95	72	$class->setDiscriminatorField($annot->fieldName);
		0 ignored issues – show Deprecated Code introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The property `Doctrine\ODM\MongoDB\Map...inatorField::$fieldName` has been deprecated. This property has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the property will be removed from the class and what other property to use instead. Loading history...
96	72	}
97	301	} elseif ($annot instanceof ODM\DiscriminatorMap) {
98	75	$class->setDiscriminatorMap($annot->value);
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report It seems like `$annot->value` can also be of type `null` or `string`; however, `Doctrine\ODM\MongoDB\Map...::setDiscriminatorMap()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
99	300	} elseif ($annot instanceof ODM\DiscriminatorValue) {
100		$class->setDiscriminatorValue($annot->value);
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report It seems like `$annot->value` can also be of type `array` or `null`; however, `Doctrine\ODM\MongoDB\Map...setDiscriminatorValue()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
101	249	} elseif ($annot instanceof ODM\ChangeTrackingPolicy) {
102	21	$class->setChangeTrackingPolicy(constant('Doctrine\\ODM\\MongoDB\\Mapping\\ClassMetadata::CHANGETRACKING_'.$annot->value));
103	249	} elseif ($annot instanceof ODM\DefaultDiscriminatorValue) {
104	22	$class->setDefaultDiscriminatorValue($annot->value);
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report It seems like `$annot->value` can also be of type `array` or `null`; however, `Doctrine\ODM\MongoDB\Map...ultDiscriminatorValue()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
105	22	}
106
107	766	}
108
109	766	if ( ! $documentAnnots) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The expression `$documentAnnots` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
110	2	throw MappingException::classIsNotAValidDocument($className);
111		}
112
113		// find the winning document annotation
114	764	ksort($documentAnnots);
115	764	$documentAnnot = reset($documentAnnots);
116
117	764	if ($documentAnnot instanceof ODM\MappedSuperclass) {
118	241	$class->isMappedSuperclass = true;
119	764	} elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
120	399	$class->isEmbeddedDocument = true;
121	399	}
122	764	if (isset($documentAnnot->db)) {
123	1	$class->setDatabase($documentAnnot->db);
124	1	}
125	764	if (isset($documentAnnot->collection)) {
126	280	$class->setCollection($documentAnnot->collection);
127	280	}
128	764	if (isset($documentAnnot->repositoryClass) && !$class->isEmbeddedDocument) {
129	31	$class->setCustomRepositoryClass($documentAnnot->repositoryClass);
130	31	}
131	764	if (isset($documentAnnot->indexes)) {
132	763	foreach ($documentAnnot->indexes as $index) {
133		$this->addIndex($class, $index);
134	763	}
135	763	}
136	764	if (isset($documentAnnot->requireIndexes)) {
137	757	$class->setRequireIndexes($documentAnnot->requireIndexes);
138	757	}
139	764	if (isset($documentAnnot->slaveOkay)) {
140	1	$class->setSlaveOkay($documentAnnot->slaveOkay);
141	1	}
142
143	764	foreach ($reflClass->getProperties() as $property) {
144	763	if (($class->isMappedSuperclass && ! $property->isPrivate())
145		\|\|
146	763	($class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name)) {
147	273	continue;
148		}
149
150	762	$indexes = array();
151	762	$mapping = array('fieldName' => $property->getName());
152	762	$fieldAnnot = null;
153
154	762	foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
155	762	if ($annot instanceof ODM\AbstractField) {
156	762	$fieldAnnot = $annot;
157	762	}
158	762	if ($annot instanceof ODM\AbstractIndex) {
159	149	$indexes[] = $annot;
160	149	}
161	762	if ($annot instanceof ODM\Indexes) {
162		foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
163		$indexes[] = $index;
164		}
165	762	} elseif ($annot instanceof ODM\AlsoLoad) {
166	13	$mapping['alsoLoadFields'] = (array) $annot->value;
167	762	} elseif ($annot instanceof ODM\Version) {
168	61	$mapping['version'] = true;
169	762	} elseif ($annot instanceof ODM\Lock) {
170	24	$mapping['lock'] = true;
171	24	}
172	762	}
173
174	762	if ($fieldAnnot) {
175	762	$mapping = array_replace($mapping, (array) $fieldAnnot);
176	762	$class->mapField($mapping);
177	762	}
178
179	762	if ($indexes) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The expression `$indexes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
180	149	foreach ($indexes as $index) {
181	149	$name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName'];
182	149	$keys = array($name => $index->order ?: 'asc');
183	150	$this->addIndex($class, $index, $keys);
184	149	}
185	149	}
186	764	}
187
188		/** @var $method \ReflectionMethod */
189	762	foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
190		/* Filter for the declaring class only. Callbacks from parent
191		* classes will already be registered.
192		*/
193	528	if ($method->getDeclaringClass()->name !== $reflClass->name) {
194	257	continue;
195		}
196
197	528	foreach ($this->reader->getMethodAnnotations($method) as $annot) {
198	247	if ($annot instanceof ODM\AlsoLoad) {
199	13	$class->registerAlsoLoadMethod($method->getName(), $annot->value);
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report It seems like `$annot->value` can also be of type `null`; however, `Doctrine\ODM\MongoDB\Map...egisterAlsoLoadMethod()` does only seem to accept `array\|string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
200	13	}
201
202	247	if ( ! isset($classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\HasLifecycleCallbacks'])) {
203	37	continue;
204		}
205
206	228	if ($annot instanceof ODM\PrePersist) {
207	207	$class->addLifecycleCallback($method->getName(), Events::prePersist);
208	228	} elseif ($annot instanceof ODM\PostPersist) {
209	11	$class->addLifecycleCallback($method->getName(), Events::postPersist);
210	51	} elseif ($annot instanceof ODM\PreUpdate) {
211	15	$class->addLifecycleCallback($method->getName(), Events::preUpdate);
212	50	} elseif ($annot instanceof ODM\PostUpdate) {
213	32	$class->addLifecycleCallback($method->getName(), Events::postUpdate);
214	45	} elseif ($annot instanceof ODM\PreRemove) {
215	37	$class->addLifecycleCallback($method->getName(), Events::preRemove);
216	39	} elseif ($annot instanceof ODM\PostRemove) {
217	35	$class->addLifecycleCallback($method->getName(), Events::postRemove);
218	39	} elseif ($annot instanceof ODM\PreLoad) {
219	36	$class->addLifecycleCallback($method->getName(), Events::preLoad);
220	39	} elseif ($annot instanceof ODM\PostLoad) {
221	37	$class->addLifecycleCallback($method->getName(), Events::postLoad);
222	38	} elseif ($annot instanceof ODM\PreFlush) {
223	11	$class->addLifecycleCallback($method->getName(), Events::preFlush);
224	11	}
225	528	}
226	762	}
227	762	}
228
229	180	private function addIndex(ClassMetadataInfo $class, $index, array $keys = array())
230		{
231	180	$keys = array_merge($keys, $index->keys);
232	180	$options = array();
233	180	$allowed = array('name', 'dropDups', 'background', 'safe', 'unique', 'sparse', 'expireAfterSeconds');
234	180	foreach ($allowed as $name) {
235	180	if (isset($index->$name)) {
236	180	$options[$name] = $index->$name;
237	180	}
238	180	}
239	180	$options = array_merge($options, $index->options);
240	180	$class->addIndex($keys, $options);
241	180	}
242
243		/**
244		* Factory method for the Annotation Driver
245		*
246		* @param array\|string $paths
247		* @param Reader $reader
248		* @return AnnotationDriver
249		*/
250	946	public static function create($paths = array(), Reader $reader = null)
251		{
252	946	if ($reader === null) {
253	946	$reader = new AnnotationReader();
254	946	}
255	946	return new self($reader, $paths);
		0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$reader` of type `object<Doctrine\Common\Annotations\Reader>` is not a sub-type of `object<Doctrine\Common\A...tions\AnnotationReader>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Annotations\Reader` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
256		}
257		}
258

doctrine / mongodb-odm

Pull Request — 1.0.x (#1416)

AnnotationDriver::loadMetadataForClass() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like