EntityMetadataFactory - Code Metrics - Inspection of "Filter abstract classes from discriminator map" - bankiru/doctrine-api-client - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e75d59...99d075 )

by Pavel

created 2017-05-05 12:33 UTC

EntityMetadataFactory B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	306
Duplicated Lines	5.88 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

76.87%

Importance

Changes

Metric	Value
wmc	51
lcom	2
cbo	8
dl	18
loc	306
ccs	103
cts	134
cp	0.7687
rs	8.3206
c	0
b	0
f	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	registerAlias()	0	8	2
A	setEntityManager()	0	4	1
A	loadMetadata()	0	7	1
A	initialize()	0	5	1
A	getFqcnFromAlias()	0	8	2
A	wakeupReflection()	0	9	2
A	initializeReflection()	0	9	2
A	isEntity()	0	4	1
D	doLoadMetadata()	0	42	9
A	getDriver()	0	4	1
A	newClassMetadataInstance()	0	4	1
B	addDefaultDiscriminatorMap()	0	20	5
A	getShortName()	0	9	2
B	addInheritedFields()	9	15	6
B	addInheritedRelations()	9	12	5
D	resolveDiscriminatorValue()	0	29	10

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like EntityMetadataFactory often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use EntityMetadataFactory, and based on these observations, apply Extract Interface, too.

<?php

namespace Bankiru\Api\Doctrine;

use Bankiru\Api\Doctrine\Exception\MappingException;
use Bankiru\Api\Doctrine\Mapping\EntityMetadata;
use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Common\Persistence\Mapping\ReflectionService;
use ReflectionException;

class EntityMetadataFactory extends AbstractClassMetadataFactory
{
    /** @var  EntityManager */
    private $manager;
    /** @var  MappingDriver */
    private $driver;

    /** @var string[] */
    private $aliases = [];

    public function registerAlias($namespaceAlias, $namespace)
    {
        if (array_key_exists($namespaceAlias, $this->aliases)) {
            throw new \LogicException(sprintf('Alias "%s" is already registered', $namespaceAlias));
        }

        $this->aliases[$namespaceAlias] = rtrim($namespace, '\\');
    }

    /**
     * @param EntityManager $manager
     */
    public function setEntityManager($manager)
    {
        $this->manager = $manager;
    }

    /**
     * {@inheritDoc}
     */
    protected function loadMetadata($name)
    {
        $loaded = parent::loadMetadata($name);
        array_map([$this, 'resolveDiscriminatorValue'], array_map([$this, 'getMetadataFor'], $loaded));

        return $loaded;
    }

    /** {@inheritdoc} */
    protected function initialize()
    {
        $this->driver      = $this->manager->getConfiguration()->getDriver();
        $this->initialized = true;
    }

    /**
     * {@inheritdoc}
     * @throws MappingException
     */
    protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
    {
        if (!array_key_exists($namespaceAlias, $this->aliases)) {
            throw MappingException::unknownAlias($namespaceAlias);
        }

        return $this->aliases[$namespaceAlias] . $simpleClassName;
    }

