Cache::normalizeTtl() - Code Metrics - Inspection of "Reorganization" - yiisoft/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#30)

by Alexander

created 2019-08-08 14:07 UTC

Cache::normalizeTtl() A

↳ Parent: Cache

Complexity

Conditions	4
Paths	4

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
cc	4
eloc	8
nc	4
nop	1
dl	0
loc	15
ccs	0
cts	0
cp	0
crap	20
rs	10
c	0
b	0
f	0

<?php

namespace Yiisoft\Cache;

use DateInterval;
use DateTime;
use Exception;
use Psr\SimpleCache\InvalidArgumentException;
use Yiisoft\Cache\Dependency\Dependency;
use Yiisoft\Cache\Exception\SetCacheException;

/**
 * Cache provides support for the data caching, including cache key composition and dependencies.
 * The actual data caching is performed via {@see Cache::$handler}, which should be configured
 * to be {@see \Psr\SimpleCache\CacheInterface} instance.
 *
 * A value can be stored in the cache by calling {@see CacheInterface::set()} and be retrieved back
 * later (in the same or different request) by {@see CacheInterface::get()}. In both operations,
 * a key identifying the value is required. An expiration time and/or a {@see Dependency}
 * can also be specified when calling {@see CacheInterface::set()}. If the value expires or the dependency
 * changes at the time of calling {@see CacheInterface::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, $ttl, $dependency);
 * }
 * ```
 *
 * For more details and usage information on Cache, see
 * [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;

    /**
     * @var string a string prefixed to every cache key so that it is unique globally in the whole cache storage.
     * It is recommended that you set a unique cache key prefix for each application if the same cache
     * storage is being used by different applications.
     */
    private $keyPrefix = '';

    private $keyNormalization = true;

    /**
     * @var int|null default TTL for a cache entry. null meaning infinity, negative or zero results in cache key deletion.
     * This value is used by {@see set()} and {@see setMultiple()}, if the duration is not explicitly given.
     */
    private $defaultTtl;

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

    /**
     * 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 normalizeKey($key): string
    {
        if (!$this->keyNormalization) {
            $normalizedKey = $key;
        } elseif (\is_string($key)) {
            $normalizedKey = ctype_alnum($key) && mb_strlen($key, '8bit') <= 32 ? $key : md5($key);
        } else {
            $normalizedKey = $this->keyPrefix . md5(json_encode($key));
        }

        return $this->keyPrefix . $normalizedKey;
    }


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

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

        return $value;
    }


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

    /**
     * Retrieves multiple values from cache with the specified keys.
     * Some caches, such as memcached or apcu, 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->normalizeKey($key);
        }
        $values = $this->handler->getMultiple(array_values($keyMap), $default);
        $results = [];
        foreach ($keyMap as $key => $newKey) {
            $results[$key] = $default;
            if (array_key_exists($newKey, (array)$values)) {
                $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 CacheInterface::get()}.
     * @return bool whether the value is successfully stored into cache
     * @throws InvalidArgumentException
     */
    public function set($key, $value, $ttl = null, Dependency $dependency = null): bool
    {
        $ttl = $this->normalizeTtl($ttl);

        if ($dependency !== null) {
            $dependency->evaluateDependency($this);
            $value = [$value, $dependency];
        }
        $key = $this->normalizeKey($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 CacheInterface::get()}.
     * @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);
        $ttl = $this->normalizeTtl($ttl);
        return $this->handler->setMultiple($data, $ttl);
    }

    public function deleteMultiple($keys): bool
    {
        $actualKeys = [];
        foreach ($keys as $key) {
            $actualKeys[] = $this->normalizeKey($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 CacheInterface::get()}.
     * @return bool
     * @throws InvalidArgumentException
     */
    public function addMultiple(array $values, $ttl = null, Dependency $dependency = null): bool
    {
        $data = $this->prepareDataForSetOrAddMultiple($values, $dependency);
        $ttl = $this->normalizeTtl($ttl);
        $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(iterable $values, ?Dependency $dependency): array
    {
        if ($dependency !== null) {
            $dependency->evaluateDependency($this);
        }

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

            $key = $this->normalizeKey($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 CacheInterface::get()}.
     * @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->normalizeKey($key);

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

        $ttl = $this->normalizeTtl($ttl);

        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->normalizeKey($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 CacheInterface::set()} and {@see CacheInterface::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 $this->getTopNProductsFromDatabase($count);
     *     }, 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 CacheInterface::get()}.
     * @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);
        $ttl = $this->normalizeTtl($ttl);
        if (!$this->set($key, $value, $ttl, $dependency)) {
            throw new SetCacheException($key, $value, $this);
        }

        return $value;
    }

    public function __call($name, $arguments)
    {
        return call_user_func_array([$this->handler, $name], $arguments);
    }

    public function enableKeyNormalization(): void
    {
        $this->keyNormalization = true;
    }

    public function disableKeyNormalization(): void
    {
        $this->keyNormalization = false;
    }

    /**
     * @param string $keyPrefix a string prefixed to every cache key so that it is unique globally in the whole cache storage.
     * It is recommended that you set a unique cache key prefix for each application if the same cache
     * storage is being used by different applications.
     */
    public function setKeyPrefix(string $keyPrefix): void
    {
        if ($keyPrefix != '' && !ctype_alnum($keyPrefix)) {
            throw new Exception\InvalidArgumentException('Cache key prefix should be alphanumeric');
filter:
    dependency_paths: ["lib/*"]
        }
        $this->keyPrefix = $keyPrefix;
    }

    /**
     * @return int|null
     */
    public function getDefaultTtl(): ?int
    {
        return $this->defaultTtl;
    }

    /**
     * @param int|DateInterval|null $defaultTtl
     */
    public function setDefaultTtl($defaultTtl): void
    {
        $this->defaultTtl = $this->normalizeTtl($defaultTtl);
    }

    /**
     * Normalizes cache TTL handling `null` value and {@see DateInterval} objects.
     * @param int|DateInterval|null $ttl raw TTL.
     * @return int|null TTL value as UNIX timestamp or null meaning infinity
     */
    protected function normalizeTtl($ttl): ?int
    {
        if ($ttl === null) {
            return $this->defaultTtl;
        }

        if ($ttl instanceof DateInterval) {
            try {
                return (new DateTime('@0'))->add($ttl)->getTimestamp();
            } catch (Exception $e) {
                return $this->defaultTtl;
            }
        }

        return $ttl;
    }
}


