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

namespace Illuminate\Cache;

class RedisTaggedCache extends TaggedCache
{
    /**
     * Forever reference key.
     *
     * @var string
     */
    const REFERENCE_KEY_FOREVER = 'forever_ref';

    /**
     * Standard reference key.
     *
     * @var string
     */
    const REFERENCE_KEY_STANDARD = 'standard_ref';

    /**
     * Store an item in the cache.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @param  \DateTimeInterface|\DateInterval|int|null  $ttl
     * @return bool
     */
    public function put($key, $value, $ttl = null)
    {
        if ($ttl === null) {
            return $this-&gt;forever($key, $value);
        }

        $this-&gt;pushStandardKeys($this-&gt;tags-&gt;getNamespace(), $key);

        return parent::put($key, $value, $ttl);
    }

    /**
     * Increment the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return int|bool
     */
    public function increment($key, $value = 1)
    {
        $this-&gt;pushStandardKeys($this-&gt;tags-&gt;getNamespace(), $key);

        return parent::increment($key, $value);
    }

    /**
     * Decrement the value of an item in the cache.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return int|bool
     */
    public function decrement($key, $value = 1)
    {
        $this-&gt;pushStandardKeys($this-&gt;tags-&gt;getNamespace(), $key);

        return parent::decrement($key, $value);
    }

    /**
     * Store an item in the cache indefinitely.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return bool
     */
    public function forever($key, $value)
    {
        $this-&gt;pushForeverKeys($this-&gt;tags-&gt;getNamespace(), $key);

        return parent::forever($key, $value);
    }

    /**
     * Remove all items from the cache.
     *
     * @return bool
     */
    public function flush()
    {
        $this-&gt;deleteForeverKeys();
        $this-&gt;deleteStandardKeys();

        $this-&gt;tags-&gt;flush();

        return true;
    }

    /**
     * Store standard key references into store.
     *
     * @param  string  $namespace
     * @param  string  $key
     * @return void
     */
    protected function pushStandardKeys($namespace, $key)
    {
        $this-&gt;pushKeys($namespace, $key, self::REFERENCE_KEY_STANDARD);
    }

    /**
     * Store forever key references into store.
     *
     * @param  string  $namespace
     * @param  string  $key
     * @return void
     */
    protected function pushForeverKeys($namespace, $key)
    {
        $this-&gt;pushKeys($namespace, $key, self::REFERENCE_KEY_FOREVER);
    }

    /**
     * Store a reference to the cache key against the reference key.
     *
     * @param  string  $namespace
     * @param  string  $key
     * @param  string  $reference
     * @return void
     */
    protected function pushKeys($namespace, $key, $reference)
    {
        $fullKey = $this-&gt;store-&gt;getPrefix().sha1($namespace).':'.$key;

        foreach (explode('|', $namespace) as $segment) {
            $this-&gt;store-&gt;connection()-&gt;sadd($this-&gt;referenceKey($segment, $reference), $fullKey);
        }
    }

    /**
     * Delete all of the items that were stored forever.
     *
     * @return void
     */
    protected function deleteForeverKeys()
    {
        $this-&gt;deleteKeysByReference(self::REFERENCE_KEY_FOREVER);
    }

    /**
     * Delete all standard items.
     *
     * @return void
     */
    protected function deleteStandardKeys()
    {
        $this-&gt;deleteKeysByReference(self::REFERENCE_KEY_STANDARD);
    }

    /**
     * Find and delete all of the items that were stored against a reference.
     *
     * @param  string  $reference
     * @return void
     */
    protected function deleteKeysByReference($reference)
    {
        foreach (explode('|', $this-&gt;tags-&gt;getNamespace()) as $segment) {
            $this-&gt;deleteValues($segment = $this-&gt;referenceKey($segment, $reference));

            $this-&gt;store-&gt;connection()-&gt;del($segment);
        }
    }

    /**
     * Delete item keys that have been stored against a reference.
     *
     * @param  string  $referenceKey
     * @return void
     */
    protected function deleteValues($referenceKey)
    {
        $cursor = $defaultCursorValue = '0';

        do {
            [$cursor, $valuesChunk] = $this-&gt;store-&gt;connection()-&gt;sscan(
                $referenceKey, $cursor, ['match' =&gt; '*', 'count' =&gt; 1000]
            );

            // PhpRedis client returns false if set does not exist or empty. Array destruction
            // on false stores null in each variable. If valuesChunk is null, it means that
            // there were not results from the previously executed &quot;sscan&quot; Redis command.
            if (is_null($valuesChunk)) {
                break;
            }

            $valuesChunk = array_unique($valuesChunk);

            if (count($valuesChunk) &gt; 0) {
                $this-&gt;store-&gt;connection()-&gt;del(...$valuesChunk);
            }
        } while (((string) $cursor) !== $defaultCursorValue);
    }

    /**
     * Get the reference key for the segment.
     *
     * @param  string  $segment
     * @param  string  $suffix
     * @return string
     */
    protected function referenceKey($segment, $suffix)
    {
        return $this-&gt;store-&gt;getPrefix().$segment.':'.$suffix;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>