    /** {@inheritdoc} */
    protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService)
    {
        if (!($class instanceof EntityMetadata)) {
            throw new \LogicException('Metadata is not supported');
        }

        /** @var EntityMetadata $class */
        $class->wakeupReflection($reflService);
    }

    /**
     * Initializes Reflection after ClassMetadata was constructed.
     *
     * @param ClassMetadata     $class
     * @param ReflectionService $reflService
     *
     * @return void
     */
    protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService)
    {
        if (!($class instanceof EntityMetadata)) {
            throw new \LogicException('Metadata is not supported');
        }

        /** @var EntityMetadata $class */
        $class->initializeReflection($reflService);
    }

    /**
     * Checks whether the class metadata is an entity.
     *
     * This method should return false for mapped superclasses or embedded classes.
     *
     * @param ClassMetadata $class
     *
     * @return boolean
     */
    protected function isEntity(ClassMetadata $class)
    {
        return true;
    }

    /** {@inheritdoc} */
    protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
    {
        /* @var $class EntityMetadata */
        /* @var $parent EntityMetadata */
        if ($parent) {
            $this->addInheritedFields($class, $parent);

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

            $class->setIdentifier($parent->identifier);
            $class->apiFactory     = $parent->apiFactory;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $class->clientName     = $parent->clientName;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $class->methodProvider = $parent->methodProvider;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

            $class->setIdGeneratorType($parent->generatorType);
            $class->setDiscriminatorField($parent->discriminatorField);
            $class->setDiscriminatorMap($parent->discriminatorMap);

            if ($parent->isMappedSuperclass) {
                $class->setCustomRepositoryClass($parent->repositoryClass);
            }
        }

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

        if ($parent) {
            $classCache = $this->manager->getConfiguration()->getCacheConfiguration($class->getName());
            if (!$classCache->isEnabled()) {
                $parentCache = $this->manager->getConfiguration()->getCacheConfiguration($parent->getName());
                if ($parentCache->isEnabled()) {
                    $this->manager->getConfiguration()->setCacheConfigurationInstance($class->getName(), $parentCache);
                }
            }
        }

        if ($class->isRootEntity() && !$class->discriminatorMap) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

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

        }
    }

    /**
     * Returns the mapping driver implementation.
     *
     * @return \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver
     */
    protected function getDriver()
    {
        return $this->driver;
    }

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

    /**
     * Populates the discriminator value of the given metadata (if not set) by iterating over discriminator
     * map classes and looking for a fitting one.
     *
     * @param EntityMetadata $metadata
     *
     * @return void
     *
     * @throws MappingException
     */
    private function resolveDiscriminatorValue(EntityMetadata $metadata)
    {
        if ($metadata->discriminatorValue
            || !$metadata->discriminatorMap

            || $metadata->isMappedSuperclass
            || !$metadata->reflClass
            || $metadata->reflClass->isAbstract()
        ) {
            return;
        }
        // minor optimization: avoid loading related metadata when not needed
        foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
            if ($discriminatorClass === $metadata->name) {
                $metadata->discriminatorValue = $discriminatorValue;
$answer = 42;

$correct = false;

$correct = (bool) $answer;

                return;
            }
        }
        // iterate over discriminator mappings and resolve actual referenced classes according to existing metadata
        foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
            if ($metadata->name === $this->getMetadataFor($discriminatorClass)->getName()) {
                $metadata->discriminatorValue = $discriminatorValue;

                return;
            }
        }

        throw MappingException::mappedClassNotPartOfDiscriminatorMap($metadata->name, $metadata->rootEntityName);
    }

    /**
     * Adds a default discriminator map if no one is given
     *
     * If an entity is of any inheritance type and does not contain a
     * discriminator map, then the map is generated automatically. This process
     * is expensive computation wise.
     *
     * The automatically generated discriminator map contains the lowercase short name of
     * each class as key.
     *
     * @param EntityMetadata $class
     *
     * @throws MappingException
     */
    private function addDefaultDiscriminatorMap(EntityMetadata $class)
    {
        $allClasses = $this->driver->getAllClassNames();
        $fqcn       = $class->getName();
        $map        = [$this->getShortName($class->name) => $fqcn];
        $duplicates = [];
        foreach ($allClasses as $subClassCandidate) {
            if (is_subclass_of($subClassCandidate, $fqcn)) {

                $shortName = $this->getShortName($subClassCandidate);
                if (isset($map[$shortName])) {
                    $duplicates[] = $shortName;
                }
                $map[$shortName] = $subClassCandidate;
            }
        }
        if ($duplicates) {

            throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
        }
        $class->setDiscriminatorMap($map);
    }

    /**
     * Gets the lower-case short name of a class.
     *
     * @param string $className
     *
     * @return string
     */
    private function getShortName($className)
    {
        if (strpos($className, "\\") === false) {
            return strtolower($className);
        }
        $parts = explode("\\", $className);

        return strtolower(end($parts));
    }

    /**
     * Adds inherited fields to the subclass mapping.
     *
     * @param EntityMetadata $subClass
     * @param EntityMetadata $parentClass
     *
     * @return void
     */
    private function addInheritedFields(EntityMetadata $subClass, EntityMetadata $parentClass)
    {
        foreach ($parentClass->fields as $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 EntityMetadata $subClass
     * @param EntityMetadata $parentClass
     *
     * @return void
     *
     * @throws MappingException
     */
    private function addInheritedRelations(EntityMetadata $subClass, EntityMetadata $parentClass)
    {
        foreach ($parentClass->associations as $mapping) {

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


Push — master ( e75d59...99d075 )

EntityMetadataFactory B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Bankiru\Api\Doctrine;
4
5			use Bankiru\Api\Doctrine\Exception\MappingException;
6			use Bankiru\Api\Doctrine\Mapping\EntityMetadata;
7			use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
8			use Doctrine\Common\Persistence\Mapping\ClassMetadata;
9			use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
10			use Doctrine\Common\Persistence\Mapping\ReflectionService;
11			use ReflectionException;
12
13			class EntityMetadataFactory extends AbstractClassMetadataFactory
14			{
15			/** @var EntityManager */
16			private $manager;
17			/** @var MappingDriver */
18			private $driver;
19
20			/** @var string[] */
21			private $aliases = [];
22
23			public function registerAlias($namespaceAlias, $namespace)
24			{
25			if (array_key_exists($namespaceAlias, $this->aliases)) {
26			throw new \LogicException(sprintf('Alias "%s" is already registered', $namespaceAlias));
27			}
28
29			$this->aliases[$namespaceAlias] = rtrim($namespace, '\\');
30			}
31
32			/**
33			* @param EntityManager $manager
34			*/
35	28		public function setEntityManager($manager)
36			{
37	28		$this->manager = $manager;
38	28		}
39
40			/**
41			* {@inheritDoc}
42			*/
43	28		protected function loadMetadata($name)
44			{
45	28		$loaded = parent::loadMetadata($name);
46	28		array_map([$this, 'resolveDiscriminatorValue'], array_map([$this, 'getMetadataFor'], $loaded));
47
48	28		return $loaded;
49			}
50
51			/** {@inheritdoc} */
52	28		protected function initialize()
53			{
54	28		$this->driver = $this->manager->getConfiguration()->getDriver();
55	28		$this->initialized = true;
56	28		}
57
58			/**
59			* {@inheritdoc}
60			* @throws MappingException
61			*/
62			protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
63			{
64			if (!array_key_exists($namespaceAlias, $this->aliases)) {
65			throw MappingException::unknownAlias($namespaceAlias);
66			}
67
68			return $this->aliases[$namespaceAlias] . $simpleClassName;
69			}
70
71			/** {@inheritdoc} */
72	28		protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService)
73			{
74	28		if (!($class instanceof EntityMetadata)) {
75			throw new \LogicException('Metadata is not supported');
76			}
77
78			/** @var EntityMetadata $class */
79	28		$class->wakeupReflection($reflService);
80	28		}
81
82			/**
83			* Initializes Reflection after ClassMetadata was constructed.
84			*
85			* @param ClassMetadata $class
86			* @param ReflectionService $reflService
87			*
88			* @return void
89			*/
90	28		protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService)
91			{
92	28		if (!($class instanceof EntityMetadata)) {
93			throw new \LogicException('Metadata is not supported');
94			}
95
96			/** @var EntityMetadata $class */
97	28		$class->initializeReflection($reflService);
98	28		}
99
100			/**
101			* Checks whether the class metadata is an entity.
102			*
103			* This method should return false for mapped superclasses or embedded classes.
104			*
105			* @param ClassMetadata $class
106			*
107			* @return boolean
108			*/
109	28		protected function isEntity(ClassMetadata $class)
110			{
111	28		return true;
112			}
113
114			/** {@inheritdoc} */
115	28		protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
116			{
117			/* @var $class EntityMetadata */
118			/* @var $parent EntityMetadata */
119	28		if ($parent) {
120	14		$this->addInheritedFields($class, $parent);
			0 ignored issues – show Compatibility introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Bankiru\Api\Doctr...Mapping\EntityMetadata>`. 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...
121	14		$this->addInheritedRelations($class, $parent);
			0 ignored issues – show Compatibility introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Bankiru\Api\Doctr...Mapping\EntityMetadata>`. 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...
122	14		$class->setIdentifier($parent->identifier);
123	14		$class->apiFactory = $parent->apiFactory;
			0 ignored issues – show Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report Accessing `apiFactory` 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...
124	14		$class->clientName = $parent->clientName;
			0 ignored issues – show Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report Accessing `clientName` 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...
125	14		$class->methodProvider = $parent->methodProvider;
			0 ignored issues – show Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report Accessing `methodProvider` 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...
126
127	14		$class->setIdGeneratorType($parent->generatorType);
128	14		$class->setDiscriminatorField($parent->discriminatorField);
129	14		$class->setDiscriminatorMap($parent->discriminatorMap);
130
131	14		if ($parent->isMappedSuperclass) {
132			$class->setCustomRepositoryClass($parent->repositoryClass);
133			}
134	14		}
135
136			// Invoke driver
137			try {
138	28		$this->getDriver()->loadMetadataForClass($class->getName(), $class);
139	28		} catch (ReflectionException $e) {
140			throw MappingException::nonExistingClass($class->getName());
141			}
142
143	28		if ($parent) {
144	14		$classCache = $this->manager->getConfiguration()->getCacheConfiguration($class->getName());
145	14		if (!$classCache->isEnabled()) {
146	14		$parentCache = $this->manager->getConfiguration()->getCacheConfiguration($parent->getName());
147	14		if ($parentCache->isEnabled()) {
148			$this->manager->getConfiguration()->setCacheConfigurationInstance($class->getName(), $parentCache);
149			}
150	14		}
151	14		}
152
153	28		if ($class->isRootEntity() && !$class->discriminatorMap) {
			0 ignored issues – show Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report Accessing `discriminatorMap` 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...
154	28		$this->addDefaultDiscriminatorMap($class);
			0 ignored issues – show Compatibility introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report `$class` of type `object<Doctrine\Common\P...\Mapping\ClassMetadata>` is not a sub-type of `object<Bankiru\Api\Doctr...Mapping\EntityMetadata>`. 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...
155	28		}
156	28		}
157
158			/**
159			* Returns the mapping driver implementation.
160			*
161			* @return \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver
162			*/
163	28		protected function getDriver()
164			{
165	28		return $this->driver;
166			}
167
168			/**
169			* Creates a new ClassMetadata instance for the given class name.
170			*
171			* @param string $className
172			*
173			* @return ClassMetadata
174			*/
175	28		protected function newClassMetadataInstance($className)
176			{
177	28		return new EntityMetadata($className);
178			}
179
180			/**
181			* Populates the discriminator value of the given metadata (if not set) by iterating over discriminator
182			* map classes and looking for a fitting one.
183			*
184			* @param EntityMetadata $metadata
185			*
186			* @return void
187			*
188			* @throws MappingException
189			*/
190	28		private function resolveDiscriminatorValue(EntityMetadata $metadata)
191			{
192	28		if ($metadata->discriminatorValue
193	4		\|\| !$metadata->discriminatorMap
			0 ignored issues – show Bug Best Practice introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report The expression `$metadata->discriminatorMap` of type `string[]` 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...
194	4		\|\| $metadata->isMappedSuperclass
195	4		\|\| !$metadata->reflClass
196	4		\|\| $metadata->reflClass->isAbstract()
197	28		) {
198	28		return;
199			}
200			// minor optimization: avoid loading related metadata when not needed
201			foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
202			if ($discriminatorClass === $metadata->name) {
203			$metadata->discriminatorValue = $discriminatorValue;
			0 ignored issues – show Documentation Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report The property `$discriminatorValue` was declared of type `string`, but `$discriminatorValue` is of type `integer`. Maybe add a type cast? This check looks for assignments to scalar types that may be of the wrong type. To ensure the code behaves as expected, it may be a good idea to add an explicit type cast. $answer = 42; $correct = false; $correct = (bool) $answer; Loading history...
204
205			return;
206			}
207			}
208			// iterate over discriminator mappings and resolve actual referenced classes according to existing metadata
209			foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
210			if ($metadata->name === $this->getMetadataFor($discriminatorClass)->getName()) {
211			$metadata->discriminatorValue = $discriminatorValue;
212
213			return;
214			}
215			}
216
217			throw MappingException::mappedClassNotPartOfDiscriminatorMap($metadata->name, $metadata->rootEntityName);
218			}
219
220			/**
221			* Adds a default discriminator map if no one is given
222			*
223			* If an entity is of any inheritance type and does not contain a
224			* discriminator map, then the map is generated automatically. This process
225			* is expensive computation wise.
226			*
227			* The automatically generated discriminator map contains the lowercase short name of
228			* each class as key.
229			*
230			* @param EntityMetadata $class
231			*
232			* @throws MappingException
233			*/
234	28		private function addDefaultDiscriminatorMap(EntityMetadata $class)
235			{
236	28		$allClasses = $this->driver->getAllClassNames();
237	28		$fqcn = $class->getName();
238	28		$map = [$this->getShortName($class->name) => $fqcn];
239	28		$duplicates = [];
240	28		foreach ($allClasses as $subClassCandidate) {
241	28		if (is_subclass_of($subClassCandidate, $fqcn)) {
			0 ignored issues – show Bug introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `$fqcn` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
242	20		$shortName = $this->getShortName($subClassCandidate);
243	20		if (isset($map[$shortName])) {
244			$duplicates[] = $shortName;
245			}
246	20		$map[$shortName] = $subClassCandidate;
247	20		}
248	28		}
249	28		if ($duplicates) {
			0 ignored issues – show Bug Best Practice introduced 2017-04-28 10:16 UTC by Report Bug Copy Issue Report The expression `$duplicates` 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...
250			throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
251			}
252	28		$class->setDiscriminatorMap($map);
253	28		}
254
255			/**
256			* Gets the lower-case short name of a class.
257			*
258			* @param string $className
259			*
260			* @return string
261			*/
262	28		private function getShortName($className)
263			{
264	28		if (strpos($className, "\\") === false) {
265			return strtolower($className);
266			}
267	28		$parts = explode("\\", $className);
268
269	28		return strtolower(end($parts));
270			}
271
272			/**
273			* Adds inherited fields to the subclass mapping.
274			*
275			* @param EntityMetadata $subClass
276			* @param EntityMetadata $parentClass
277			*
278			* @return void
279			*/
280	14		private function addInheritedFields(EntityMetadata $subClass, EntityMetadata $parentClass)
281			{
282	14	View Code Duplication	foreach ($parentClass->fields as $mapping) {
			0 ignored issues – show Duplication introduced 2016-10-20 19:34 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...
283	14		if (!isset($mapping['inherited']) && !$parentClass->isMappedSuperclass) {
284	14		$mapping['inherited'] = $parentClass->name;
285	14		}
286	14		if (!isset($mapping['declared'])) {
287	14		$mapping['declared'] = $parentClass->name;
288	14		}
289	14		$subClass->addInheritedFieldMapping($mapping);
290	14		}
291	14		foreach ($parentClass->reflFields as $name => $field) {
292	14		$subClass->reflFields[$name] = $field;
293	14		}
294	14		}
295
296			/**
297			* Adds inherited association mappings to the subclass mapping.
298			*
299			* @param EntityMetadata $subClass
300			* @param EntityMetadata $parentClass
301			*
302			* @return void
303			*
304			* @throws MappingException
305			*/
306	14		private function addInheritedRelations(EntityMetadata $subClass, EntityMetadata $parentClass)
307			{
308	14	View Code Duplication	foreach ($parentClass->associations as $mapping) {
			0 ignored issues – show Duplication introduced 2016-10-20 19:34 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...
309	10		if (!isset($mapping['inherited']) && !$parentClass->isMappedSuperclass) {
310	10		$mapping['inherited'] = $parentClass->name;
311	10		}
312	10		if (!isset($mapping['declared'])) {
313	10		$mapping['declared'] = $parentClass->name;
314	10		}
315	10		$subClass->addInheritedAssociationMapping($mapping);
316	14		}
317	14		}
318			}
319

bankiru / doctrine-api-client

Push — master ( e75d59...99d075 )

EntityMetadataFactory B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like