1		<?php
2
3		namespace Yiisoft\Cache;
4
5		use DateInterval;
6		use DateTime;
7		use Exception;
8		use Psr\SimpleCache\InvalidArgumentException;
9		use Yiisoft\Cache\Dependency\Dependency;
10		use Yiisoft\Cache\Exception\SetCacheException;
11
12		/**
13		* Cache provides support for the data caching, including cache key composition and dependencies.
14		* The actual data caching is performed via {@see Cache::$handler}, which should be configured
15		* to be {@see \Psr\SimpleCache\CacheInterface} instance.
16		*
17		* A value can be stored in the cache by calling {@see CacheInterface::set()} and be retrieved back
18		* later (in the same or different request) by {@see CacheInterface::get()}. In both operations,
19		* a key identifying the value is required. An expiration time and/or a {@see Dependency}
20		* can also be specified when calling {@see CacheInterface::set()}. If the value expires or the dependency
21		* changes at the time of calling {@see CacheInterface::get()}, the cache will return no data.
22		*
23		* A typical usage pattern of cache is like the following:
24		*
25		* ```php
26		* $key = 'demo';
27		* $data = $cache->get($key);
28		* if ($data === null) {
29		* // ...generate $data here...
30		* $cache->set($key, $data, $ttl, $dependency);
31		* }
32		* ```
33		*
34		* For more details and usage information on Cache, see
35		* [PSR-16 specification](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-16-simple-cache.md).
36		*/
37		final class Cache implements CacheInterface
38		{
39		/**
40		* @var \Psr\SimpleCache\CacheInterface actual cache handler.
41		*/
42		private $handler;
43	57
44		/**
45	57	* @var string a string prefixed to every cache key so that it is unique globally in the whole cache storage.
46		* It is recommended that you set a unique cache key prefix for each application if the same cache
47		* storage is being used by different applications.
48		*/
49		private $keyPrefix = '';
50
51		private $keyNormalization = true;
52
53		/**
54		* @var int\|null default TTL for a cache entry. null meaning infinity, negative or zero results in cache key deletion.
55		* This value is used by {@see set()} and {@see setMultiple()}, if the duration is not explicitly given.
56		*/
57		private $defaultTtl;
58	57
59		/**
60	57	* @param \Psr\SimpleCache\CacheInterface cache handler.
61	51	*/
62		public function __construct(\Psr\SimpleCache\CacheInterface $handler = null)
63	6	{
64		$this->handler = $handler;
65		}
66
67	51	/**
68		* Builds a normalized cache key from a given key.
69	51	*
70	51	* If the given key is a string containing alphanumeric characters only and no more than 32 characters,
71		* then the key will be returned back as it is. Otherwise, a normalized key is generated by serializing
72	51	* the given key and applying MD5 hashing.
73	34	*
74		* @param mixed $key the key to be normalized
75		* @return string the generated cache key
76	45	*/
77	4	private function normalizeKey($key): string
78	4	{
79		if (!$this->keyNormalization) {
80	4	$normalizedKey = $key;
81		} elseif (\is_string($key)) {
82		$normalizedKey = ctype_alnum($key) && mb_strlen($key, '8bit') <= 32 ? $key : md5($key);
83	41	} else {
84		$normalizedKey = $this->keyPrefix . md5(json_encode($key));
85		}
86
87	9	return $this->keyPrefix . $normalizedKey;
88		}
89	9
90	9
91		public function get($key, $default = null)
92		{
93		$key = $this->normalizeKey($key);
94		$value = $this->handler->get($key, $default);
95
96		if (\is_array($value) && isset($value[1]) && $value[1] instanceof Dependency) {
97		if ($value[1]->isChanged($this)) {
98		return $default;
99		}
100		$value = $value[0];
101		}
102
103		return $value;
104		}
105	7
106
107	7	public function has($key): bool
108	7	{
109	7	$key = $this->normalizeKey($key);
110		return $this->handler->has($key);
111	7	}
112	7
113	7	/**
114	7	* Retrieves multiple values from cache with the specified keys.
115	7	* Some caches, such as memcached or apcu, allow retrieving multiple cached values at the same time,
116	7	* which may improve the performance. In case a cache does not support this feature natively,
117	7	* this method will try to simulate it.
118		* @param string[] $keys list of string keys identifying the cached values
119		* @param mixed $default Default value to return for keys that do not exist.
120		* @return iterable list of cached values corresponding to the specified keys. The array
121		* is returned in terms of (key, value) pairs.
122		* If a value is not cached or expired, the corresponding array value will be false.
123		* @throws InvalidArgumentException
124	7	*/
125		public function getMultiple($keys, $default = null): iterable
126		{
127		$keyMap = [];
128	7	foreach ($keys as $key) {
129		$keyMap[$key] = $this->normalizeKey($key);
130		}
131		$values = $this->handler->getMultiple(array_values($keyMap), $default);
132		$results = [];
133		foreach ($keyMap as $key => $newKey) {
134		$results[$key] = $default;
135		if (array_key_exists($newKey, (array)$values)) {
136		$value = $values[$newKey];
137		if (\is_array($value) && isset($value[1]) && $value[1] instanceof Dependency) {
138		if ($value[1]->isChanged($this)) {
139		continue;
140		}
141
142		$value = $value[0];
143		}
144		$results[$key] = $value;
145	43	}
146		}
147	43
148	4	return $results;
149	4	}
150
151	43	/**
152	43	* Stores a value identified by a key into cache.
153		* If the cache already contains such a key, the existing value and
154		* expiration time will be replaced with the new ones, respectively.
155		*
156		* @param mixed $key a key identifying the value to be cached. This can be a simple string or
157		* a complex data structure consisting of factors representing the key.
158		* @param mixed $value the value to be cached
159		* @param null\|int\|\DateInterval $ttl the TTL of this value. If not set, default value is used.
160		* @param Dependency $dependency dependency of the cached value. If the dependency changes,
161		* the corresponding value in the cache will be invalidated when it is fetched via {@see CacheInterface::get()}.
162		* @return bool whether the value is successfully stored into cache
163		* @throws InvalidArgumentException
164		*/
165		public function set($key, $value, $ttl = null, Dependency $dependency = null): bool
166		{
167	13	$ttl = $this->normalizeTtl($ttl);
168
169	13	if ($dependency !== null) {
170	13	$dependency->evaluateDependency($this);
171		$value = [$value, $dependency];
172		}
173	3	$key = $this->normalizeKey($key);
174
175	3	return $this->handler->set($key, $value, $ttl);
176	3	}
177	3
178		/**
179	3	* Stores multiple values in cache. Each value contains a value identified by a key.
180		* If the cache already contains such a key, the existing value and
181		* expiration time will be replaced with the new ones, respectively.
182		*
183		* @param array $values the values to be cached, as key-value pairs.
184		* @param null\|int\|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
185		* @param Dependency $dependency dependency of the cached values. If the dependency changes,
186		* the corresponding values in the cache will be invalidated when it is fetched via {@see CacheInterface::get()}.
187		* @return bool True on success and false on failure.
188		* @throws InvalidArgumentException
189		*/
190		public function setMultiple($values, $ttl = null, Dependency $dependency = null): bool
191		{
192		$data = $this->prepareDataForSetOrAddMultiple($values, $dependency);
193	3	$ttl = $this->normalizeTtl($ttl);
194		return $this->handler->setMultiple($data, $ttl);
195	3	}
196	3
197	3	public function deleteMultiple($keys): bool
198	3	{
199	3	$actualKeys = [];
200		foreach ($keys as $key) {
201		$actualKeys[] = $this->normalizeKey($key);
202	3	}
203		return $this->handler->deleteMultiple($actualKeys);
204		}
205	16
206		/**
207	16	* Stores multiple values in cache. Each value contains a value identified by a key.
208		* If the cache already contains such a key, the existing value and expiration time will be preserved.
209		*
210		* @param array $values the values to be cached, as key-value pairs.
211	16	* @param null\|int\|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
212	16	* @param Dependency $dependency dependency of the cached values. If the dependency changes,
213	16	* the corresponding values in the cache will be invalidated when it is fetched via {@see CacheInterface::get()}.
214		* @return bool
215		* @throws InvalidArgumentException
216		*/
217	16	public function addMultiple(array $values, $ttl = null, Dependency $dependency = null): bool
218	16	{
219		$data = $this->prepareDataForSetOrAddMultiple($values, $dependency);
220		$ttl = $this->normalizeTtl($ttl);
221	16	$existingValues = $this->handler->getMultiple(array_keys($data));
222		foreach ($existingValues as $key => $value) {
223		if ($value !== null) {
224		unset($data[$key]);
225		}
226		}
227		return $this->handler->setMultiple($data, $ttl);
228		}
229
230		private function prepareDataForSetOrAddMultiple(iterable $values, ?Dependency $dependency): array
231		{
232		if ($dependency !== null) {
233		$dependency->evaluateDependency($this);
234		}
235
236	5	$data = [];
237		foreach ($values as $key => $value) {
238	5	if ($dependency !== null) {
239		$value = [$value, $dependency];
240		}
241
242		$key = $this->normalizeKey($key);
243	5	$data[$key] = $value;
244		}
245	5
246	3	return $data;
247		}
248
249	5	/**
250		* Stores a value identified by a key into cache if the cache does not contain this key.
251		* Nothing will be done if the cache already contains the key.
252		* @param mixed $key a key identifying the value to be cached. This can be a simple string or
253		* a complex data structure consisting of factors representing the key.
254		* @param mixed $value the value to be cached
255		* @param null\|int\|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
256		* @param Dependency $dependency dependency of the cached value. If the dependency changes,
257		* the corresponding value in the cache will be invalidated when it is fetched via {@see CacheInterface::get()}.
258		* @return bool whether the value is successfully stored into cache
259	3	* @throws InvalidArgumentException
260		*/
261	3	public function add($key, $value, $ttl = null, Dependency $dependency = null): bool
262		{
263	3	if ($dependency !== null) {
264		$dependency->evaluateDependency($this);
265		$value = [$value, $dependency];
266		}
267
268		$key = $this->normalizeKey($key);
269
270		if ($this->handler->has($key)) {
271	56	return false;
272		}
273	56
274		$ttl = $this->normalizeTtl($ttl);
275
276		return $this->handler->set($key, $value, $ttl);
277		}
278
279		/**
280		* Deletes a value with the specified key from cache.
281		* @param mixed $key a key identifying the value to be deleted from cache. This can be a simple string or
282		* a complex data structure consisting of factors representing the key.
283		* @return bool if no error happens during deletion
284		* @throws InvalidArgumentException
285		*/
286		public function delete($key): bool
287		{
288		$key = $this->normalizeKey($key);
289
290		return $this->handler->delete($key);
291		}
292
293		/**
294		* Deletes all values from cache.
295		* Be careful of performing this operation if the cache is shared among multiple applications.
296		* @return bool whether the flush operation was successful.
297		*/
298		public function clear(): bool
299		{
300		return $this->handler->clear();
301		}
302
303	6	/**
304		* Method combines both {@see CacheInterface::set()} and {@see CacheInterface::get()} methods to retrieve
305	6	* value identified by a $key, or to store the result of $callable execution if there is no cache available
306	3	* for the $key.
307		*
308		* Usage example:
309	6	*
310	6	* ```php
311		* public function getTopProducts($count = 10) {
312		* $cache = $this->cache;
313		* return $cache->getOrSet(['top-n-products', 'n' => $count], function ($cache) use ($count) {
314	6	* return $this->getTopNProductsFromDatabase($count);
315		* }, 1000);
316		* }
317		* ```
318		*
319		* @param mixed $key a key identifying the value to be cached. This can be a simple string or
320		* a complex data structure consisting of factors representing the key.
321		* @param callable\|\Closure $callable the callable or closure that will be used to generate a value to be cached.
322		* In case $callable returns `false`, the value will not be cached.
323		* @param null\|int\|\DateInterval $ttl the TTL value of this value. If not set, default value is used.
324		* @param Dependency $dependency dependency of the cached value. If the dependency changes,
325		* the corresponding value in the cache will be invalidated when it is fetched via {@see CacheInterface::get()}.
326		* @return mixed result of $callable execution
327		* @throws SetCacheException
328		* @throws InvalidArgumentException
329		*/
330		public function getOrSet($key, callable $callable, $ttl = null, Dependency $dependency = null)
331		{
332		if (($value = $this->get($key)) !== null) {
333		return $value;
334		}
335
336		$value = $callable($this);
337		$ttl = $this->normalizeTtl($ttl);
338		if (!$this->set($key, $value, $ttl, $dependency)) {
339		throw new SetCacheException($key, $value, $this);
340		}
341
342		return $value;
343		}
344
345		public function __call($name, $arguments)
346		{
347		return call_user_func_array([$this->handler, $name], $arguments);
348		}
349
350		public function enableKeyNormalization(): void
351		{
352		$this->keyNormalization = true;
353		}
354
355		public function disableKeyNormalization(): void
356		{
357		$this->keyNormalization = false;
358		}
359
360		/**
361		* @param string $keyPrefix a string prefixed to every cache key so that it is unique globally in the whole cache storage.
362		* It is recommended that you set a unique cache key prefix for each application if the same cache
363		* storage is being used by different applications.
364		*/
365		public function setKeyPrefix(string $keyPrefix): void
366		{
367		if ($keyPrefix != '' && !ctype_alnum($keyPrefix)) {
368		throw new Exception\InvalidArgumentException('Cache key prefix should be alphanumeric');
		0 ignored issues – show Bug introduced 2019-08-08 12:32 UTC by Report Bug Copy Issue Report The type `Exception\InvalidArgumentException` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
369		}
370		$this->keyPrefix = $keyPrefix;
371		}
372
373		/**
374		* @return int\|null
375		*/
376		public function getDefaultTtl(): ?int
377		{
378		return $this->defaultTtl;
379		}
380
381		/**
382		* @param int\|DateInterval\|null $defaultTtl
383		*/
384		public function setDefaultTtl($defaultTtl): void
385		{
386		$this->defaultTtl = $this->normalizeTtl($defaultTtl);
387		}
388
389		/**
390		* Normalizes cache TTL handling `null` value and {@see DateInterval} objects.
391		* @param int\|DateInterval\|null $ttl raw TTL.
392		* @return int\|null TTL value as UNIX timestamp or null meaning infinity
393		*/
394		protected function normalizeTtl($ttl): ?int
395		{
396		if ($ttl === null) {
397		return $this->defaultTtl;
398		}
399
400		if ($ttl instanceof DateInterval) {
401		try {
402		return (new DateTime('@0'))->add($ttl)->getTimestamp();
403		} catch (Exception $e) {
404		return $this->defaultTtl;
405		}
406		}
407
408		return $ttl;
409		}
410		}
411

yiisoft / cache

Pull Request — master (#30)

Cache::normalizeTtl() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like