[Validator] Deprecated CacheInterface in favor of PSR-6.

Author: derrabus

CHANGELOG.md

@@ -22,6 +22,8 @@ CHANGELOG
    be used in the violation builder when both `min` and `max` are not null
  * added ability to use stringable objects as violation messages
  * Overriding the methods `ConstraintValidatorTestCase::setUp()` and `ConstraintValidatorTestCase::tearDown()` without the `void` return-type is deprecated.
+ * deprecated `Symfony\Component\Validator\Mapping\Cache\CacheInterface` in favor of PSR-6.
+ * deprecated `ValidatorBuilder::setMetadataCache`, use `ValidatorBuilder::setMappingCache` instead.
 
 4.3.0
 -----

Mapping/Cache/CacheInterface.php

@@ -13,10 +13,14 @@
 
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 
+@trigger_error(sprintf('The "%s" interface is deprecated since Symfony 4.4.', CacheInterface::class), E_USER_DEPRECATED);
+
 /**
  * Persists ClassMetadata instances in a cache.
  *
  * @author Bernhard Schussek <[email protected]>
+ *
+ * @deprecated since Symfony 4.4.
  */
 interface CacheInterface
 {

Mapping/Cache/DoctrineCache.php

@@ -14,10 +14,14 @@
 use Doctrine\Common\Cache\Cache;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4.', DoctrineCache::class), E_USER_DEPRECATED);
+
 /**
  * Adapts a Doctrine cache to a CacheInterface.
  *
  * @author Florian Voutzinos <[email protected]>
+ *
+ * @deprecated since Symfony 4.4.
  */
 final class DoctrineCache implements CacheInterface
 {

Mapping/Cache/Psr6Cache.php

@@ -14,10 +14,14 @@
 use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 
+@trigger_error(sprintf('The "%s" class is deprecated since Symfony 4.4.', Psr6Cache::class), E_USER_DEPRECATED);
+
 /**
  * PSR-6 adapter.
  *
  * @author Kévin Dunglas <[email protected]>
+ *
+ * @deprecated since Symfony 4.4.
  */
 class Psr6Cache implements CacheInterface
 {

Mapping/Factory/LazyLoadingMetadataFactory.php

@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Validator\Mapping\Factory;
 
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\Validator\Exception\NoSuchMetadataException;
 use Symfony\Component\Validator\Mapping\Cache\CacheInterface;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
@@ -51,12 +52,17 @@ class LazyLoadingMetadataFactory implements MetadataFactoryInterface
     /**
      * Creates a new metadata factory.
      *
-     * @param LoaderInterface|null $loader The loader for configuring new metadata
-     * @param CacheInterface|null  $cache  The cache for persisting metadata
-     *                                     between multiple PHP requests
+     * @param CacheItemPoolInterface|null $cache The cache for persisting metadata
+     *                                           between multiple PHP requests
      */
-    public function __construct(LoaderInterface $loader = null, CacheInterface $cache = null)
+    public function __construct(LoaderInterface $loader = null, $cache = null)
     {
+        if ($cache instanceof CacheInterface) {
+            @trigger_error(sprintf('Passing a "%s" to "%s" is deprecated in Symfony 4.4 and will trigger a TypeError in 5.0. Please pass an implementation of "%s" instead.', \get_class($cache), __METHOD__, CacheItemPoolInterface::class), E_USER_DEPRECATED);
+        } elseif (!$cache instanceof CacheItemPoolInterface && null !== $cache) {
+            throw new \TypeError(sprintf('Expected an instance of %s, got %s.', CacheItemPoolInterface::class, \is_object($cache) ? \get_class($cache) : \gettype($cache)));
+        }
+
         $this->loader = $loader;
         $this->cache = $cache;
     }
@@ -92,11 +98,24 @@ public function getMetadataFor($value)
             throw new NoSuchMetadataException(sprintf('The class or interface "%s" does not exist.', $class));
         }
 
-        if (null !== $this->cache && false !== ($metadata = $this->cache->read($class))) {
-            // Include constraints from the parent class
-            $this->mergeConstraints($metadata);
+        $cacheItem = null;
+        if ($this->cache instanceof CacheInterface) {
+            if ($metadata = $this->cache->read($class)) {
+                // Include constraints from the parent class
+                $this->mergeConstraints($metadata);
+
+                return $this->loadedClasses[$class] = $metadata;
+            }
+        } elseif (null !== $this->cache) {
+            $cacheItem = $this->cache->getItem($this->escapeClassName($class));
+            if ($cacheItem->isHit()) {
+                $metadata = $cacheItem->get();
 
-            return $this->loadedClasses[$class] = $metadata;
+                // Include constraints from the parent class
+                $this->mergeConstraints($metadata);
+
+                return $this->loadedClasses[$class] = $metadata;
+            }
         }
 
         $metadata = new ClassMetadata($class);
@@ -105,8 +124,10 @@ public function getMetadataFor($value)
             $this->loader->loadClassMetadata($metadata);
         }
 
-        if (null !== $this->cache) {
+        if ($this->cache instanceof CacheInterface) {
             $this->cache->write($metadata);
+        } elseif (null !== $cacheItem) {
+            $this->cache->save($cacheItem->set($metadata));
         }
 
         // Include constraints from the parent class
@@ -162,4 +183,17 @@ public function hasMetadataFor($value)
 
         return class_exists($class) || interface_exists($class, false);
     }
+
+    /**
+     * Replaces backslashes by dots in a class name.
+     */
+    private function escapeClassName(string $class): string
+    {
+        if (false !== strpos($class, '@')) {
+            // anonymous class: replace all PSR6-reserved characters
+            return str_replace(["\0", '\\', '/', '@', ':', '{', '}', '(', ')'], '.', $class);
+        }
+
+        return str_replace('\\', '.', $class);
+    }
 }

Tests/Mapping/Cache/DoctrineCacheTest.php

@@ -14,6 +14,9 @@
 use Doctrine\Common\Cache\ArrayCache;
 use Symfony\Component\Validator\Mapping\Cache\DoctrineCache;
 
+/**
+ * @group legacy
+ */
 class DoctrineCacheTest extends AbstractCacheTest
 {
     protected function setUp(): void

Tests/Mapping/Cache/Psr6CacheTest.php

@@ -8,6 +8,8 @@
 
 /**
  * @author Kévin Dunglas <[email protected]>
+ *
+ * @group legacy
  */
 class Psr6CacheTest extends AbstractCacheTest
 {

Tests/Mapping/Factory/LazyLoadingMetadataFactoryTest.php

@@ -12,6 +12,8 @@
 namespace Symfony\Component\Validator\Tests\Mapping\Factory;
 
 use PHPUnit\Framework\TestCase;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
 use Symfony\Component\Validator\Constraints\Callback;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 use Symfony\Component\Validator\Mapping\Factory\LazyLoadingMetadataFactory;
@@ -76,7 +78,36 @@ public function testMergeParentConstraints()
         $this->assertEquals($constraints, $metadata->getConstraints());
     }
 
-    public function testWriteMetadataToCache()
+    public function testCachedMetadata()
+    {
+        $cache = new ArrayAdapter();
+        $factory = new LazyLoadingMetadataFactory(new TestLoader(), $cache);
+
+        $expectedConstraints = [
+            new ConstraintA(['groups' => ['Default', 'EntityParent']]),
+            new ConstraintA(['groups' => ['Default', 'EntityInterfaceA', 'EntityParent']]),
+        ];
+
+        $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
+
+        $this->assertEquals(self::PARENT_CLASS, $metadata->getClassName());
+        $this->assertEquals($expectedConstraints, $metadata->getConstraints());
+
+        $loader = $this->createMock(LoaderInterface::class);
+        $loader->expects($this->never())->method('loadClassMetadata');
+
+        $factory = new LazyLoadingMetadataFactory($loader, $cache);
+
+        $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
+
+        $this->assertEquals(self::PARENT_CLASS, $metadata->getClassName());
+        $this->assertEquals($expectedConstraints, $metadata->getConstraints());
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testWriteMetadataToLegacyCache()
     {
         $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
         $factory = new LazyLoadingMetadataFactory(new TestLoader(), $cache);
@@ -115,7 +146,10 @@ public function testWriteMetadataToCache()
         $this->assertEquals($parentClassConstraints, $metadata->getConstraints());
     }
 
-    public function testReadMetadataFromCache()
+    /**
+     * @group legacy
+     */
+    public function testReadMetadataFromLegacyCache()
     {
         $loader = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Loader\LoaderInterface')->getMock();
         $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
@@ -154,29 +188,19 @@ public function testNonClassNameStringValues()
         $this->expectException('Symfony\Component\Validator\Exception\NoSuchMetadataException');
         $testedValue = '[email protected]';
         $loader = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Loader\LoaderInterface')->getMock();
-        $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
+        $cache = $this->createMock(CacheItemPoolInterface::class);
         $factory = new LazyLoadingMetadataFactory($loader, $cache);
         $cache
             ->expects($this->never())
-            ->method('read');
+            ->method('getItem');
         $factory->getMetadataFor($testedValue);
     }
 
     public function testMetadataCacheWithRuntimeConstraint()
     {
-        $cache = $this->getMockBuilder('Symfony\Component\Validator\Mapping\Cache\CacheInterface')->getMock();
+        $cache = new ArrayAdapter();
         $factory = new LazyLoadingMetadataFactory(new TestLoader(), $cache);
 
-        $cache
-            ->expects($this->any())
-            ->method('write')
-            ->willReturnCallback(function ($metadata) { serialize($metadata); })
-        ;
-
-        $cache->expects($this->any())
-            ->method('read')
-            ->willReturn(false);
-
         $metadata = $factory->getMetadataFor(self::PARENT_CLASS);
         $metadata->addConstraint(new Callback(function () {}));
 

Tests/ValidatorBuilderTest.php

@@ -12,6 +12,7 @@
 namespace Symfony\Component\Validator\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\Validator\Util\LegacyTranslatorProxy;
 use Symfony\Component\Validator\ValidatorBuilder;
 use Symfony\Component\Validator\ValidatorBuilderInterface;
@@ -85,6 +86,15 @@ public function testDisableAnnotationMapping()
         $this->assertSame($this->builder, $this->builder->disableAnnotationMapping());
     }
 
+    public function testSetMappingCache()
+    {
+        $this->assertSame($this->builder, $this->builder->setMappingCache($this->createMock(CacheItemPoolInterface::class)));
+    }
+
+    /**
+     * @group legacy
+     * @expectedDeprecation Symfony\Component\Validator\ValidatorBuilder::setMetadataCache is deprecated since Symfony 4.4. Use setMappingCache() instead.
+     */
     public function testSetMetadataCache()
     {
         $this->assertSame($this->builder, $this->builder->setMetadataCache(

ValidatorBuilder.php

@@ -15,6 +15,7 @@
 use Doctrine\Common\Annotations\CachedReader;
 use Doctrine\Common\Annotations\Reader;
 use Doctrine\Common\Cache\ArrayCache;
+use Psr\Cache\CacheItemPoolInterface;
 use Symfony\Component\Translation\TranslatorInterface as LegacyTranslatorInterface;
 use Symfony\Component\Validator\Context\ExecutionContextFactory;
 use Symfony\Component\Validator\Exception\LogicException;
@@ -63,9 +64,9 @@ class ValidatorBuilder implements ValidatorBuilderInterface
     private $validatorFactory;
 
     /**
-     * @var CacheInterface|null
+     * @var CacheItemPoolInterface|null
      */
-    private $metadataCache;
+    private $mappingCache;
 
     /**
      * @var TranslatorInterface|null
@@ -228,15 +229,37 @@ public function setMetadataFactory(MetadataFactoryInterface $metadataFactory)
     }
 
     /**
-     * {@inheritdoc}
+     * Sets the cache for caching class metadata.
+     *
+     * @return $this
+     *
+     * @deprecated since Symfony 4.4.
      */
     public function setMetadataCache(CacheInterface $cache)
     {
+        @trigger_error(sprintf('%s is deprecated since Symfony 4.4. Use setMappingCache() instead.', __METHOD__), E_USER_DEPRECATED);
+
         if (null !== $this->metadataFactory) {
             throw new ValidatorException('You cannot set a custom metadata cache after setting a custom metadata factory. Configure your metadata factory instead.');
         }
 
-        $this->metadataCache = $cache;
+        $this->mappingCache = $cache;
+
+        return $this;
+    }
+
+    /**
+     * Sets the cache for caching class metadata.
+     *
+     * @return $this
+     */
+    public function setMappingCache(CacheItemPoolInterface $cache)
+    {
+        $this->mappingCache = $cache;
+
+        if (null !== $this->metadataFactory) {
+            throw new ValidatorException('You cannot set a custom mapping cache after setting a custom metadata factory. Configure your metadata factory instead.');
+        }
 
         return $this;
     }
@@ -330,7 +353,7 @@ public function getValidator()
                 $loader = $loaders[0];
             }
 
-            $metadataFactory = new LazyLoadingMetadataFactory($loader, $this->metadataCache);
+            $metadataFactory = new LazyLoadingMetadataFactory($loader, $this->mappingCache);
         }
 
         $validatorFactory = $this->validatorFactory ?: new ConstraintValidatorFactory();