Refactored the doctrine compiler pass

Author: Nyholm

src/DependencyInjection/CacheExtension.php

@@ -14,8 +14,7 @@
 use Cache\Bridge\DoctrineCacheBridge;
 use Cache\CacheBundle\Bridge\SessionHandlerBridge;
 use Cache\CacheBundle\Bridge\SymfonyValidatorBridge;
-use Cache\CacheBundle\Factory\AnnotationFactory;
-use Cache\CacheBundle\Factory\SerializerFactory;
+use Cache\CacheBundle\Factory\DoctrineBridgeFactory;
 use Cache\CacheBundle\Factory\ValidationFactory;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -51,17 +50,19 @@ public function load(array $configs, ContainerBuilder $container)
         if ($config['annotation']['enabled']) {
             $this->verifyDoctrineBridgeExists('annotation');
             $container->register('cache.service.annotation', DoctrineCacheBridge::class)
-                ->setFactory([AnnotationFactory::class, 'get'])
+                ->setFactory([DoctrineBridgeFactory::class, 'get'])
                 ->addArgument(new Reference($config['annotation']['service_id']))
-                ->addArgument($config['annotation']);
+                ->addArgument($config['annotation'])
+                ->addArgument('annotation');
         }
 
         if ($config['serializer']['enabled']) {
             $this->verifyDoctrineBridgeExists('serializer');
             $container->register('cache.service.serializer', DoctrineCacheBridge::class)
-                ->setFactory([SerializerFactory::class, 'get'])
+                ->setFactory([DoctrineBridgeFactory::class, 'get'])
                 ->addArgument(new Reference($config['serializer']['service_id']))
-                ->addArgument($config['serializer']);
+                ->addArgument($config['serializer'])
+                ->addArgument('serializer');
         }
 
         if ($config['validation']['enabled']) {

src/DependencyInjection/Compiler/DoctrineSupportCompilerPass.php

@@ -13,6 +13,7 @@
 
 use Cache\Bridge\DoctrineCacheBridge;
 use Cache\CacheBundle\Cache\FixedTaggingCachePool;
+use Cache\CacheBundle\Factory\DoctrineBridgeFactory;
 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -70,19 +71,23 @@ public function process(ContainerBuilder $container)
     protected function enableDoctrineSupport(array $config)
     {
         $types = ['entity_managers', 'document_managers'];
-        foreach ($config as $cacheType => $cacheData) {
+        // For each ['metadata' => [], 'result' => [], 'query' => []]
+        foreach ($config as $cacheType => $typeConfig) {
             foreach ($types as $type) {
-                if (!isset($cacheData[$type])) {
+                if (!isset($typeConfig[$type])) {
                     continue;
                 }
 
                 // Doctrine can't talk to a PSR-6 cache, so we need a bridge
-                $bridgeServiceId = sprintf('cache.provider.doctrine.%s.bridge', $cacheType);
-                $bridgeDef       = $this->container->register($bridgeServiceId, DoctrineCacheBridge::class);
-                $bridgeDef->addArgument(new Reference($this->getPoolReferenceForBridge($bridgeServiceId, $cacheData, $config['use_tagging'])))
-                    ->setPublic(false);
-
-                foreach ($cacheData[$type] as $manager) {
+                $bridgeServiceId = sprintf('cache.service.doctrine.%s.%s.bridge', $cacheType, $type);
+                $this->container->register($bridgeServiceId, FixedTaggingCachePool::class)
+                    ->setPublic(false)
+                    ->setFactory([DoctrineBridgeFactory::class, 'get'])
+                    ->addArgument(new Reference($typeConfig['service_id']))
+                    ->addArgument($typeConfig)
+                    ->addArgument(['doctrine', $cacheType]);
+
+                foreach ($typeConfig[$type] as $manager) {
                     $doctrineDefinitionId =
                         sprintf(
                             'doctrine.%s.%s_%s_cache',
@@ -98,31 +103,6 @@ protected function enableDoctrineSupport(array $config)
         }
     }
 
-    /**
-     * Get a reference string for the PSR-6 cache implementation service to use with doctrine.
-     * If we support tagging we use the DoctrineTaggingCachePool.
-     *
-     * @param string $bridgeServiceId
-     * @param array  $cacheData
-     * @param bool   $tagging
-     *
-     * @return string
-     */
-    public function getPoolReferenceForBridge($bridgeServiceId, $cacheData, $tagging)
-    {
-        if (!$tagging) {
-            return $cacheData['service_id'];
-        }
-
-        $taggingServiceId = $bridgeServiceId.'.tagging';
-        $taggingDef       = $this->container->register($taggingServiceId, FixedTaggingCachePool::class);
-        $taggingDef->addArgument(new Reference($cacheData['service_id']))
-            ->addArgument(['doctrine'])
-            ->setPublic(false);
-
-        return $taggingServiceId;
-    }
-
     /**
      * Checks to see if there are ORM's or ODM's.
      *

src/Factory/AnnotationFactory.php src/Factory/DoctrineBridgeFactory.phpsrc/Factory/AnnotationFactory.php renamed to src/Factory/DoctrineBridgeFactory.php

@@ -18,18 +18,19 @@
 /**
  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  */
-class AnnotationFactory
+class DoctrineBridgeFactory
 {
     /**
      * @param CacheItemPoolInterface $pool
      * @param array                  $config
+     * @param array                  $tags
      *
      * @return DoctrineCacheBridge
      */
-    public static function get(CacheItemPoolInterface $pool, $config)
+    public static function get(CacheItemPoolInterface $pool, $config, array $tags)
     {
         if ($config['use_tagging']) {
-            $pool = new FixedTaggingCachePool($pool, ['annotation']);
+            $pool = new FixedTaggingCachePool($pool, $tags);
         }
 
         return new DoctrineCacheBridge($pool);