Yiisoft\Cache\Cache

Complexity

Total Complexity

42

Size/Duplication

Total Lines	298
Duplicated Lines	0 %

Test Coverage

Coverage

84.44%

Importance

Changes	4
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	deleteMultiple()	0	7	2
A	addMultiple()	0	10	3
B	getMultiple()	0	24	8
A	buildKey()	0	6	4
A	get()	0	17	6
A	has()	0	4	1
A	getOrSet()	0	12	3
A	delete()	0	5	1
A	prepareDataForSetOrAddMultiple()	0	17	4
A	add()	0	14	3
A	clear()	0	3	1
A	setMultiple()	0	4	1
A	setHandler()	0	7	2
A	set()	0	8	2

<?php
namespace Yiisoft\Cache;

use Psr\SimpleCache\InvalidArgumentException;
use Yiisoft\Cache\Dependencies\Dependency;
use Yiisoft\Cache\Exceptions\SetCacheException;

/**
 * Cache provides support for the data caching, including cache key composition and dependencies.
 * The actual data caching is performed via {@see handler}, which should be configured to be {@see \Psr\SimpleCache\CacheInterface}
 * instance.
 *
 * Application configuration example:
 *
 * ```php
 * return [
 *     'components' => [
 *         'cache' => [
 *             '__class' => Yiisoft\Cache\Cache::class,
 *             'handler' => [
 *                 '__class' => Yiisoft\Cache\FileCache::class,
 *                 'cachePath' => '@runtime/cache',
 *             ],
 *         ],
 *         // ...
 *     ],
 *     // ...
 * ];
 * ```
 *
 * A value can be stored in the cache by calling {@see set()} and be retrieved back
 * later (in the same or different request) by {@see get()}. In both operations,
 * a key identifying the value is required. An expiration time and/or a {@see Dependency|dependency}
 * can also be specified when calling {@see set()}. If the value expires or the dependency
 * changes at the time of calling {@see get()}, the cache will return no data.
 *
 * A typical usage pattern of cache is like the following:
 *
 * ```php
 * $key = 'demo';
 * $data = $cache->get($key);
 * if ($data === null) {
 *     // ...generate $data here...
 *     $cache->set($key, $data, $duration, $dependency);
 * }
 * ```
 *
 * Because Cache implements the {@see \ArrayAccess} interface, it can be used like an array. For example,
 *
 * ```php
 * $cache['foo'] = 'some data';
 * echo $cache['foo'];
 * ```
 *
 * For more details and usage information on Cache, see the [guide article on caching](guide:caching-overview)
 * and [PSR-16 specification](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-16-simple-cache.md).
 */
final class Cache implements CacheInterface
{
    /**
     * @var \Psr\SimpleCache\CacheInterface actual cache handler.
     */
    private $handler;

    /**
     * @param \Psr\SimpleCache\CacheInterface cache handler.
     */
    public function __construct(\Psr\SimpleCache\CacheInterface $handler = null)
    {
        $this->setHandler($handler);
    }

    /**
     * @param \Psr\SimpleCache\CacheInterface|array cache handler.
     */
    public function setHandler(\Psr\SimpleCache\CacheInterface $handler = null): self
    {
        if ($handler) {
            $this->handler = $handler;
        }

        return $this;
    }

    /**
     * Builds a normalized cache key from a given key.
     *
     * If the given key is a string containing alphanumeric characters only and no more than 32 characters,
     * then the key will be returned back as it is. Otherwise, a normalized key is generated by serializing
     * the given key and applying MD5 hashing.
     *
     * @param mixed $key the key to be normalized
     * @return string the generated cache key
     */
    private function buildKey($key): string
    {
        if (\is_string($key)) {
            return ctype_alnum($key) && mb_strlen($key, '8bit') <= 32 ? $key : md5($key);
        }
        return md5(json_encode($key));
    }


    public function get($key, $default = null)
    {
        $key = $this->buildKey($key);
        $value = $this->handler->get($key);

        if ($value === null) {
            return $default;
        }

        if (\is_array($value) && isset($value[1]) && $value[1] instanceof Dependency) {
            if ($value[1]->isChanged($this)) {
                return $default;
            }
            return $value[0];
        }

        return $value;
    }


