bankiru / doctrine-api-client

EntityMetadataFactory.php

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

$class of type object<Doctrine\Common\Persistence\Mapping\ClassMetadata> is not a sub-type of object<Bankiru\Api\Doctrine\Mapping\EntityMetadata>. It seems like you assume a concrete implementation of the interface Doctrine\Common\Persistence\Mapping\ClassMetadata to be always present.

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

$class of type object<Doctrine\Common\Persistence\Mapping\ClassMetadata> is not a sub-type of object<Bankiru\Api\Doctrine\Mapping\EntityMetadata>. It seems like you assume a concrete implementation of the interface Doctrine\Common\Persistence\Mapping\ClassMetadata to be always present.

            $class->setIdentifier($parent->identifier);
            $class->apiFactory     = $parent->apiFactory;

Accessing apiFactory on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            $class->clientName     = $parent->clientName;

Accessing clientName on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            $class->methodProvider = $parent->methodProvider;

Accessing methodProvider on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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) {

Accessing discriminatorMap on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            $this->addDefaultDiscriminatorMap($class);

$class of type object<Doctrine\Common\Persistence\Mapping\ClassMetadata> is not a sub-type of object<Bankiru\Api\Doctrine\Mapping\EntityMetadata>. It seems like you assume a concrete implementation of the interface Doctrine\Common\Persistence\Mapping\ClassMetadata to be always present.

        }
    }

    /**
     * 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

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.

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

The property $discriminatorValue was declared of type string, but $discriminatorValue is of type integer. Maybe add a type cast?

                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)) {

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.

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

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.

            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) {

This code seems to be duplicated across your project.

            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) {

This code seems to be duplicated across your project.

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