vendor/gedmo/doctrine-extensions/src/Mapping/ExtensionMetadataFactory.php line 155

  1. <?php
  3. /*
  4.  * This file is part of the Doctrine Behavioral Extensions package.
  5.  * (c) Gediminas Morkevicius <gediminas.morkevicius@gmail.com> http://www.gediminasm.org
  6.  * For the full copyright and license information, please view the LICENSE
  7.  * file that was distributed with this source code.
  8.  */
  10. namespace Gedmo\Mapping;
  12. use Doctrine\Bundle\DoctrineBundle\Mapping\MappingDriver as DoctrineBundleMappingDriver;
  13. use Doctrine\Common\Annotations\Reader;
  14. use Doctrine\Deprecations\Deprecation;
  15. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as DocumentClassMetadata;
  16. use Doctrine\ORM\Mapping\ClassMetadata as EntityClassMetadata;
  17. use Doctrine\ORM\Mapping\ClassMetadataInfo as LegacyEntityClassMetadata;
  18. use Doctrine\Persistence\Mapping\ClassMetadata;
  19. use Doctrine\Persistence\Mapping\Driver\DefaultFileLocator;
  20. use Doctrine\Persistence\Mapping\Driver\MappingDriver;
  21. use Doctrine\Persistence\Mapping\Driver\MappingDriverChain;
  22. use Doctrine\Persistence\Mapping\Driver\SymfonyFileLocator;
  23. use Doctrine\Persistence\ObjectManager;
  24. use Gedmo\Exception\RuntimeException;
  25. use Gedmo\Mapping\Driver\AnnotationDriverInterface;
  26. use Gedmo\Mapping\Driver\AttributeAnnotationReader;
  27. use Gedmo\Mapping\Driver\AttributeDriverInterface;
  28. use Gedmo\Mapping\Driver\AttributeReader;
  29. use Gedmo\Mapping\Driver\Chain;
  30. use Gedmo\Mapping\Driver\File as FileDriver;
  31. use Psr\Cache\CacheItemPoolInterface;
  33. /**
  34.  * The extension metadata factory is responsible for extension driver
  35.  * initialization and fully reading the extension metadata
  36.  *
  37.  * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
  38.  *
  39.  * @final since gedmo/doctrine-extensions 3.11
  40.  */
  41. class ExtensionMetadataFactory
  42. {
  43.     /**
  44.      * Extension driver
  45.      *
  46.      * @var Driver
  47.      */
  48.     protected $driver;
  50.     /**
  51.      * Object manager, entity or document
  52.      *
  53.      * @var ObjectManager
  54.      */
  55.     protected $objectManager;
  57.     /**
  58.      * Extension namespace
  59.      *
  60.      * @var string
  61.      */
  62.     protected $extensionNamespace;
  64.     /**
  65.      * Metadata annotation reader
  66.      *
  67.      * @var Reader|AttributeReader|object|null
  68.      */
  69.     protected $annotationReader;
  71.     private ?CacheItemPoolInterface $cacheItemPool = null;
  73.     /**
  74.      * @param Reader|AttributeReader|object|null $annotationReader
  75.      *
  76.      * @note Providing any object as the third argument is deprecated, as of 4.0 an {@see AttributeReader} will be required
  77.      */
  78.     public function __construct(ObjectManager $objectManager, string $extensionNamespace, ?object $annotationReader = null, ?CacheItemPoolInterface $cacheItemPool = null)
  79.     {
  80.         if (null !== $annotationReader) {
  81.             if ($annotationReader instanceof Reader) {
  82.                 Deprecation::trigger(
  83.                     'gedmo/doctrine-extensions',
  84.                     'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2772',
  85.                     'Annotations support is deprecated, migrate your application to use attributes and pass an instance of %s to the %s constructor instead.',
  86.                     AttributeReader::class,
  87.                     static::class
  88.                 );
  89.             } elseif (!$annotationReader instanceof AttributeReader) {
  90.                 Deprecation::trigger(
  91.                     'gedmo/doctrine-extensions',
  92.                     'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2258',
  93.                     'Providing an annotation reader which does not implement %s or is not an instance of %s to %s is deprecated.',
  94.                     Reader::class,
  95.                     AttributeReader::class,
  96.                     static::class
  97.                 );
  98.             }
  99.         }
  101.         $this->objectManager = $objectManager;
  102.         $this->annotationReader = $annotationReader;
  103.         $this->extensionNamespace = $extensionNamespace;
  104.         $omDriver = $objectManager->getConfiguration()->getMetadataDriverImpl();
  105.         $this->driver = $this->getDriver($omDriver);
  106.         $this->cacheItemPool = $cacheItemPool;
  107.     }
  109.     /**
  110.      * Reads extension metadata
  111.      *
  112.      * @param ClassMetadata<object>&(DocumentClassMetadata<object>|EntityClassMetadata<object>|LegacyEntityClassMetadata<object>) $meta
  113.      *
  114.      * @return array<string, mixed> the metadata configuration
  115.      */
  116.     public function getExtensionMetadata($meta)
  117.     {
  118.         if ($meta->isMappedSuperclass) {
  119.             return []; // ignore mappedSuperclasses for now
  120.         }
  121.         $config = [];
  122.         $cmf = $this->objectManager->getMetadataFactory();
  123.         $useObjectName = $meta->getName();
  124.         // collect metadata from inherited classes
  125.         if (null !== $meta->reflClass) {
  126.             foreach (array_reverse(class_parents($meta->getName())) as $parentClass) {
  127.                 // read only inherited mapped classes
  128.                 if ($cmf->hasMetadataFor($parentClass) || !$cmf->isTransient($parentClass)) {
  129.                     assert(class_exists($parentClass));
  131.                     $class = $this->objectManager->getClassMetadata($parentClass);
  133.                     assert($class instanceof DocumentClassMetadata || $class instanceof EntityClassMetadata || $class instanceof LegacyEntityClassMetadata);
  135.                     $extendedMetadata = $this->driver->readExtendedMetadata($class, $config);
  137.                     if (\is_array($extendedMetadata)) {
  138.                         $config = $extendedMetadata;
  139.                     }
  141.                     // @todo: In the next major release remove the assignment to `$extendedMetadata`, the previous conditional
  142.                     // block and uncomment the following line.
  143.                     // $config = $this->driver->readExtendedMetadata($class, $config);
  145.                     $isBaseInheritanceLevel = !$class->isInheritanceTypeNone()
  146.                         && [] === $class->parentClasses
  147.                         && [] !== $config
  148.                     ;
  149.                     if ($isBaseInheritanceLevel) {
  150.                         $useObjectName = $class->getName();
  151.                     }
  152.                 }
  153.             }
  155.             $extendedMetadata = $this->driver->readExtendedMetadata($meta, $config);
  157.             if (\is_array($extendedMetadata)) {
  158.                 $config = $extendedMetadata;
  159.             }
  161.             // @todo: In the next major release remove the assignment to `$extendedMetadata`, the previous conditional
  162.             // block and uncomment the following line.
  163.             // $config = $this->driver->readExtendedMetadata($meta, $config);
  164.         }
  165.         if ([] !== $config) {
  166.             $config['useObjectClass'] = $useObjectName;
  167.         }
  169.         $this->storeConfiguration($meta->getName(), $config);
  171.         return $config;
  172.     }
  174.     /**
  175.      * Get the cache id
  176.      *
  177.      * @param string $className
  178.      * @param string $extensionNamespace
  179.      *
  180.      * @return string
  181.      */
  182.     public static function getCacheId($className, $extensionNamespace)
  183.     {
  184.         return str_replace('\\', '_', $className).'_$'.strtoupper(str_replace('\\', '_', $extensionNamespace)).'_CLASSMETADATA';
  185.     }
  187.     /**
  188.      * Get the extended driver instance which will
  189.      * read the metadata required by extension
  190.      *
  191.      * @param MappingDriver $omDriver
  192.      *
  193.      * @throws RuntimeException if driver was not found in extension
  194.      *
  195.      * @return Driver
  196.      */
  197.     protected function getDriver($omDriver)
  198.     {
  199.         if ($omDriver instanceof DoctrineBundleMappingDriver) {
  200.             $omDriver = $omDriver->getDriver();
  201.         }
  203.         $driver = null;
  204.         $className = get_class($omDriver);
  205.         $driverName = substr($className, strrpos($className, '\\') + 1);
  206.         if ($omDriver instanceof MappingDriverChain || 'DriverChain' === $driverName) {
  207.             $driver = new Chain();
  208.             foreach ($omDriver->getDrivers() as $namespace => $nestedOmDriver) {
  209.                 $driver->addDriver($this->getDriver($nestedOmDriver), $namespace);
  210.             }
  211.             if (null !== $omDriver->getDefaultDriver()) {
  212.                 $driver->setDefaultDriver($this->getDriver($omDriver->getDefaultDriver()));
  213.             }
  214.         } else {
  215.             $driverName = substr($driverName, 0, strpos($driverName, 'Driver'));
  216.             $isSimplified = false;
  217.             if ('Simplified' === substr($driverName, 0, 10)) {
  218.                 // support for simplified file drivers
  219.                 $driverName = substr($driverName, 10);
  220.                 $isSimplified = true;
  221.             }
  222.             // create driver instance
  223.             $driverClassName = $this->extensionNamespace.'\Mapping\Driver\\'.$driverName;
  224.             if (!class_exists($driverClassName)) {
  225.                 $originalDriverClassName = $driverClassName;
  227.                 // try to fall back to either an annotation or attribute driver depending on the available dependencies
  228.                 if (interface_exists(Reader::class)) {
  229.                     $driverClassName = $this->extensionNamespace.'\Mapping\Driver\Annotation';
  230.                 } elseif (\PHP_VERSION_ID >= 80000) {
  231.                     $driverClassName = $this->extensionNamespace.'\Mapping\Driver\Attribute';
  232.                 }
  234.                 if (!class_exists($driverClassName)) {
  235.                     if ($originalDriverClassName !== $driverClassName) {
  236.                         throw new RuntimeException("Failed to create mapping driver: ({$originalDriverClassName}), the extension driver nor a fallback annotation or attribute driver could be found.");
  237.                     }
  239.                     throw new RuntimeException("Failed to fallback to annotation driver: ({$driverClassName}), extension driver was not found.");
  240.                 }
  241.             }
  242.             $driver = new $driverClassName();
  243.             $driver->setOriginalDriver($omDriver);
  244.             if ($driver instanceof FileDriver) {
  245.                 if ($omDriver instanceof MappingDriver) {
  246.                     $driver->setLocator($omDriver->getLocator());
  247.                 // BC for Doctrine 2.2
  248.                 } elseif ($isSimplified) {
  249.                     $driver->setLocator(new SymfonyFileLocator($omDriver->getNamespacePrefixes(), $omDriver->getFileExtension()));
  250.                 } else {
  251.                     $driver->setLocator(new DefaultFileLocator($omDriver->getPaths(), $omDriver->getFileExtension()));
  252.                 }
  253.             }
  255.             if ($driver instanceof AttributeDriverInterface) {
  256.                 if (null === $this->annotationReader) {
  257.                     throw new RuntimeException("Cannot use metadata driver ({$driverClassName}), an annotation or attribute reader was not provided.");
  258.                 }
  260.                 if ($driver instanceof AnnotationDriverInterface) {
  261.                     $driver->setAnnotationReader($this->annotationReader);
  262.                 } else {
  263.                     if ($this->annotationReader instanceof AttributeReader) {
  264.                         $driver->setAnnotationReader($this->annotationReader);
  265.                     } else {
  266.                         $driver->setAnnotationReader(new AttributeAnnotationReader(new AttributeReader(), $this->annotationReader));
  267.                     }
  268.                 }
  269.             }
  270.         }
  272.         return $driver;
  273.     }
  275.     /**
  276.      * @param array<string, mixed> $config
  277.      */
  278.     private function storeConfiguration(string $className, array $config): void
  279.     {
  280.         if (null === $this->cacheItemPool) {
  281.             return;
  282.         }
  284.         // Cache the result, even if it's empty, to prevent re-parsing non-existent annotations.
  285.         $cacheId = self::getCacheId($className, $this->extensionNamespace);
  287.         $item = $this->cacheItemPool->getItem($cacheId);
  289.         $this->cacheItemPool->save($item->set($config));
  290.     }
  291. }