    public function has($key): bool
    {
        $key = $this->buildKey($key);
        return $this->handler->has($key);
    }

    /**
     * Retrieves multiple values from cache with the specified keys.
     * Some caches (such as memcache, apc) allow retrieving multiple cached values at the same time,
     * which may improve the performance. In case a cache does not support this feature natively,
     * this method will try to simulate it.
     * @param string[] $keys list of string keys identifying the cached values
     * @param mixed $default Default value to return for keys that do not exist.
     * @return iterable list of cached values corresponding to the specified keys. The array
     * is returned in terms of (key, value) pairs.
     * If a value is not cached or expired, the corresponding array value will be false.
     * @throws InvalidArgumentException
     */
    public function getMultiple($keys, $default = null): iterable
    {
        $keyMap = [];
        foreach ($keys as $key) {
            $keyMap[$key] = $this->buildKey($key);
        }
        $values = $this->handler->getMultiple(array_values($keyMap));
        $results = [];
        foreach ($keyMap as $key => $newKey) {
            $results[$key] = $default;
            if (isset($values[$newKey])) {
                $value = $values[$newKey];
                if (\is_array($value) && isset($value[1]) && $value[1] instanceof Dependency) {
                    if ($value[1]->isChanged($this)) {
                        continue;
                    }

                    $value = $value[0];
                }
                $results[$key] = $value;
            }
        }

        return $results;
    }

    /**
     * Stores a value identified by a key into cache.
     * If the cache already contains such a key, the existing value and
     * expiration time will be replaced with the new ones, respectively.
     *
     * @param mixed $key a key identifying the value to be cached. This can be a simple string or
     * a complex data structure consisting of factors representing the key.
     * @param mixed $value the value to be cached
     * @param null|int|\DateInterval $ttl the TTL of this value. If not set, default value is used.
     * @param Dependency $dependency dependency of the cached value. If the dependency changes,
     * the corresponding value in the cache will be invalidated when it is fetched via {@see get()}.
     * This parameter is ignored if {@see serializer} is false.
     * @return bool whether the value is successfully stored into cache
     * @throws InvalidArgumentException
     */
    public function set($key, $value, $ttl = null, Dependency $dependency = null): bool
    {
        if ($dependency !== null) {
            $dependency->evaluateDependency($this);
            $value = [$value, $dependency];
        }
        $key = $this->buildKey($key);
        return $this->handler->set($key, $value, $ttl);
    }

    /**
     * Stores multiple values in cache. Each value contains a value identified by a key.
     * If the cache already contains such a key, the existing value and
     * expiration time will be replaced with the new ones, respectively.
     *
     * @param array $values the values to be cached, as key-value pairs.
     * @param null|int|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
     * @param Dependency $dependency dependency of the cached values. If the dependency changes,
     * the corresponding values in the cache will be invalidated when it is fetched via {@see get()}.
     * This parameter is ignored if {@see serializer} is false.
     * @return bool True on success and false on failure.
     * @throws InvalidArgumentException
     */
    public function setMultiple($values, $ttl = null, Dependency $dependency = null): bool
    {
        $data = $this->prepareDataForSetOrAddMultiple($values, $dependency);
        return $this->handler->setMultiple($data, $ttl);
    }

    public function deleteMultiple($keys): bool
    {
        $actualKeys = [];
        foreach ($keys as $key) {
            $actualKeys[] = $this->buildKey($key);
        }
        return $this->handler->deleteMultiple($actualKeys);
    }

