ClassMetadataFactory::getFqcnFromAlias() - Code Metrics - Inspection of "Let ReflectionException bubble" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0.x (#1320)

by Maciej

created 2015-12-20 22:47 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	0
CRAP Score	2

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

<?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 (#1320)

ClassMetadataFactory::getFqcnFromAlias() A

Complexity

Size

Duplication

Code Coverage

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

doctrine / mongodb-odm

Pull Request — 1.0.x (#1320)

ClassMetadataFactory::getFqcnFromAlias() A

Complexity

Size

Duplication

Code Coverage

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like