ClassMetadataFactory::completeIdGeneratorMapping() - Code Metrics - Inspection of "Fix broken conversion of microseconds less than 10..." - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0.x (#1382)

unknown

created 2016-03-09 16:17 UTC

ClassMetadataFactory::completeIdGeneratorMapping() C

↳ Parent: ClassMetadataFactory

Complexity

Conditions	17
Paths	20

Size

Total Lines	63
Code Lines	48

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	30
CRAP Score	44.1331

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	63
ccs	30
cts	55
cp	0.5455
rs	6.0439
cc	17
eloc	48
nc	20
nop	1
crap	44.1331

How to fix Long Method Complexity

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Mapping;

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 (#1382)

ClassMetadataFactory::completeIdGeneratorMapping() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

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

doctrine / mongodb-odm

Pull Request — 1.0.x (#1382)

ClassMetadataFactory::completeIdGeneratorMapping() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like