ClassMetadataFactory::newClassMetadataInstance() - Code Metrics - Inspection of "Fix headline in changelog" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0.x ( 0605bb...052971 )

by Andreas

created 2016-10-07 09:17 UTC

ClassMetadataFactory::newClassMetadataInstance() A

↳ Parent: ClassMetadataFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

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

use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
use Doctrine\Common\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
use Doctrine\Common\Persistence\Mapping\ReflectionService;
use Doctrine\ODM\MongoDB\Configuration;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Events;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use Doctrine\ODM\MongoDB\Mapping\MappingException;

/**
 * The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
 * metadata mapping informations of a class which describes how a class should be mapped
 * to a document database.
 *
 * @since       1.0
 * @author      Jonathan H. Wage <[email protected]>
 * @author      Roman Borschel <[email protected]>
 */
class ClassMetadataFactory extends AbstractClassMetadataFactory
{
    protected $cacheSalt = "\$MONGODBODMCLASSMETADATA";

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

    /** @var Configuration The Configuration instance */
    private $config;

    /** @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver The used metadata driver. */
    private $driver;

    /** @var \Doctrine\Common\EventManager The event manager instance */
    private $evm;

    /**
     * Sets the DocumentManager instance for this class.
     *
     * @param DocumentManager $dm The DocumentManager instance
     */
    public function setDocumentManager(DocumentManager $dm)
    {
        $this->dm = $dm;
    }

    /**
     * Sets the Configuration instance
     *
     * @param Configuration $config
     */
    public function setConfiguration(Configuration $config)
    {
        $this->config = $config;
    }

    /**
     * Lazy initialization of this stuff, especially the metadata driver,
     * since these are not needed at all when a metadata cache is active.
     */
    protected function initialize()
    {
        $this->driver = $this->config->getMetadataDriverImpl();
        $this->evm = $this->dm->getEventManager();
        $this->initialized = true;
    }

    /**
     * {@inheritDoc}
     */
    protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
    {
        return $this->config->getDocumentNamespace($namespaceAlias) . '\\' . $simpleClassName;
    }

    /**
     * {@inheritDoc}
     */
    protected function getDriver()
    {
        return $this->driver;
    }

    /**
     * {@inheritDoc}
     */
    protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
    {
    }

    /**
     * {@inheritDoc}
     */
    protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
    {
    }

    /**
     * {@inheritDoc}
     */
    protected function isEntity(ClassMetadataInterface $class)
    {
        return ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

    /**
     * {@inheritDoc}
     */
    protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents = array())
    {
        /** @var $class ClassMetadata */
        /** @var $parent ClassMetadata */
        if ($parent) {
            $class->setInheritanceType($parent->inheritanceType);
            $class->setDiscriminatorField($parent->discriminatorField);
            $class->setDiscriminatorMap($parent->discriminatorMap);
            $class->setDefaultDiscriminatorValue($parent->defaultDiscriminatorValue);
            $class->setIdGeneratorType($parent->generatorType);
            $this->addInheritedFields($class, $parent);

            $this->addInheritedRelations($class, $parent);

            $this->addInheritedIndexes($class, $parent);

            $class->setIdentifier($parent->identifier);
            $class->setVersioned($parent->isVersioned);
            $class->setVersionField($parent->versionField);
            $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
            $class->setAlsoLoadMethods($parent->alsoLoadMethods);
            $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
            $class->setFile($parent->getFile());
            if ($parent->isMappedSuperclass) {
                $class->setCustomRepositoryClass($parent->customRepositoryClassName);
            }
        }

        // Invoke driver
        try {
            $this->driver->loadMetadataForClass($class->getName(), $class);
        } catch (\ReflectionException $e) {
            throw MappingException::reflectionFailure($class->getName(), $e);
        }

        $this->validateIdentifier($class);


        if ($parent && $rootEntityFound && $parent->generatorType === $class->generatorType) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if ($parent->generatorType) {
                $class->setIdGeneratorType($parent->generatorType);
            }
            if ($parent->generatorOptions) {

                $class->setIdGeneratorOptions($parent->generatorOptions);
            }
            if ($parent->idGenerator) {
                $class->setIdGenerator($parent->idGenerator);
            }
        } else {
            $this->completeIdGeneratorMapping($class);

        }

        if ($parent && $parent->isInheritanceTypeSingleCollection()) {
            $class->setDatabase($parent->getDatabase());
            $class->setCollection($parent->getCollection());
        }

