Soupmix\Cache\RedisCache

Complexity

Total Complexity

27

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

73.44%

Importance

Changes	5
Bugs	1	Features	3

13 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	9	2
A	getConnection()	0	4	1
A	get()	0	5	2
A	__construct()	0	7	3
A	delete()	0	4	1
A	clear()	0	4	1
A	getMultiple()	0	8	2
B	setMultiple()	0	15	5
A	deleteMultiple()	0	11	3
A	increment()	0	4	1
A	decrement()	0	4	1
A	has()	0	5	1
A	checkReservedCharacters()	0	14	4

<?php

namespace Soupmix\Cache;

use Soupmix\Cache\Exceptions\InvalidArgumentException;
use Psr\SimpleCache\CacheInterface;
use Redis;

class RedisCache implements CacheInterface
{
    const PSR16_RESERVED_CHARACTERS = ['{','}','(',')','/','@',':'];

    private $handler = null;

    private $serializer = 'PHP';

    /**
     * Connect to Redis service
     *
     * @param Redis $handler Configuration values that has dbIndex name and host's IP address
     *
     */
    public function __construct(Redis $handler)
    {
        if (defined('Redis::SERIALIZER_IGBINARY') && extension_loaded('igbinary')) {
            $handler->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY);
        }
        $this->handler = $handler;
    }

    public function getConnection()
    {
        return $this->handler;
    }

    /**
     * {@inheritDoc}
     */
    public function get($key, $default = null)
    {
        $value = $this->handler->get($key);
        return $value ? $value : $default;
    }

    /**
     * {@inheritDoc}
     */
    public function set($key, $value, $ttl = null)
    {
        $ttl = (int) $ttl;
        $value = $value;

Why assign $value to itself?

        if ($ttl === 0) {
            return $this->handler->set($key, $value);
        }
        return $this->handler->set($key, $value, $ttl);
    }

    /**
     * {@inheritDoc}
     */
    public function delete($key)
    {
        return (bool) $this->handler->delete($key);
    }
    /**
     * {@inheritDoc}
     */
    public function clear()
    {
        return $this->handler->flushDb();
    }
    /**
     * {@inheritDoc}
     */
    public function getMultiple($keys, $default = null)
    {
        $defaults = array_fill(0, count($keys), $default);
        foreach ($keys as $key) {
            $this->checkReservedCharacters($key);
        }
        return array_merge(array_combine($keys, $this->handler->mGet($keys)), $defaults);

The return type of return array_merge(array_combine($keys, $this->handler->mGet($keys)), $defaults); (array) is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::getMultiple of type Psr\SimpleCache\iterable.

    }
    /**
     * {@inheritDoc}
     */
    public function setMultiple($values, $ttl = null)
    {
        foreach ($values as $key => $value) {
            $this->checkReservedCharacters($key);
        }
        if (($ttl === null) || ($ttl === 0)) {
            return $this->handler->mSet($values);
        }

        $return =[];
        foreach ($values as $key => $value) {
            $return[$key] =  $this->set($key, $value, $ttl);
        }
        return $return;

The return type of return $return; (array) is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::setMultiple of type boolean.

    }
    /**
     * {@inheritDoc}
     */
    public function deleteMultiple($keys)
    {
        foreach ($keys as $key) {
            $this->checkReservedCharacters($key);
        }
        $return =[];
        foreach ($keys as $key) {
            $return[$key] = (bool) $this->delete($key);
        }
        return $return;

The return type of return $return; (array) is incompatible with the return type declared by the interface Psr\SimpleCache\CacheInterface::deleteMultiple of type boolean.

    }
    /**
     * Increment a value atomically in the cache by its step value, which defaults to 1
     *
     * @param string  $key  The cache item key
     * @param integer $step The value to increment by, defaulting to 1
     *
     * @return int|bool The new value on success and false on failure
     */
    public function increment($key, $step = 1)
    {
        return $this->handler->incr($key, $step);
    }
    /**
     * Decrement a value atomically in the cache by its step value, which defaults to 1
     *
     * @param string  $key  The cache item key
     * @param integer $step The value to decrement by, defaulting to 1
     *
     * @return int|bool The new value on success and false on failure
     */
    public function decrement($key, $step = 1)
    {
        return $this->handler->decr($key, $step);
    }




    /**
     * {@inheritDoc}
     */
    public function has($key)
    {
        $this->checkReservedCharacters($key);
        return $this->handler->exists($key);
    }

    private function checkReservedCharacters($key)
    {

        if (!is_string($key)) {
            $message = sprintf('key %s is not a string.', $key);
            throw new InvalidArgumentException($message);
        }
        foreach (self::PSR16_RESERVED_CHARACTERS as $needle) {
            if (strpos($key, $needle) !== false) {
                $message = sprintf('%s string is not a legal value.', $key);
                throw new InvalidArgumentException($message);
            }
        }
    }
}