Create Serializable Redis Adapter and ApcuAdapter disabled in CLI

phpcs.xml

@@ -38,6 +38,7 @@
         <exclude name="SlevomatCodingStandard.TypeHints.PropertyTypeHint.MissingNativeTypeHint"/>
         <exclude name="SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed"/>
         <exclude name="SlevomatCodingStandard.Classes.SuperfluousTraitNaming.SuperfluousSuffix"/>
+        <exclude name="SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint"/>
     </rule>
     <!-- Additional Rules -->
     <rule ref="SlevomatCodingStandard.Namespaces.UnusedUses">

psalm.xml

@@ -5,12 +5,18 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
-    phpVersion="7.4"
+    phpVersion="8.2"
+    findUnusedBaselineEntry="false"
+    findUnusedCode="false"
 >
     <projectFiles>
         <directory name="src" />
         <ignoreFiles>
             <directory name="vendor" />
         </ignoreFiles>
     </projectFiles>
+    <issueHandlers>
+        <MethodSignatureMismatch errorLevel="suppress" />
+        <UnimplementedAbstractMethod errorLevel="suppress" />
+    </issueHandlers>
 </psalm>

src/LocalCacheProvider.php

@@ -11,6 +11,8 @@
 
 use function sys_get_temp_dir;
 
+use const PHP_SAPI;
+
 /**
  * Provide APCu cache adapter if available, otherwise file cache adapter
  *
@@ -34,8 +36,10 @@ public function __construct(string $cacheDir = '', string $namespace = '')
 
     public function get(): AbstractAdapter
     {
-        return ApcuAdapter::isSupported() ?
+        return PHP_SAPI !== 'cli' && ApcuAdapter::isSupported() ?
+            // @codeCoverageIgnoreStart
             new ApcuAdapter($this->namespace) :
+            // @codeCoverageIgnoreEnd
             new FilesystemAdapter($this->namespace, 0, $this->cacheDir);
     }
 }

src/Php73BcSerializableTrait.php

@@ -11,6 +11,8 @@ trait Php73BcSerializableTrait
 {
     /**
      * {@inheritDoc}
+     *
+     * @psalm-suppress MethodSignatureMustProvideReturnType
      */
     final public function serialize()
     {

src/Psr6RedisModule.php

@@ -6,14 +6,16 @@
 
 use Psr\Cache\CacheItemPoolInterface;
 use Ray\Di\AbstractModule;
+use Ray\Di\ProviderInterface;
 use Ray\Di\Scope;
 use Ray\PsrCacheModule\Annotation\CacheNamespace;
 use Ray\PsrCacheModule\Annotation\Local;
 use Ray\PsrCacheModule\Annotation\RedisConfig;
-use Ray\PsrCacheModule\Annotation\RedisInstance;
 use Ray\PsrCacheModule\Annotation\Shared;
-use Symfony\Component\Cache\Adapter\RedisAdapter;
+use Redis;
+use RuntimeException;
 
+use function class_exists;
 use function explode;
 
 final class Psr6RedisModule extends AbstractModule
@@ -30,12 +32,19 @@ public function __construct(string $server, ?AbstractModule $module = null)
 
     protected function configure(): void
     {
+        if (! class_exists(Redis::class)) {
+            // @codeCoverageIgnoreStart
+            throw new RuntimeException('Redis not installed.');
+            // @codeCoverageIgnoreEnd
+        }
+
+        $this->bind(Redis::class);
         $this->bind(CacheItemPoolInterface::class)->annotatedWith(Local::class)->toConstructor(ApcuAdapter::class, ['namespace' => CacheNamespace::class])->in(Scope::SINGLETON);
         $this->bind(CacheItemPoolInterface::class)->annotatedWith(Shared::class)->toConstructor(RedisAdapter::class, [
-            'redis' => RedisInstance::class,
+            'redisProvider' => 'redis',
             'namespace' => CacheNamespace::class,
         ]);
         $this->bind()->annotatedWith(RedisConfig::class)->toInstance($this->server);
-        $this->bind('')->annotatedWith(RedisInstance::class)->toProvider(RedisProvider::class);
+        $this->bind(ProviderInterface::class)->annotatedWith('redis')->to(RedisProvider::class);
     }
 }