        $class->setParentClasses($nonSuperclassParents);

        if ($this->evm->hasListeners(Events::loadClassMetadata)) {

            $eventArgs = new \Doctrine\ODM\MongoDB\Event\LoadClassMetadataEventArgs($class, $this->dm);
            $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
        }
    }

    /**
     * Validates the identifier mapping.
     *
     * @param ClassMetadata $class
     * @throws MappingException
     */
    protected function validateIdentifier($class)
    {
        if ( ! $class->identifier && ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument) {
            throw MappingException::identifierRequired($class->name);
        }
    }

    /**
     * Creates a new ClassMetadata instance for the given class name.
     *
     * @param string $className
     * @return \Doctrine\ODM\MongoDB\Mapping\ClassMetadata
     */
    protected function newClassMetadataInstance($className)
    {
        return new ClassMetadata($className);
    }

    private function completeIdGeneratorMapping(ClassMetadataInfo $class)
    {
        $idGenOptions = $class->generatorOptions;
        switch ($class->generatorType) {
            case ClassMetadata::GENERATOR_TYPE_AUTO:
                $class->setIdGenerator(new \Doctrine\ODM\MongoDB\Id\AutoGenerator());
                break;
            case ClassMetadata::GENERATOR_TYPE_INCREMENT:
                $incrementGenerator = new \Doctrine\ODM\MongoDB\Id\IncrementGenerator();
                if (isset($idGenOptions['key'])) {
                    $incrementGenerator->setKey($idGenOptions['key']);
                }
                if (isset($idGenOptions['collection'])) {
                    $incrementGenerator->setCollection($idGenOptions['collection']);
                }
                $class->setIdGenerator($incrementGenerator);
                break;
            case ClassMetadata::GENERATOR_TYPE_UUID:
                $uuidGenerator = new \Doctrine\ODM\MongoDB\Id\UuidGenerator();
                isset($idGenOptions['salt']) && $uuidGenerator->setSalt($idGenOptions['salt']);
                $class->setIdGenerator($uuidGenerator);
                break;
            case ClassMetadata::GENERATOR_TYPE_ALNUM:
                $alnumGenerator = new \Doctrine\ODM\MongoDB\Id\AlnumGenerator();
                if (isset($idGenOptions['pad'])) {
                    $alnumGenerator->setPad($idGenOptions['pad']);
                }
                if (isset($idGenOptions['chars'])) {
                    $alnumGenerator->setChars($idGenOptions['chars']);
                } elseif (isset($idGenOptions['awkwardSafe'])) {
                    $alnumGenerator->setAwkwardSafeMode($idGenOptions['awkwardSafe']);
                }

                $class->setIdGenerator($alnumGenerator);
                break;
            case ClassMetadata::GENERATOR_TYPE_CUSTOM:
                if (empty($idGenOptions['class'])) {
                    throw MappingException::missingIdGeneratorClass($class->name);
                }

                $customGenerator = new $idGenOptions['class'];
                unset($idGenOptions['class']);
                if ( ! $customGenerator instanceof \Doctrine\ODM\MongoDB\Id\AbstractIdGenerator) {
                    throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
                }

                $methods = get_class_methods($customGenerator);
                foreach ($idGenOptions as $name => $value) {
                    $method = 'set' . ucfirst($name);
                    if ( ! in_array($method, $methods)) {
                        throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
                    }

                    $customGenerator->$method($value);
                }
                $class->setIdGenerator($customGenerator);
                break;
            case ClassMetadata::GENERATOR_TYPE_NONE;
                break;
            default:
                throw new MappingException("Unknown generator type: " . $class->generatorType);
        }
    }

    /**
     * Adds inherited fields to the subclass mapping.
     *
     * @param ClassMetadata $subClass
     * @param ClassMetadata $parentClass
     */
    private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass)
    {
        foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
            if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {

                $mapping['inherited'] = $parentClass->name;
            }
            if ( ! isset($mapping['declared'])) {
                $mapping['declared'] = $parentClass->name;
            }
            $subClass->addInheritedFieldMapping($mapping);
        }
        foreach ($parentClass->reflFields as $name => $field) {
            $subClass->reflFields[$name] = $field;
        }
    }


    /**
     * Adds inherited association mappings to the subclass mapping.
     *
     * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
     * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
     *
     * @return void
     *
     * @throws MappingException
     */
    private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass)
    {
        foreach ($parentClass->associationMappings as $field => $mapping) {
            if ($parentClass->isMappedSuperclass) {
                $mapping['sourceDocument'] = $subClass->name;
            }

            if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {

                $mapping['inherited'] = $parentClass->name;
            }
            if ( ! isset($mapping['declared'])) {
                $mapping['declared'] = $parentClass->name;
            }
            $subClass->addInheritedAssociationMapping($mapping);
        }
    }

    /**
     * Adds inherited indexes to the subclass mapping.
     *
     * @param ClassMetadata $subClass
     * @param ClassMetadata $parentClass
     */
    private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass)
    {
        foreach ($parentClass->indexes as $index) {
            $subClass->addIndex($index['keys'], $index['options']);
        }
    }
}


