AnnotationDriver - Code Metrics - Inspection of "Write concern per document" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1419)

by Robert

created 2016-06-01 15:29 UTC

AnnotationDriver F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

94.32%

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
wmc	73
c	4
b	0
f	0
lcom	1
cbo	14
dl	0
loc	249
ccs	166
cts	176
cp	0.9432
rs	3.8271

5 Methods

Rating	Name	Size	Complexity
A	registerAnnotationClasses()	4	1
F	loadMetadataForClass()	176	63
A	addIndex()	16	4
A	setShardKey()	12	3
A	create()	7	2

How to fix 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\ClassMetadata as MappingClassMetadata;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
use Doctrine\ODM\MongoDB\Mapping\MappingException;

/**
 * The AnnotationDriver reads the mapping metadata from docblock annotations.
 *
 * @since       1.0
 */
class AnnotationDriver extends AbstractAnnotationDriver
{
    protected $entityAnnotationClasses = array(
        ODM\Document::class         => 1,
        ODM\MappedSuperclass::class => 2,
        ODM\EmbeddedDocument::class => 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(MappingClassMetadata::class . '::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(MappingClassMetadata::class . '::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->writeConcern)) {
            $class->setWriteConcern($documentAnnot->writeConcern);
        }
        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);
                }
            }
        }

        // Set shard key after all fields to ensure we mapped all its keys
        if (isset($classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\ShardKey'])) {
            $this->setShardKey($class, $classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\ShardKey']);
        }

        /** @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[ODM\HasLifecycleCallbacks::class])) {
                    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;
            }
        }
        if (! empty($index->partialFilterExpression)) {
            $options['partialFilterExpression'] = $index->partialFilterExpression;
        }
        $options = array_merge($options, $index->options);
        $class->addIndex($keys, $options);
    }

    /**
     * @param ClassMetadataInfo $class
     * @param ODM\ShardKey      $shardKey
     *
     * @throws MappingException
     */
    private function setShardKey(ClassMetadataInfo $class, ODM\ShardKey $shardKey)
    {
        $options = array();
        $allowed = array('unique', 'numInitialChunks');
        foreach ($allowed as $name) {
            if (isset($shardKey->$name)) {
                $options[$name] = $shardKey->$name;
            }
        }

        $class->setShardKey($shardKey->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\ClassMetadata as MappingClassMetadata;
30		use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
31		use Doctrine\ODM\MongoDB\Mapping\MappingException;
32
33		/**
34		* The AnnotationDriver reads the mapping metadata from docblock annotations.
35		*
36		* @since 1.0
37		*/
38		class AnnotationDriver extends AbstractAnnotationDriver
39		{
40		protected $entityAnnotationClasses = array(
41		ODM\Document::class => 1,
42		ODM\MappedSuperclass::class => 2,
43		ODM\EmbeddedDocument::class => 3,
44		);
45
46		/**
47		* Registers annotation classes to the common registry.
48		*
49		* This method should be called when bootstrapping your application.
50		*/
51		public static function registerAnnotationClasses()
52		{
53		AnnotationRegistry::registerFile(__DIR__ . '/../Annotations/DoctrineAnnotations.php');
54		}
55
56		/**
57		* {@inheritdoc}
58		*/
59	867	public function loadMetadataForClass($className, ClassMetadata $class)
60		{
61		/** @var $class ClassMetadataInfo */
62	867	$reflClass = $class->getReflectionClass();
63
64	867	$classAnnotations = $this->reader->getClassAnnotations($reflClass);
65
66	867	$documentAnnots = array();
67	867	foreach ($classAnnotations as $annot) {
68	865	$classAnnotations[get_class($annot)] = $annot;
69
70	865	foreach ($this->entityAnnotationClasses as $annotClass => $i) {
71	865	if ($annot instanceof $annotClass) {
72	865	$documentAnnots[$i] = $annot;
73	865	continue 2;
74		}
75	559	}
76
77		// non-document class annotations
78	379	if ($annot instanceof ODM\AbstractIndex) {
79	13	$this->addIndex($class, $annot);
80	13	}
81	379	if ($annot instanceof ODM\Indexes) {
82	63	foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
83	63	$this->addIndex($class, $index);
84	63	}
85	379	} elseif ($annot instanceof ODM\InheritanceType) {
86	289	$class->setInheritanceType(constant(MappingClassMetadata::class . '::INHERITANCE_TYPE_'.$annot->value));
87	370	} elseif ($annot instanceof ODM\DiscriminatorField) {
88		// $fieldName property is deprecated, but fall back for BC
89	112	if (isset($annot->value)) {
90	54	$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...
91	112	} elseif (isset($annot->name)) {
92		$class->setDiscriminatorField($annot->name);
93	109	} 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...
94	109	$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...
95	109	}
96	368	} elseif ($annot instanceof ODM\DiscriminatorMap) {
97	112	$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...
98	367	} elseif ($annot instanceof ODM\DiscriminatorValue) {
99		$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...
100	314	} elseif ($annot instanceof ODM\ChangeTrackingPolicy) {
101	57	$class->setChangeTrackingPolicy(constant(MappingClassMetadata::class . '::CHANGETRACKING_'.$annot->value));
102	314	} elseif ($annot instanceof ODM\DefaultDiscriminatorValue) {
103	57	$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...
104	57	}
105
106	867	}
107
108	867	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...
109	3	throw MappingException::classIsNotAValidDocument($className);
110		}
111
112		// find the winning document annotation
113	865	ksort($documentAnnots);
114	865	$documentAnnot = reset($documentAnnots);
115
116	865	if ($documentAnnot instanceof ODM\MappedSuperclass) {
117	287	$class->isMappedSuperclass = true;
118	865	} elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
119	287	$class->isEmbeddedDocument = true;
120	287	}
121	865	if (isset($documentAnnot->db)) {
122	1	$class->setDatabase($documentAnnot->db);
123	1	}
124	865	if (isset($documentAnnot->collection)) {
125	339	$class->setCollection($documentAnnot->collection);
126	339	}
127	865	if (isset($documentAnnot->repositoryClass) && !$class->isEmbeddedDocument) {
128	65	$class->setCustomRepositoryClass($documentAnnot->repositoryClass);
129	65	}
130	865	if (isset($documentAnnot->writeConcern)) {
131	11	$class->setWriteConcern($documentAnnot->writeConcern);
132	11	}
133	865	if (isset($documentAnnot->indexes)) {
134	864	foreach ($documentAnnot->indexes as $index) {
135		$this->addIndex($class, $index);
136	864	}
137	864	}
138	865	if (isset($documentAnnot->requireIndexes)) {
139	857	$class->setRequireIndexes($documentAnnot->requireIndexes);
140	857	}
141	865	if (isset($documentAnnot->slaveOkay)) {
142	1	$class->setSlaveOkay($documentAnnot->slaveOkay);
143	1	}
144
145	865	foreach ($reflClass->getProperties() as $property) {
146	864	if (($class->isMappedSuperclass && ! $property->isPrivate())
147		\|\|
148	864	($class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name)) {
149	324	continue;
150		}
151
152	863	$indexes = array();
153	863	$mapping = array('fieldName' => $property->getName());
154	863	$fieldAnnot = null;
155
156	863	foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
157	863	if ($annot instanceof ODM\AbstractField) {
158	863	$fieldAnnot = $annot;
159	863	}
160	863	if ($annot instanceof ODM\AbstractIndex) {
161	185	$indexes[] = $annot;
162	185	}
163	863	if ($annot instanceof ODM\Indexes) {
164		foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
165		$indexes[] = $index;
166		}
167	863	} elseif ($annot instanceof ODM\AlsoLoad) {
168	13	$mapping['alsoLoadFields'] = (array) $annot->value;
169	863	} elseif ($annot instanceof ODM\Version) {
170	97	$mapping['version'] = true;
171	863	} elseif ($annot instanceof ODM\Lock) {
172	24	$mapping['lock'] = true;
173	24	}
174	863	}
175
176	863	if ($fieldAnnot) {
177	864	$mapping = array_replace($mapping, (array) $fieldAnnot);
178	863	$class->mapField($mapping);
179	863	}
180
181	863	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...
182	185	foreach ($indexes as $index) {
183	186	$name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName'];
184	185	$keys = array($name => $index->order ?: 'asc');
185	185	$this->addIndex($class, $index, $keys);
186	185	}
187	185	}
188	865	}
189
190		// Set shard key after all fields to ensure we mapped all its keys
191	863	if (isset($classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\ShardKey'])) {
192	71	$this->setShardKey($class, $classAnnotations['Doctrine\ODM\MongoDB\Mapping\Annotations\ShardKey']);
193	70	}
194
195		/** @var $method \ReflectionMethod */
196	862	foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
197		/* Filter for the declaring class only. Callbacks from parent
198		* classes will already be registered.
199		*/
200	594	if ($method->getDeclaringClass()->name !== $reflClass->name) {
201	298	continue;
202		}
203
204	594	foreach ($this->reader->getMethodAnnotations($method) as $annot) {
205	292	if ($annot instanceof ODM\AlsoLoad) {
206	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... Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
207	13	}
208
209	292	if ( ! isset($classAnnotations[ODM\HasLifecycleCallbacks::class])) {
210	72	continue;
211		}
212
213	273	if ($annot instanceof ODM\PrePersist) {
214	252	$class->addLifecycleCallback($method->getName(), Events::prePersist);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
215	273	} elseif ($annot instanceof ODM\PostPersist) {
216	11	$class->addLifecycleCallback($method->getName(), Events::postPersist);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
217	86	} elseif ($annot instanceof ODM\PreUpdate) {
218	15	$class->addLifecycleCallback($method->getName(), Events::preUpdate);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
219	85	} elseif ($annot instanceof ODM\PostUpdate) {
220	67	$class->addLifecycleCallback($method->getName(), Events::postUpdate);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
221	80	} elseif ($annot instanceof ODM\PreRemove) {
222	72	$class->addLifecycleCallback($method->getName(), Events::preRemove);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
223	74	} elseif ($annot instanceof ODM\PostRemove) {
224	70	$class->addLifecycleCallback($method->getName(), Events::postRemove);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
225	74	} elseif ($annot instanceof ODM\PreLoad) {
226	71	$class->addLifecycleCallback($method->getName(), Events::preLoad);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
227	74	} elseif ($annot instanceof ODM\PostLoad) {
228	72	$class->addLifecycleCallback($method->getName(), Events::postLoad);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
229	73	} elseif ($annot instanceof ODM\PreFlush) {
230	11	$class->addLifecycleCallback($method->getName(), Events::preFlush);
		0 ignored issues – show Bug introduced 2015-12-09 07:53 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
231	11	}
232	594	}
233	862	}
234	862	}
235
236	207	private function addIndex(ClassMetadataInfo $class, $index, array $keys = array())
237		{
238	207	$keys = array_merge($keys, $index->keys);
239	207	$options = array();
240	207	$allowed = array('name', 'dropDups', 'background', 'safe', 'unique', 'sparse', 'expireAfterSeconds');
241	207	foreach ($allowed as $name) {
242	207	if (isset($index->$name)) {
243	207	$options[$name] = $index->$name;
244	207	}
245	207	}
246	207	if (! empty($index->partialFilterExpression)) {
247	2	$options['partialFilterExpression'] = $index->partialFilterExpression;
248	2	}
249	207	$options = array_merge($options, $index->options);
250	207	$class->addIndex($keys, $options);
251	207	}
252
253		/**
254		* @param ClassMetadataInfo $class
255		* @param ODM\ShardKey $shardKey
256		*
257		* @throws MappingException
258		*/
259	71	private function setShardKey(ClassMetadataInfo $class, ODM\ShardKey $shardKey)
260		{
261	71	$options = array();
262	71	$allowed = array('unique', 'numInitialChunks');
263	71	foreach ($allowed as $name) {
264	71	if (isset($shardKey->$name)) {
265	1	$options[$name] = $shardKey->$name;
266	1	}
267	71	}
268
269	71	$class->setShardKey($shardKey->keys, $options);
270	70	}
271
272		/**
273		* Factory method for the Annotation Driver
274		*
275		* @param array\|string $paths
276		* @param Reader $reader
277		* @return AnnotationDriver
278		*/
279	1087	public static function create($paths = array(), Reader $reader = null)
280		{
281	1087	if ($reader === null) {
282	1087	$reader = new AnnotationReader();
283	1087	}
284	1087	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...
285		}
286		}
287

doctrine / mongodb-odm

Pull Request — master (#1419)

AnnotationDriver F

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

5 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like