ClassMetadataFactory::getFqcnFromAlias() - Code Metrics - Inspection of "Remove | separators" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0.x (#1777)

by Maciej

created 2018-04-10 14:22 UTC

ClassMetadataFactory::getFqcnFromAlias() 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.037

Importance

Changes

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

<?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']);
        }
    }
}


Pull Request — 1.0.x (#1777)

ClassMetadataFactory::getFqcnFromAlias() 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	968		public function setDocumentManager(DocumentManager $dm)
62			{
63	968		$this->dm = $dm;
64	968		}
65
66			/**
67			* Sets the Configuration instance
68			*
69			* @param Configuration $config
70			*/
71	968		public function setConfiguration(Configuration $config)
72			{
73	968		$this->config = $config;
74	968		}
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	775		protected function initialize()
81			{
82	775		$this->driver = $this->config->getMetadataDriverImpl();
83	775		$this->evm = $this->dm->getEventManager();
84	775		$this->initialized = true;
85	775		}
86
87			/**
88			* {@inheritDoc}
89			*/
90	2		protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
91			{
92			return $this->config->getDocumentNamespace($namespaceAlias) . '\\' . $simpleClassName;
93	2		}
94
95			/**
96			* {@inheritDoc}
97			*/
98	293		protected function getDriver()
99			{
100	293		return $this->driver;
101			}
102
103			/**
104			* {@inheritDoc}
105			*/
106	772		protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
107			{
108	772		}
109
110			/**
111			* {@inheritDoc}
112			*/
113	775		protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
114			{
115	775		}
116
117			/**
118			* {@inheritDoc}
119			*/
120	772		protected function isEntity(ClassMetadataInterface $class)
121			{
122	772		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	775		protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents = array())
129			{
130			/** @var $class ClassMetadata */
131			/** @var $parent ClassMetadata */
132	775		if ($parent) {
133	291		$class->setInheritanceType($parent->inheritanceType);
134	291		$class->setDiscriminatorField($parent->discriminatorField);
135	291		$class->setDiscriminatorMap($parent->discriminatorMap);
136	291		$class->setDefaultDiscriminatorValue($parent->defaultDiscriminatorValue);
137	291		$class->setIdGeneratorType($parent->generatorType);
138	291		$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	291		$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	291		$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	291		$class->setIdentifier($parent->identifier);
142	291		$class->setVersioned($parent->isVersioned);
143	291		$class->setVersionField($parent->versionField);
144	291		$class->setLifecycleCallbacks($parent->lifecycleCallbacks);
145	291		$class->setAlsoLoadMethods($parent->alsoLoadMethods);
146	291		$class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
147	291		$class->setFile($parent->getFile());
148	291		if ($parent->isMappedSuperclass) {
149	244		$class->setCustomRepositoryClass($parent->customRepositoryClassName);
150	244		}
151	291		}
152
153			// Invoke driver
154			try {
155	775		$this->driver->loadMetadataForClass($class->getName(), $class);
156	775		} catch (\ReflectionException $e) {
157			throw MappingException::reflectionFailure($class->getName(), $e);
158			}
159
160	772		$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	772		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	59		if ($parent->generatorType) {
164	59		$class->setIdGeneratorType($parent->generatorType);
165	59		}
166	59		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	59		if ($parent->idGenerator) {
170	59		$class->setIdGenerator($parent->idGenerator);
171	59		}
172	59		} else {
173	772		$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	772		if ($parent && $parent->isInheritanceTypeSingleCollection()) {
177	46		$class->setDatabase($parent->getDatabase());
178	46		$class->setCollection($parent->getCollection());
179	46		}
180
181	772		$class->setParentClasses($nonSuperclassParents);
182
183	772	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	772		}
188
189			/**
190			* Validates the identifier mapping.
191			*
192			* @param ClassMetadata $class
193			* @throws MappingException
194			*/
195	772		protected function validateIdentifier($class)
196			{
197	772		if ( ! $class->identifier && ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument) {
198			throw MappingException::identifierRequired($class->name);
199			}
200	772		}
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	775		protected function newClassMetadataInstance($className)
209			{
210	775		return new ClassMetadata($className);
211			}
212
213	772		private function completeIdGeneratorMapping(ClassMetadataInfo $class)
214			{
215	772		$idGenOptions = $class->generatorOptions;
216	772		switch ($class->generatorType) {
217	772		case ClassMetadata::GENERATOR_TYPE_AUTO:
218	706		$class->setIdGenerator(new \Doctrine\ODM\MongoDB\Id\AutoGenerator());
219	706		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	772		}
275	772		}
276
277			/**
278			* Adds inherited fields to the subclass mapping.
279			*
280			* @param ClassMetadata $subClass
281			* @param ClassMetadata $parentClass
282			*/
283	291		private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass)
284			{
285	291		foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
286	75	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	70		$mapping['inherited'] = $parentClass->name;
288	70		}
289	75		if ( ! isset($mapping['declared'])) {
290	75		$mapping['declared'] = $parentClass->name;
291	75		}
292	75		$subClass->addInheritedFieldMapping($mapping);
293	291		}
294	291		foreach ($parentClass->reflFields as $name => $field) {
295	75		$subClass->reflFields[$name] = $field;
296	291		}
297	291		}
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	291		private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass)
311			{
312	291		foreach ($parentClass->associationMappings as $field => $mapping) {
313	42		if ($parentClass->isMappedSuperclass) {
314	3		$mapping['sourceDocument'] = $subClass->name;
315	3		}
316
317	42	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	39		$mapping['inherited'] = $parentClass->name;
319	39		}
320	42		if ( ! isset($mapping['declared'])) {
321	42		$mapping['declared'] = $parentClass->name;
322	42		}
323	42		$subClass->addInheritedAssociationMapping($mapping);
324	291		}
325	291		}
326
327			/**
328			* Adds inherited indexes to the subclass mapping.
329			*
330			* @param ClassMetadata $subClass
331			* @param ClassMetadata $parentClass
332			*/
333	291		private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass)
334			{
335	291		foreach ($parentClass->indexes as $index) {
336	19		$subClass->addIndex($index['keys'], $index['options']);
337	291		}
338	291		}
339			}
340

doctrine / mongodb-odm

Pull Request — 1.0.x (#1777)

ClassMetadataFactory::getFqcnFromAlias() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like