RedisCache::iterableToArray() - Code Metrics - Inspection of "Add source code and tests, update support files" - yiisoft/cache-redis - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1)

by Evgeniy

created 2021-11-07 14:05 UTC

RedisCache::iterableToArray() A

↳ Parent: RedisCache

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Cache\Redis;

use DateInterval;
use DateTime;
use Predis\ClientInterface;
use Predis\Response\Status;
use Psr\SimpleCache\CacheInterface;
use Traversable;

use function array_fill_keys;
use function array_keys;
use function array_map;
use function count;
use function gettype;
use function is_iterable;
use function is_string;
use function iterator_to_array;
use function serialize;
use function strpbrk;
use function unserialize;

/**
 * RedisCache stores cache data in a Redis.
 *
 * Please refer to {@see CacheInterface} for common cache operations that are supported by RedisCache.
 */
final class RedisCache implements CacheInterface
{
    /**
     * @var ClientInterface $client Predis client instance to use.
     */
    private ClientInterface $client;

    /**
     * @param ClientInterface $client Predis client instance to use.
     */
    public function __construct(ClientInterface $client)
    {
        $this->client = $client;
    }

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

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

        return unserialize($value);
    }

    public function set($key, $value, $ttl = null): bool
    {
        $ttl = $this->normalizeTtl($ttl);

        if ($this->isExpiredTtl($ttl)) {
            return $this->delete($key);
        }

        $this->validateKey($key);

        /** @var Status|null $result */
        $result = $this->isInfinityTtl($ttl)
            ? $this->client->set($key, serialize($value))
            : $this->client->set($key, serialize($value), 'EX', $ttl)
        ;

        return $result !== null;
    }

    public function delete($key): bool
    {
        return !$this->has($key) || $this->client->del($key) === 1;
    }

    public function clear(): bool
    {
        return $this->client->flushdb() !== null;
    }

    public function getMultiple($keys, $default = null): iterable
    {
        $keys = $this->iterableToArray($keys);
        $this->validateKeys($keys);
        /** @var string[] $keys */
        $values = array_fill_keys($keys, $default);
        /** @var null[]|string[] $valuesFromCache */
        $valuesFromCache = $this->client->mget($keys);

        $i = 0;
        /** @var mixed $default */
        foreach ($values as $key => $default) {
            /** @psalm-suppress MixedAssignment */
            $values[$key] = isset($valuesFromCache[$i]) ? unserialize($valuesFromCache[$i]) : $default;
            $i++;
        }

        return $values;
    }

    public function setMultiple($values, $ttl = null): bool
    {
        $values = $this->iterableToArray($values);
        $keys = array_map('\strval', array_keys($values));
        $this->validateKeys($keys);
        $ttl = $this->normalizeTtl($ttl);
        $serializeValues = [];

        if ($this->isExpiredTtl($ttl)) {
            return $this->deleteMultiple($keys);
        }

        /** @var mixed $value */
        foreach ($values as $key => $value) {
            $serializeValues[$key] = serialize($value);
        }

        if ($this->isInfinityTtl($ttl)) {
            $this->client->mset($serializeValues);
            return true;
        }

        $this->client->multi();
        $this->client->mset($serializeValues);

        foreach ($keys as $key) {
            $this->client->expire($key, $ttl);
        }

        $results = $this->client->exec();

        /** @var Status|null $result */
        foreach ((array) $results as $result) {
            if ($result === null) {
                return false;
            }
        }

        return true;
    }

    public function deleteMultiple($keys): bool
    {
        $keys = $this->iterableToArray($keys);

        /** @psalm-suppress MixedAssignment, MixedArgument */
        foreach ($keys as $index => $key) {
            if (!$this->has($key)) {
                unset($keys[$index]);
            }
        }

        return empty($keys) || $this->client->del($keys) === count($keys);
    }

    public function has($key): bool
    {
        $this->validateKey($key);
        $ttl = $this->client->ttl($key);
        /** "-1" - if the key exists but has no associated expire {@see https://redis.io/commands/ttl}. */
        return $ttl > 0 || $ttl === -1;
    }

    /**
     * Normalizes cache TTL handling `null` value, strings and {@see DateInterval} objects.
     *
     * @param DateInterval|int|string|null $ttl The raw TTL.
     *
     * @return int TTL value as UNIX timestamp.
     */
    private function normalizeTtl($ttl): ?int
    {
        if ($ttl === null) {
            return null;
        }

        if ($ttl instanceof DateInterval) {
            return (new DateTime('@0'))->add($ttl)->getTimestamp();
        }

        return (int) $ttl;
    }

    /**
     * Converts iterable to array. If provided value is not iterable it throws an InvalidArgumentException.
     *
     * @param mixed $iterable
     *
     * @return array
     */
    private function iterableToArray($iterable): array
    {
        if (!is_iterable($iterable)) {
            throw new InvalidArgumentException('Iterable is expected, got ' . gettype($iterable));
        }

        /** @psalm-suppress RedundantCast */
        return $iterable instanceof Traversable ? iterator_to_array($iterable) : (array) $iterable;
    }

    /**
     * @param mixed $key
     */
    private function validateKey($key): void
    {
        if (!is_string($key) || $key === '' || strpbrk($key, '{}()/\@:')) {
            throw new InvalidArgumentException('Invalid key value.');
        }
    }

    /**
     * @param array $keys
     */
    private function validateKeys(array $keys): void
    {
        if (empty($keys)) {
            throw new InvalidArgumentException('Invalid key values.');
        }

        /** @var mixed $key */
        foreach ($keys as $key) {
            $this->validateKey($key);
        }
    }

    private function isExpiredTtl(?int $ttl): bool
    {
        return $ttl !== null && $ttl <= 0;
    }

    private function isInfinityTtl(?int $ttl): bool
    {
        return $ttl === null;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Cache\Redis;
6
7		use DateInterval;
8		use DateTime;
9		use Predis\ClientInterface;
10		use Predis\Response\Status;
11		use Psr\SimpleCache\CacheInterface;
12		use Traversable;
13
14		use function array_fill_keys;
15		use function array_keys;
16		use function array_map;
17		use function count;
18		use function gettype;
19		use function is_iterable;
20		use function is_string;
21		use function iterator_to_array;
22		use function serialize;
23		use function strpbrk;
24		use function unserialize;
25
26		/**
27		* RedisCache stores cache data in a Redis.
28		*
29		* Please refer to {@see CacheInterface} for common cache operations that are supported by RedisCache.
30		*/
31		final class RedisCache implements CacheInterface
32		{
33		/**
34		* @var ClientInterface $client Predis client instance to use.
35		*/
36		private ClientInterface $client;
37
38		/**
39		* @param ClientInterface $client Predis client instance to use.
40		*/
41	178	public function __construct(ClientInterface $client)
42		{
43	178	$this->client = $client;
44	178	}
45
46	73	public function get($key, $default = null)
47		{
48	73	$this->validateKey($key);
49	65	$value = $this->client->get($key);
50
51	65	if ($value === null) {
52	25	return $default;
53		}
54
55	52	return unserialize($value);
56		}
57
58	93	public function set($key, $value, $ttl = null): bool
59		{
60	93	$ttl = $this->normalizeTtl($ttl);
61
62	93	if ($this->isExpiredTtl($ttl)) {
63	1	return $this->delete($key);
64		}
65
66	92	$this->validateKey($key);
67
68		/** @var Status\|null $result */
69	84	$result = $this->isInfinityTtl($ttl)
70	72	? $this->client->set($key, serialize($value))
71	12	: $this->client->set($key, serialize($value), 'EX', $ttl)
72		;
73
74	84	return $result !== null;
75		}
76
77	22	public function delete($key): bool
78		{
79	22	return !$this->has($key) \|\| $this->client->del($key) === 1;
80		}
81
82	178	public function clear(): bool
83		{
84	178	return $this->client->flushdb() !== null;
85		}
86
87	24	public function getMultiple($keys, $default = null): iterable
88		{
89	24	$keys = $this->iterableToArray($keys);
90	16	$this->validateKeys($keys);
91		/** @var string[] $keys */
92	7	$values = array_fill_keys($keys, $default);
93		/** @var null[]\|string[] $valuesFromCache */
94	7	$valuesFromCache = $this->client->mget($keys);
95
96	7	$i = 0;
97		/** @var mixed $default */
98	7	foreach ($values as $key => $default) {
99		/** @psalm-suppress MixedAssignment */
100	7	$values[$key] = isset($valuesFromCache[$i]) ? unserialize($valuesFromCache[$i]) : $default;
101	7	$i++;
102		}
103
104	7	return $values;
105		}
106
107	21	public function setMultiple($values, $ttl = null): bool
108		{
109	21	$values = $this->iterableToArray($values);
110	13	$keys = array_map('\strval', array_keys($values));
111	13	$this->validateKeys($keys);
112	12	$ttl = $this->normalizeTtl($ttl);
113	12	$serializeValues = [];
114
115	12	if ($this->isExpiredTtl($ttl)) {
116	1	return $this->deleteMultiple($keys);
117		}
118
119		/** @var mixed $value */
120	11	foreach ($values as $key => $value) {
121	11	$serializeValues[$key] = serialize($value);
122		}
123
124	11	if ($this->isInfinityTtl($ttl)) {
125	8	$this->client->mset($serializeValues);
126	8	return true;
127		}
128
129	3	$this->client->multi();
130	3	$this->client->mset($serializeValues);
131
132	3	foreach ($keys as $key) {
133	3	$this->client->expire($key, $ttl);
134		}
135
136	3	$results = $this->client->exec();
137
138		/** @var Status\|null $result */
139	3	foreach ((array) $results as $result) {
140	3	if ($result === null) {
141	1	return false;
142		}
143		}
144
145	2	return true;
146		}
147
148	19	public function deleteMultiple($keys): bool
149		{
150	19	$keys = $this->iterableToArray($keys);
151
152		/** @psalm-suppress MixedAssignment, MixedArgument */
153	11	foreach ($keys as $index => $key) {
154	11	if (!$this->has($key)) {
155	2	unset($keys[$index]);
156		}
157		}
158
159	3	return empty($keys) \|\| $this->client->del($keys) === count($keys);
160		}
161
162	51	public function has($key): bool
163		{
164	51	$this->validateKey($key);
165	27	$ttl = $this->client->ttl($key);
166		/** "-1" - if the key exists but has no associated expire {@see https://redis.io/commands/ttl}. */
167	27	return $ttl > 0 \|\| $ttl === -1;
168		}
169
170		/**
171		* Normalizes cache TTL handling `null` value, strings and {@see DateInterval} objects.
172		*
173		* @param DateInterval\|int\|string\|null $ttl The raw TTL.
174		*
175		* @return int TTL value as UNIX timestamp.
176		*/
177	111	private function normalizeTtl($ttl): ?int
178		{
179	111	if ($ttl === null) {
180	89	return null;
181		}
182
183	22	if ($ttl instanceof DateInterval) {
184	2	return (new DateTime('@0'))->add($ttl)->getTimestamp();
185		}
186
187	20	return (int) $ttl;
188		}
189
190		/**
191		* Converts iterable to array. If provided value is not iterable it throws an InvalidArgumentException.
192		*
193		* @param mixed $iterable
194		*
195		* @return array
196		*/
197	55	private function iterableToArray($iterable): array
198		{
199	55	if (!is_iterable($iterable)) {
200	24	throw new InvalidArgumentException('Iterable is expected, got ' . gettype($iterable));
201		}
202
203		/** @psalm-suppress RedundantCast */
204	31	return $iterable instanceof Traversable ? iterator_to_array($iterable) : (array) $iterable;
205		}
206
207		/**
208		* @param mixed $key
209		*/
210	145	private function validateKey($key): void
211		{
212	145	if (!is_string($key) \|\| $key === '' \|\| strpbrk($key, '{}()/\@:')) {
213	48	throw new InvalidArgumentException('Invalid key value.');
214		}
215	97	}
216
217		/**
218		* @param array $keys
219		*/
220	23	private function validateKeys(array $keys): void
221		{
222	23	if (empty($keys)) {
223	2	throw new InvalidArgumentException('Invalid key values.');
224		}
225
226		/** @var mixed $key */
227	21	foreach ($keys as $key) {
228	21	$this->validateKey($key);
229		}
230	13	}
231
232	104	private function isExpiredTtl(?int $ttl): bool
233		{
234	104	return $ttl !== null && $ttl <= 0;
235		}
236
237	95	private function isInfinityTtl(?int $ttl): bool
238		{
239	95	return $ttl === null;
240		}
241		}
242

yiisoft / cache-redis

Pull Request — master (#1)

RedisCache::iterableToArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like