    /**
     * Stores multiple values in cache. Each value contains a value identified by a key.
     * If the cache already contains such a key, the existing value and expiration time will be preserved.
     *
     * @param array $values the values to be cached, as key-value pairs.
     * @param null|int|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
     * @param Dependency $dependency dependency of the cached values. If the dependency changes,
     * the corresponding values in the cache will be invalidated when it is fetched via {@see get()}.
     * This parameter is ignored if {@see serializer} is false.
     * @return bool
     * @throws InvalidArgumentException
     */
    public function addMultiple(array $values, $ttl = null, Dependency $dependency = null): bool
    {
        $data = $this->prepareDataForSetOrAddMultiple($values, $dependency);
        $existingValues = $this->handler->getMultiple(array_keys($data));
        foreach ($existingValues as $key => $value) {
            if ($value !== null) {
                unset($data[$key]);
            }
        }
        return $this->handler->setMultiple($data, $ttl);
    }

    private function prepareDataForSetOrAddMultiple(array $values, ?Dependency $dependency): array
    {
        if ($dependency !== null) {
            $dependency->evaluateDependency($this);
        }

        $data = [];
        foreach ($values as $key => $value) {
            if ($dependency !== null) {
                $value = [$value, $dependency];
            }

            $key = $this->buildKey($key);
            $data[$key] = $value;
        }

        return $data;
    }

    /**
     * Stores a value identified by a key into cache if the cache does not contain this key.
     * Nothing will be done if the cache already contains the key.
     * @param mixed $key a key identifying the value to be cached. This can be a simple string or
     * a complex data structure consisting of factors representing the key.
     * @param mixed $value the value to be cached
     * @param null|int|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
     * @param Dependency $dependency dependency of the cached value. If the dependency changes,
     * the corresponding value in the cache will be invalidated when it is fetched via {@see get()}.
     * This parameter is ignored if {@see serializer} is false.
     * @return bool whether the value is successfully stored into cache
     * @throws InvalidArgumentException
     */
    public function add($key, $value, $ttl = null, Dependency $dependency = null): bool
    {
        if ($dependency !== null) {
            $dependency->evaluateDependency($this);
            $value = [$value, $dependency];
        }

        $key = $this->buildKey($key);

        if ($this->handler->has($key)) {
            return false;
        }

        return $this->handler->set($key, $value, $ttl);
    }

    /**
     * Deletes a value with the specified key from cache.
     * @param mixed $key a key identifying the value to be deleted from cache. This can be a simple string or
     * a complex data structure consisting of factors representing the key.
     * @return bool if no error happens during deletion
     * @throws InvalidArgumentException
     */
    public function delete($key): bool
    {
        $key = $this->buildKey($key);

        return $this->handler->delete($key);
    }

    /**
     * Deletes all values from cache.
     * Be careful of performing this operation if the cache is shared among multiple applications.
     * @return bool whether the flush operation was successful.
     */
    public function clear(): bool
    {
        return $this->handler->clear();
    }

    /**
     * Method combines both {@see set()} and {@see get()} methods to retrieve value identified by a $key,
     * or to store the result of $callable execution if there is no cache available for the $key.
     *
     * Usage example:
     *
     * ```php
     * public function getTopProducts($count = 10) {
     *     $cache = $this->cache;
     *     return $cache->getOrSet(['top-n-products', 'n' => $count], function ($cache) use ($count) {
     *         return Products::find()->mostPopular()->limit(10)->all();
     *     }, 1000);
     * }
     * ```
     *
     * @param mixed $key a key identifying the value to be cached. This can be a simple string or
     * a complex data structure consisting of factors representing the key.
     * @param callable|\Closure $callable the callable or closure that will be used to generate a value to be cached.
     * In case $callable returns `false`, the value will not be cached.
     * @param null|int|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
     * @param Dependency $dependency dependency of the cached value. If the dependency changes,
     * the corresponding value in the cache will be invalidated when it is fetched via {@see get()}.
     * This parameter is ignored if {@see serializer} is `false`.
     * @return mixed result of $callable execution
     * @throws SetCacheException
     * @throws InvalidArgumentException
     */
    public function getOrSet($key, callable $callable, $ttl = null, Dependency $dependency = null)
    {
        if (($value = $this->get($key)) !== null) {
            return $value;
        }

        $value = $callable($this);
        if (!$this->set($key, $value, $ttl, $dependency)) {
            throw new SetCacheException($key, $value, $this);
        }

        return $value;
    }
}