<form method="POST">
    <h3>Editing: RedisCaster.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\VarDumper\Caster;

use Symfony\Component\VarDumper\Cloner\Stub;

/**
 * Casts Redis class from ext-redis to array representation.
 *
 * @author Nicolas Grekas &lt;p@tchwork.com&gt;
 *
 * @final
 */
class RedisCaster
{
    private const SERIALIZERS = [
        \Redis::SERIALIZER_NONE =&gt; 'NONE',
        \Redis::SERIALIZER_PHP =&gt; 'PHP',
        2 =&gt; 'IGBINARY', // Optional Redis::SERIALIZER_IGBINARY
    ];

    private const MODES = [
        \Redis::ATOMIC =&gt; 'ATOMIC',
        \Redis::MULTI =&gt; 'MULTI',
        \Redis::PIPELINE =&gt; 'PIPELINE',
    ];

    private const COMPRESSION_MODES = [
        0 =&gt; 'NONE', // Redis::COMPRESSION_NONE
        1 =&gt; 'LZF',  // Redis::COMPRESSION_LZF
    ];

    private const FAILOVER_OPTIONS = [
        \RedisCluster::FAILOVER_NONE =&gt; 'NONE',
        \RedisCluster::FAILOVER_ERROR =&gt; 'ERROR',
        \RedisCluster::FAILOVER_DISTRIBUTE =&gt; 'DISTRIBUTE',
        \RedisCluster::FAILOVER_DISTRIBUTE_SLAVES =&gt; 'DISTRIBUTE_SLAVES',
    ];

    public static function castRedis(\Redis $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        if (!$connected = $c-&gt;isConnected()) {
            return $a + [
                $prefix.'isConnected' =&gt; $connected,
            ];
        }

        $mode = $c-&gt;getMode();

        return $a + [
            $prefix.'isConnected' =&gt; $connected,
            $prefix.'host' =&gt; $c-&gt;getHost(),
            $prefix.'port' =&gt; $c-&gt;getPort(),
            $prefix.'auth' =&gt; $c-&gt;getAuth(),
            $prefix.'mode' =&gt; isset(self::MODES[$mode]) ? new ConstStub(self::MODES[$mode], $mode) : $mode,
            $prefix.'dbNum' =&gt; $c-&gt;getDbNum(),
            $prefix.'timeout' =&gt; $c-&gt;getTimeout(),
            $prefix.'lastError' =&gt; $c-&gt;getLastError(),
            $prefix.'persistentId' =&gt; $c-&gt;getPersistentID(),
            $prefix.'options' =&gt; self::getRedisOptions($c),
        ];
    }

    public static function castRedisArray(\RedisArray $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

        return $a + [
            $prefix.'hosts' =&gt; $c-&gt;_hosts(),
            $prefix.'function' =&gt; ClassStub::wrapCallable($c-&gt;_function()),
            $prefix.'lastError' =&gt; $c-&gt;getLastError(),
            $prefix.'options' =&gt; self::getRedisOptions($c),
        ];
    }

    public static function castRedisCluster(\RedisCluster $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;
        $failover = $c-&gt;getOption(\RedisCluster::OPT_SLAVE_FAILOVER);

        $a += [
            $prefix.'_masters' =&gt; $c-&gt;_masters(),
            $prefix.'_redir' =&gt; $c-&gt;_redir(),
            $prefix.'mode' =&gt; new ConstStub($c-&gt;getMode() ? 'MULTI' : 'ATOMIC', $c-&gt;getMode()),
            $prefix.'lastError' =&gt; $c-&gt;getLastError(),
            $prefix.'options' =&gt; self::getRedisOptions($c, [
                'SLAVE_FAILOVER' =&gt; isset(self::FAILOVER_OPTIONS[$failover]) ? new ConstStub(self::FAILOVER_OPTIONS[$failover], $failover) : $failover,
            ]),
        ];

        return $a;
    }

    /**
     * @param \Redis|\RedisArray|\RedisCluster $redis
     */
    private static function getRedisOptions($redis, array $options = []): EnumStub
    {
        $serializer = $redis-&gt;getOption(\Redis::OPT_SERIALIZER);
        if (\is_array($serializer)) {
            foreach ($serializer as &amp;$v) {
                if (isset(self::SERIALIZERS[$v])) {
                    $v = new ConstStub(self::SERIALIZERS[$v], $v);
                }
            }
        } elseif (isset(self::SERIALIZERS[$serializer])) {
            $serializer = new ConstStub(self::SERIALIZERS[$serializer], $serializer);
        }

        $compression = \defined('Redis::OPT_COMPRESSION') ? $redis-&gt;getOption(\Redis::OPT_COMPRESSION) : 0;
        if (\is_array($compression)) {
            foreach ($compression as &amp;$v) {
                if (isset(self::COMPRESSION_MODES[$v])) {
                    $v = new ConstStub(self::COMPRESSION_MODES[$v], $v);
                }
            }
        } elseif (isset(self::COMPRESSION_MODES[$compression])) {
            $compression = new ConstStub(self::COMPRESSION_MODES[$compression], $compression);
        }

        $retry = \defined('Redis::OPT_SCAN') ? $redis-&gt;getOption(\Redis::OPT_SCAN) : 0;
        if (\is_array($retry)) {
            foreach ($retry as &amp;$v) {
                $v = new ConstStub($v ? 'RETRY' : 'NORETRY', $v);
            }
        } else {
            $retry = new ConstStub($retry ? 'RETRY' : 'NORETRY', $retry);
        }

        $options += [
            'TCP_KEEPALIVE' =&gt; \defined('Redis::OPT_TCP_KEEPALIVE') ? $redis-&gt;getOption(\Redis::OPT_TCP_KEEPALIVE) : 0,
            'READ_TIMEOUT' =&gt; $redis-&gt;getOption(\Redis::OPT_READ_TIMEOUT),
            'COMPRESSION' =&gt; $compression,
            'SERIALIZER' =&gt; $serializer,
            'PREFIX' =&gt; $redis-&gt;getOption(\Redis::OPT_PREFIX),
            'SCAN' =&gt; $retry,
        ];

        return new EnumStub($options);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>