src/RedisAdapter.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\PsrCacheModule;
+
+use Ray\Di\Di\Named;
+use Ray\Di\ProviderInterface;
+use Ray\PsrCacheModule\Annotation\CacheNamespace;
+use Redis;
+use Serializable;
+use Symfony\Component\Cache\Adapter\RedisAdapter as OriginAdapter;
+use Symfony\Component\Cache\Marshaller\MarshallerInterface;
+
+use function func_get_args;
+
+/** @psalm-suppress PropertyNotSetInConstructor */
+class RedisAdapter extends OriginAdapter implements Serializable
+{
+    use SerializableTrait;
+
+    /**
+     * @param ProviderInterface<Redis> $redisProvider
+     *
+     * @CacheNamespace("namespace")
+     * @Named("redisProvider=redis")
+     */
+    #[CacheNamespace('namespace')]
+    #[Named('redisProvider=redis')]
+    public function __construct(ProviderInterface $redisProvider, string $namespace = '', int $defaultLifetime = 0, ?MarshallerInterface $marshaller = null)
+    {
+        $this->args = func_get_args();
+
+        parent::__construct($redisProvider->get(), $namespace, $defaultLifetime, $marshaller);
+    }
+}

tests/RedisAdapterTest.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\PsrCacheModule;
+
+use PHPUnit\Framework\TestCase;
+use Ray\Di\AbstractModule;
+use Ray\Di\Injector;
+use Redis;
+use Symfony\Component\Cache\Adapter\AbstractAdapter;
+use Symfony\Contracts\Cache\ItemInterface;
+
+use function serialize;
+use function unserialize;
+
+class RedisAdapterTest extends TestCase
+{
+    /** @return array{0:string, 1: RedisAdapter} */
+    public function testSerialize(): array
+    {
+        $provider = new RedisProvider(['127.0.0.1', '6379']);
+        $adapter = new RedisAdapter($provider);
+        $adapter->get('foo', static function (ItemInterface $item) {
+            return 'foobar';
+        });
+        $foo = $adapter->get('foo', static function (ItemInterface $item) {
+            return '_no_serve_';
+        });
+        $this->assertSame('foobar', $foo);
+        $string = serialize($adapter);
+        $this->assertIsString($string);
+
+        return [$string, $adapter];
+    }
+
+    /**
+     * @param array{0:string, 1: RedisAdapter} $adapters
+     *
+     * @depends testSerialize
+     */
+    public function testUnserialize(array $adapters): void
+    {
+        $this->assertInstanceOf(RedisAdapter::class, $adapters[1]);
+        $this->assertSame('foobar', $adapters[1]->get('foo', static function (ItemInterface $item) {
+            return '_no_serve_in_object';
+        }));
+
+        $adapter0 = unserialize($adapters[0]);
+        $this->assertInstanceOf(RedisAdapter::class, $adapter0);
+        $this->assertSame('foobar', $adapter0->get('foo', static function (ItemInterface $item) {
+            return '_no_serve_in_serialize';
+        }));
+    }
+
+    public function testCacheNamespaceModule(): void
+    {
+        $injector = new Injector(new class extends AbstractModule{
+            protected function configure(): void
+            {
+                $this->install(new CacheNamespaceModule('a'));
+                $this->install(new CacheDirModule('/tmp/a'));
+                $this->bind(AbstractAdapter::class)->to(RedisAdapter::class);
+                $this->bind(Redis::class);
+                $this->install(new Psr6RedisModule('127.0.0.1:6379:1'));
+            }
+        });
+        $adapter = $injector->getInstance(AbstractAdapter::class);
+        $this->assertInstanceOf(RedisAdapter::class, $adapter);
+    }
+}