Matecat\SimpleS3\Components\Cache\RedisCache

Complexity

Total Complexity

20

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Test Coverage

Coverage

85.37%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	flushAll()	0	9	2
A	get()	0	7	2
A	search()	0	3	1
A	getDirName()	0	9	2
A	setPrefixSeparator()	0	3	1
A	has()	0	7	2
A	set()	0	13	4
A	remove()	0	7	2
A	ttl()	0	7	2
A	getHashPrefix()	0	3	1

<?php

namespace Matecat\SimpleS3\Components\Cache;

use Matecat\SimpleS3\Helpers\File;
use Predis\Client as Redis;

class RedisCache implements CacheInterface

The type Matecat\SimpleS3\Components\Cache\CacheInterface was not found. Maybe you did not declare it correctly or list all dependencies?

{
    /**
     * @var string
     */
    private string $prefixSeparator = DIRECTORY_SEPARATOR;

    /**
     * @var Redis
     */
    private Redis $redisClient;

    /**
     * RedisCache constructor.
     *
     * @param Redis $redisClient
     */
    public function __construct(Redis $redisClient)
    {
        $this->redisClient = $redisClient;
    }

    /**
     * @return bool
     */
    public function flushAll(): bool
    {
        $flush = $this->redisClient->flushall();

        if ($flush->getPayload() === 'OK') {
            return true;
        }

        return false;
    }

    /**
     * @param string      $bucket
     * @param string      $keyname
     * @param string|null $version
     *
     * @return mixed
     */
    public function get(string $bucket, string $keyname, ?string $version = null): mixed
    {
        if (null != $version) {

It seems like you are loosely comparing $version of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $keyname .= '<VERSION_ID:' . $version . '>';
        }

        return unserialize($this->redisClient->hget($this->getHashPrefix($bucket, $keyname), $keyname));
    }

    /**
     * @param string      $bucket
     * @param string      $keyname
     * @param string|null $version
     *
     * @return bool
     */
    public function has(string $bucket, string $keyname, ?string $version = null): bool
    {
        if (null != $version) {

It seems like you are loosely comparing $version of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $keyname .= '<VERSION_ID:' . $version . '>';
        }

        return 1 === $this->redisClient->hexists($this->getHashPrefix($bucket, $keyname), $keyname);
    }

    /**
     * @param string      $bucket
     * @param string      $keyname
     * @param string|null $version
     *
     * @return bool
     */
    public function remove(string $bucket, string $keyname, ?string $version = null): bool
    {
        if (null != $version) {

It seems like you are loosely comparing $version of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $keyname .= '<VERSION_ID:' . $version . '>';
        }

        return $this->redisClient->hdel($this->getHashPrefix($bucket, $keyname), [$keyname]) === 1;
    }

    /**
     * @param string $bucket
     * @param string $keyname
     *
     * @return array
     */
    public function search(string $bucket, string $keyname): array
    {
        return $this->redisClient->hkeys($this->getHashPrefix($bucket, $keyname));
    }

    /**
     * @param string      $bucket
     * @param string      $keyname
     * @param mixed       $content
     * @param string|null $version
     * @param int         $ttl
     *
     * @return int
     */
    public function set(string $bucket, string $keyname, mixed $content, ?string $version = null, int $ttl = 0): int
    {
        if (null != $version) {

It seems like you are loosely comparing $version of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $keyname .= '<VERSION_ID:' . $version . '>';
        }

        $res = $this->redisClient->hset($this->getHashPrefix($bucket, $keyname), $keyname, serialize($content));

        if ($this->ttl($bucket, $keyname) === -1) {
            return $this->redisClient->expire($this->getHashPrefix($bucket, $keyname), (null != $ttl) ? $ttl * 60 : self::TTL_STANDARD);
        }

        return $res;
    }

    /**
     * @param string $separator
     */
    public function setPrefixSeparator(string $separator): void
    {
        $this->prefixSeparator = $separator;
    }

    /**
     * @param string      $bucket
     * @param string      $keyname
     * @param string|null $version
     *
     * @return int
     */
    public function ttl(string $bucket, string $keyname, ?string $version = null): int
    {
        if (null != $version) {

It seems like you are loosely comparing $version of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $keyname .= '<VERSION_ID:' . $version . '>';
        }

        return $this->redisClient->ttl($this->getHashPrefix($bucket, $keyname));
    }

    /**
     * @param string $bucketName
     * @param string $keyName
     *
     * @return string
     */
    private function getHashPrefix(string $bucketName, string $keyName): string
    {
        return hash(self::HASH_ALGORITHM, $bucketName . self::HASH_SAFE_SEPARATOR . $this->getDirName($keyName));
    }

    /**
     * @param string $item
     *
     * @return string
     */
    private function getDirName(string $item): string
    {
        if (File::endsWith($item, $this->prefixSeparator)) {
            return $item;
        }

        $fileInfo = File::getPathInfo($item);

        return $fileInfo[ 'dirname' ] . $this->prefixSeparator;
    }
}