Push — 1.0.x ( 0605bb...052971 )

ClassMetadataFactory::newClassMetadataInstance() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

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;
21
22			use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
23			use Doctrine\Common\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
24			use Doctrine\Common\Persistence\Mapping\ReflectionService;
25			use Doctrine\ODM\MongoDB\Configuration;
26			use Doctrine\ODM\MongoDB\DocumentManager;
27			use Doctrine\ODM\MongoDB\Events;
28			use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
29			use Doctrine\ODM\MongoDB\Mapping\MappingException;
30
31			/**
32			* The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
33			* metadata mapping informations of a class which describes how a class should be mapped
34			* to a document database.
35			*
36			* @since 1.0
37			* @author Jonathan H. Wage <[email protected]>
38			* @author Roman Borschel <[email protected]>
39			*/
40			class ClassMetadataFactory extends AbstractClassMetadataFactory
41			{
42			protected $cacheSalt = "\$MONGODBODMCLASSMETADATA";
43
44			/** @var DocumentManager The DocumentManager instance */
45			private $dm;
46
47			/** @var Configuration The Configuration instance */
48			private $config;
49
50			/** @var \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver The used metadata driver. */
51			private $driver;
52
53			/** @var \Doctrine\Common\EventManager The event manager instance */
54			private $evm;
55
56			/**
57			* Sets the DocumentManager instance for this class.
58			*
59			* @param DocumentManager $dm The DocumentManager instance
60			*/
61	966		public function setDocumentManager(DocumentManager $dm)
62			{
63	966		$this->dm = $dm;
64	966		}
65
66			/**
67			* Sets the Configuration instance
68			*
69			* @param Configuration $config
70			*/
71	966		public function setConfiguration(Configuration $config)
72			{
73	966		$this->config = $config;
74	966		}
75
76			/**
77			* Lazy initialization of this stuff, especially the metadata driver,
78			* since these are not needed at all when a metadata cache is active.
79			*/
80	773		protected function initialize()
81			{
82	773		$this->driver = $this->config->getMetadataDriverImpl();
83	773		$this->evm = $this->dm->getEventManager();
84	773		$this->initialized = true;
85	773		}
86
87			/**
88			* {@inheritDoc}
89			*/
90			protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
91			{
92			return $this->config->getDocumentNamespace($namespaceAlias) . '\\' . $simpleClassName;
93			}
94
95			/**
96			* {@inheritDoc}
97			*/
98	292		protected function getDriver()
99			{
100	292		return $this->driver;
101			}
102
103			/**
104			* {@inheritDoc}
105			*/
106	770		protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
107			{
108	770		}
109
110			/**
111			* {@inheritDoc}
112			*/
113	773		protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
114			{
115	773		}
116
117			/**
118			* {@inheritDoc}
119			*/
120	770		protected function isEntity(ClassMetadataInterface $class)
121			{
122	770		return ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument;
			0 ignored issues – show Bug introduced 2015-12-23 19:24 UTC by Report Bug Copy Issue Report Accessing `isMappedSuperclass` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history... Bug introduced 2015-12-23 19:24 UTC by Report Bug Copy Issue Report Accessing `isEmbeddedDocument` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
123			}
124
125			/**
126			* {@inheritDoc}
127			*/
128	773		protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents = array())
129			{
130			/** @var $class ClassMetadata */
131			/** @var $parent ClassMetadata */
132	773		if ($parent) {
133	290		$class->setInheritanceType($parent->inheritanceType);
134	290		$class->setDiscriminatorField($parent->discriminatorField);
135	290		$class->setDiscriminatorMap($parent->discriminatorMap);
136	290		$class->setDefaultDiscriminatorValue($parent->defaultDiscriminatorValue);
137	290		$class->setIdGeneratorType($parent->generatorType);
138	290		$this->addInheritedFields($class, $parent);
			0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Doctrine\ODM\Mong...\Mapping\ClassMetadata>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` 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...
139	290		$this->addInheritedRelations($class, $parent);
			0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Doctrine\ODM\Mong...\Mapping\ClassMetadata>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` 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...
140	290		$this->addInheritedIndexes($class, $parent);
			0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Doctrine\ODM\Mong...\Mapping\ClassMetadata>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` 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...
141	290		$class->setIdentifier($parent->identifier);
142	290		$class->setVersioned($parent->isVersioned);
143	290		$class->setVersionField($parent->versionField);
144	290		$class->setLifecycleCallbacks($parent->lifecycleCallbacks);
145	290		$class->setAlsoLoadMethods($parent->alsoLoadMethods);
146	290		$class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
147	290		$class->setFile($parent->getFile());
148	290		if ($parent->isMappedSuperclass) {
149	244		$class->setCustomRepositoryClass($parent->customRepositoryClassName);
150	244		}
151	290		}
152
153			// Invoke driver
154			try {
155	773		$this->driver->loadMetadataForClass($class->getName(), $class);
156	773		} catch (\ReflectionException $e) {
157			throw MappingException::reflectionFailure($class->getName(), $e);
158			}
159
160	770		$this->validateIdentifier($class);
			0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Doctrine\ODM\Mong...\Mapping\ClassMetadata>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` 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...
161
162	770		if ($parent && $rootEntityFound && $parent->generatorType === $class->generatorType) {
			0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report Accessing `generatorType` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
163	58		if ($parent->generatorType) {
164	58		$class->setIdGeneratorType($parent->generatorType);
165	58		}
166	58		if ($parent->generatorOptions) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The expression `$parent->generatorOptions` 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...
167			$class->setIdGeneratorOptions($parent->generatorOptions);
168			}
169	58		if ($parent->idGenerator) {
170	58		$class->setIdGenerator($parent->idGenerator);
171	58		}
172	58		} else {
173	770		$this->completeIdGeneratorMapping($class);
			0 ignored issues – show Compatibility introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Doctrine\ODM\Mong...ping\ClassMetadataInfo>`. It seems like you assume a concrete implementation of the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` 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...
174			}
175
176	770		if ($parent && $parent->isInheritanceTypeSingleCollection()) {
177	46		$class->setDatabase($parent->getDatabase());
178	46		$class->setCollection($parent->getCollection());
179	46		}
180
181	770		$class->setParentClasses($nonSuperclassParents);
182
183	770	View Code Duplication	if ($this->evm->hasListeners(Events::loadClassMetadata)) {
			0 ignored issues – show Duplication introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
184	2		$eventArgs = new \Doctrine\ODM\MongoDB\Event\LoadClassMetadataEventArgs($class, $this->dm);
185	2		$this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
186	2		}
187	770		}
188
189			/**
190			* Validates the identifier mapping.
191			*
192			* @param ClassMetadata $class
193			* @throws MappingException
194			*/
195	770		protected function validateIdentifier($class)
196			{
197	770		if ( ! $class->identifier && ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument) {
198			throw MappingException::identifierRequired($class->name);
199			}
200	770		}
201
202			/**
203			* Creates a new ClassMetadata instance for the given class name.
204			*
205			* @param string $className
206			* @return \Doctrine\ODM\MongoDB\Mapping\ClassMetadata
207			*/
208	773		protected function newClassMetadataInstance($className)
209			{
210	773		return new ClassMetadata($className);
211			}
212
213	770		private function completeIdGeneratorMapping(ClassMetadataInfo $class)
214			{
215	770		$idGenOptions = $class->generatorOptions;
216	770		switch ($class->generatorType) {
217	770		case ClassMetadata::GENERATOR_TYPE_AUTO:
218	704		$class->setIdGenerator(new \Doctrine\ODM\MongoDB\Id\AutoGenerator());
219	704		break;
220	110		case ClassMetadata::GENERATOR_TYPE_INCREMENT:
221	6		$incrementGenerator = new \Doctrine\ODM\MongoDB\Id\IncrementGenerator();
222	6		if (isset($idGenOptions['key'])) {
223			$incrementGenerator->setKey($idGenOptions['key']);
224			}
225	6		if (isset($idGenOptions['collection'])) {
226			$incrementGenerator->setCollection($idGenOptions['collection']);
227			}
228	6		$class->setIdGenerator($incrementGenerator);
229	6		break;
230	104		case ClassMetadata::GENERATOR_TYPE_UUID:
231	4		$uuidGenerator = new \Doctrine\ODM\MongoDB\Id\UuidGenerator();
232	4		isset($idGenOptions['salt']) && $uuidGenerator->setSalt($idGenOptions['salt']);
233	4		$class->setIdGenerator($uuidGenerator);
234	4		break;
235	100		case ClassMetadata::GENERATOR_TYPE_ALNUM:
236	1		$alnumGenerator = new \Doctrine\ODM\MongoDB\Id\AlnumGenerator();
237	1		if (isset($idGenOptions['pad'])) {
238			$alnumGenerator->setPad($idGenOptions['pad']);
239			}
240	1		if (isset($idGenOptions['chars'])) {
241	1		$alnumGenerator->setChars($idGenOptions['chars']);
242	1		} elseif (isset($idGenOptions['awkwardSafe'])) {
243			$alnumGenerator->setAwkwardSafeMode($idGenOptions['awkwardSafe']);
244			}
245
246	1		$class->setIdGenerator($alnumGenerator);
247	1		break;
248	99		case ClassMetadata::GENERATOR_TYPE_CUSTOM:
249			if (empty($idGenOptions['class'])) {
250			throw MappingException::missingIdGeneratorClass($class->name);
251			}
252
253			$customGenerator = new $idGenOptions['class'];
254			unset($idGenOptions['class']);
255			if ( ! $customGenerator instanceof \Doctrine\ODM\MongoDB\Id\AbstractIdGenerator) {
256			throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
257			}
258
259			$methods = get_class_methods($customGenerator);
260			foreach ($idGenOptions as $name => $value) {
261			$method = 'set' . ucfirst($name);
262			if ( ! in_array($method, $methods)) {
263			throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
264			}
265
266			$customGenerator->$method($value);
267			}
268			$class->setIdGenerator($customGenerator);
269			break;
270	99		case ClassMetadata::GENERATOR_TYPE_NONE;
271	99		break;
272			default:
273			throw new MappingException("Unknown generator type: " . $class->generatorType);
274	770		}
275	770		}
276
277			/**
278			* Adds inherited fields to the subclass mapping.
279			*
280			* @param ClassMetadata $subClass
281			* @param ClassMetadata $parentClass
282			*/
283	290		private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass)
284			{
285	290		foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
286	74	View Code Duplication	if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
			0 ignored issues – show Duplication introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
287	69		$mapping['inherited'] = $parentClass->name;
288	69		}
289	74		if ( ! isset($mapping['declared'])) {
290	74		$mapping['declared'] = $parentClass->name;
291	74		}
292	74		$subClass->addInheritedFieldMapping($mapping);
293	290		}
294	290		foreach ($parentClass->reflFields as $name => $field) {
295	74		$subClass->reflFields[$name] = $field;
296	290		}
297	290		}
298
299
300			/**
301			* Adds inherited association mappings to the subclass mapping.
302			*
303			* @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
304			* @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
305			*
306			* @return void
307			*
308			* @throws MappingException
309			*/
310	290		private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass)
311			{
312	290		foreach ($parentClass->associationMappings as $field => $mapping) {
313	41		if ($parentClass->isMappedSuperclass) {
314	3		$mapping['sourceDocument'] = $subClass->name;
315	3		}
316
317	41	View Code Duplication	if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
			0 ignored issues – show Duplication introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
318	38		$mapping['inherited'] = $parentClass->name;
319	38		}
320	41		if ( ! isset($mapping['declared'])) {
321	41		$mapping['declared'] = $parentClass->name;
322	41		}
323	41		$subClass->addInheritedAssociationMapping($mapping);
324	290		}
325	290		}
326
327			/**
328			* Adds inherited indexes to the subclass mapping.
329			*
330			* @param ClassMetadata $subClass
331			* @param ClassMetadata $parentClass
332			*/
333	290		private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass)
334			{
335	290		foreach ($parentClass->indexes as $index) {
336	19		$subClass->addIndex($index['keys'], $index['options']);
337	290		}
338	290		}
339			}
340

doctrine / mongodb-odm

Push — 1.0.x ( 0605bb...052971 )

ClassMetadataFactory::newClassMetadataInstance() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like