AnnotationDriver::loadMetadataForClass() - Code Metrics - Inspection of "Fix the ' needs an Object' exception for simple re..." - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0.x (#1406)

unknown

created 2016-05-11 17:09 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

Metric	Value
dl	0
loc	168
ccs	130
cts	137
cp	0.9489
rs	2
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	768	public function loadMetadataForClass($className, ClassMetadata $class)
61		{
62		/** @var $class ClassMetadataInfo */
63	768	$reflClass = $class->getReflectionClass();
64
65	768	$classAnnotations = $this->reader->getClassAnnotations($reflClass);
66
67	768	$documentAnnots = array();
68	768	foreach ($classAnnotations as $annot) {
69	766	$classAnnotations[get_class($annot)] = $annot;
70
71	766	foreach ($this->entityAnnotationClasses as $annotClass => $i) {
72	766	if ($annot instanceof $annotClass) {
73	766	$documentAnnots[$i] = $annot;
74	766	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	768	}
108
109	768	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	766	ksort($documentAnnots);
115	766	$documentAnnot = reset($documentAnnots);
116
117	766	if ($documentAnnot instanceof ODM\MappedSuperclass) {
118	241	$class->isMappedSuperclass = true;
119	766	} elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
120	399	$class->isEmbeddedDocument = true;
121	399	}
122	766	if (isset($documentAnnot->db)) {
123	1	$class->setDatabase($documentAnnot->db);
124	1	}
125	766	if (isset($documentAnnot->collection)) {
126	280	$class->setCollection($documentAnnot->collection);
127	280	}
128	766	if (isset($documentAnnot->repositoryClass) && !$class->isEmbeddedDocument) {
129	31	$class->setCustomRepositoryClass($documentAnnot->repositoryClass);
130	31	}
131	766	if (isset($documentAnnot->indexes)) {
132	765	foreach ($documentAnnot->indexes as $index) {
133		$this->addIndex($class, $index);
134	765	}
135	765	}
136	766	if (isset($documentAnnot->requireIndexes)) {
137	759	$class->setRequireIndexes($documentAnnot->requireIndexes);
138	759	}
139	766	if (isset($documentAnnot->slaveOkay)) {
140	1	$class->setSlaveOkay($documentAnnot->slaveOkay);
141	1	}
142
143	766	foreach ($reflClass->getProperties() as $property) {
144	765	if (($class->isMappedSuperclass && ! $property->isPrivate())
145		\|\|
146	765	($class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name)) {
147	273	continue;
148		}
149
150	764	$indexes = array();
151	764	$mapping = array('fieldName' => $property->getName());
152	764	$fieldAnnot = null;
153
154	764	foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
155	764	if ($annot instanceof ODM\AbstractField) {
156	764	$fieldAnnot = $annot;
157	764	}
158	764	if ($annot instanceof ODM\AbstractIndex) {
159	149	$indexes[] = $annot;
160	149	}
161	764	if ($annot instanceof ODM\Indexes) {
162		foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
163		$indexes[] = $index;
164		}
165	764	} elseif ($annot instanceof ODM\AlsoLoad) {
166	13	$mapping['alsoLoadFields'] = (array) $annot->value;
167	764	} elseif ($annot instanceof ODM\Version) {
168	61	$mapping['version'] = true;
169	764	} elseif ($annot instanceof ODM\Lock) {
170	24	$mapping['lock'] = true;
171	24	}
172	764	}
173
174	764	if ($fieldAnnot) {
175	764	$mapping = array_replace($mapping, (array) $fieldAnnot);
176	764	$class->mapField($mapping);
177	764	}
178
179	764	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	766	}
187
188		/** @var $method \ReflectionMethod */
189	764	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	530	if ($method->getDeclaringClass()->name !== $reflClass->name) {
194	258	continue;
195		}
196
197	530	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	530	}
226	764	}
227	764	}
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	948	public static function create($paths = array(), Reader $reader = null)
251		{
252	948	if ($reader === null) {
253	948	$reader = new AnnotationReader();
254	948	}
255	948	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 (#1406)

AnnotationDriver::loadMetadataForClass() F

Complexity

Size

Duplication

Code Coverage

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like