Adding the ability to configure the Attributes cache or disable the cache

src/Framework/Bootloader/Attributes/AttributesBootloader.php

@@ -7,7 +7,6 @@
 use Doctrine\Common\Annotations\AnnotationReader as DoctrineAnnotationReader;
 use Doctrine\Common\Annotations\Reader as DoctrineReaderInterface;
 use Psr\Container\ContainerInterface;
-use Psr\SimpleCache\CacheInterface;
 use Spiral\Attributes\AnnotationReader;
 use Spiral\Attributes\AttributeReader;
 use Spiral\Attributes\Composite\SelectiveReader;
@@ -19,6 +18,7 @@
 use Spiral\Attributes\ReaderInterface;
 use Spiral\Boot\Bootloader\Bootloader;
 use Spiral\Boot\EnvironmentInterface;
+use Spiral\Cache\CacheStorageProviderInterface;
 use Spiral\Config\ConfiguratorInterface;
 
 class AttributesBootloader extends Bootloader
@@ -41,6 +41,10 @@ public function init(EnvironmentInterface $env): void
                 'annotations' => [
                     'support' => $env->get('SUPPORT_ANNOTATIONS', true),
                 ],
+                'cache' => [
+                    'storage' => $env->get('ATTRIBUTES_CACHE_STORAGE', null),
+                    'enabled' => $env->get('ATTRIBUTES_CACHE_ENABLED', false),
+                ],
             ],
         );
     }
@@ -62,11 +66,11 @@ private function initReader(
     ): ReaderInterface {
         $reader = new AttributeReader($instantiator);
 
-        if ($container->has(CacheInterface::class)) {
-            $cache = $container->get(CacheInterface::class);
-            \assert($cache instanceof CacheInterface);
+        if ($config->isCacheEnabled()) {
+            $provider = $container->get(CacheStorageProviderInterface::class);
+            \assert($provider instanceof CacheStorageProviderInterface);
 
-            $reader = new Psr16CachedReader($reader, $cache);
+            $reader = new Psr16CachedReader($reader, $provider->storage($config->getCacheStorage()));
         }
 
         $supportAnnotations = $config->isAnnotationsReaderEnabled();

src/Framework/Bootloader/Attributes/AttributesConfig.php

@@ -10,14 +10,37 @@ final class AttributesConfig extends InjectableConfig
 {
     public const CONFIG = 'attributes';
 
+    /**
+     * @var array{
+     *     annotations: array{support:bool},
+     *     cache: array{storage: null|non-empty-string, enabled: bool},
+     * }
+     */
     protected array $config = [
         'annotations' => [
             'support' => true,
         ],
+        'cache' => [
+            'storage' => null,
+            'enabled' => false,
+        ],
     ];
 
     public function isAnnotationsReaderEnabled(): bool
     {
         return (bool)$this->config['annotations']['support'];
     }
+
+    public function isCacheEnabled(): bool
+    {
+        return (bool)($this->config['cache']['enabled'] ?? false);
+    }
+
+    /**
+     * @return non-empty-string|null
+     */
+    public function getCacheStorage(): ?string
+    {
+        return $this->config['cache']['storage'] ?? null;
+    }
 }

tests/Framework/Bootloader/Attributes/AttributesBootloaderTest.php

@@ -8,6 +8,7 @@
 use Spiral\Attributes\Internal\Instantiator\Facade;
 use Spiral\Attributes\Internal\Instantiator\InstantiatorInterface;
 use Spiral\Attributes\ReaderInterface;
+use Spiral\Bootloader\Attributes\AttributesConfig;
 use Spiral\Bootloader\Attributes\Factory;
 use Spiral\Tests\Framework\BaseTestCase;
 
@@ -22,4 +23,14 @@ public function testInstantiatorBinding(): void
     {
         $this->assertContainerBoundAsSingleton(InstantiatorInterface::class, Facade::class);
     }
+
+    public function testIsCacheEnabledShouldBeFalse(): void
+    {
+        $this->assertFalse($this->getConfig(AttributesConfig::CONFIG)['cache']['enabled']);
+    }
+
+    public function testGetStorageShouldBeNull(): void
+    {
+        $this->assertNull($this->getConfig(AttributesConfig::CONFIG)['cache']['storage']);
+    }
 }

tests/Framework/Bootloader/Attributes/AttributesConfigTest.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Framework\Bootloader\Attributes;
+
+use PHPUnit\Framework\TestCase;
+use Spiral\Bootloader\Attributes\AttributesConfig;
+
+final class AttributesConfigTest extends TestCase
+{
+    public function testIsAnnotationsReaderEnabled(): void
+    {
+        $this->assertTrue((new AttributesConfig())->isAnnotationsReaderEnabled());
+        $this->assertFalse(
+            (new AttributesConfig(['annotations' => ['support' => false]]))->isAnnotationsReaderEnabled()
+        );
+    }
+
+    public function testIsCacheEnabled(): void
+    {
+        $this->assertFalse((new AttributesConfig())->isCacheEnabled());
+        $this->assertTrue((new AttributesConfig(['cache' => ['enabled' => true]]))->isCacheEnabled());
+    }
+
+    public function testGetCacheStorage(): void
+    {
+        $this->assertNull((new AttributesConfig())->getCacheStorage());
+        $this->assertSame(
+            'test',
+            (new AttributesConfig(['cache' => ['storage' => 'test']]))->getCacheStorage()
+        );
+    }
+}

tests/Framework/Bootloader/Attributes/AttributesWithoutAnnotationsBootloaderTest.php

@@ -13,31 +13,22 @@
 
 final class AttributesWithoutAnnotationsBootloaderTest extends BaseTestCase
 {
-    public const MAKE_APP_ON_STARTUP = false;
-
     #[Env('SUPPORT_ANNOTATIONS', 'false')]
     public function testReaderBindingWithoutCache(): void
     {
-        $this
-            ->withDisabledBootloaders(\Spiral\Cache\Bootloader\CacheBootloader::class)
-            ->initApp($this->getTestEnvVariables());
-
         $this->assertContainerBoundAsSingleton(ReaderInterface::class, AttributeReader::class);
     }
 
     #[Env('SUPPORT_ANNOTATIONS', 'false')]
-    public function testReaderBindingWithtCache(): void
+    #[Env('ATTRIBUTES_CACHE_ENABLED', 'true')]
+    public function testReaderBindingWithCache(): void
     {
-        $this->initApp($this->getTestEnvVariables());
-
         $this->assertContainerBoundAsSingleton(ReaderInterface::class, Psr16CachedReader::class);
     }
 
     #[Env('SUPPORT_ANNOTATIONS', 'true')]
     public function testSelectiveReaderBinding(): void
     {
-        $this->initApp($this->getTestEnvVariables());
-
         $this->assertContainerBoundAsSingleton(ReaderInterface::class, SelectiveReader::class);
     }
 }