Dtc\QueueBundle\Redis\PhpRedis

Complexity

Total Complexity

24

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Test Coverage

Coverage

90.91%

Importance

Changes	1
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	mGet()	0	3	1
A	zScan()	0	3	1
A	hGetAll()	0	3	1
A	hIncrBy()	0	3	1
A	hScan()	0	3	1
A	zCount()	0	3	1
A	setEx()	0	3	1
A	zPopByMaxScore()	0	21	4
A	del()	0	3	1
A	zPop()	0	21	4
A	lRange()	0	3	1
A	get()	0	3	1
A	lPush()	0	6	1
A	zRem()	0	3	1
A	__construct()	0	4	1
A	set()	0	3	1
A	lRem()	0	3	1
A	zAdd()	0	3	1

<?php

namespace Dtc\QueueBundle\Redis;

class PhpRedis implements RedisInterface
{
    protected $redis;
    protected $maxRetries;

    public function __construct(\Redis $redis, $maxRetries = 5)
    {
        $this->redis = $redis;
        $this->maxRetries = $maxRetries;
    }

    public function mGet(array $keys)
    {
        return $this->redis->mGet($keys);
    }

    public function hScan($key, &$cursor, $pattern = '', $count = 0)
    {
        return $this->redis->hScan($key, $cursor, $pattern, $count);
    }

    public function zScan($key, &$cursor, $pattern = '', $count = 0)
    {
        return $this->redis->zScan($key, $cursor, $pattern, $count);
    }

    public function zCount($key, $min, $max)
    {
        return $this->redis->zCount($key, $min, $max);
    }

    public function zAdd($zkey, $score, $value)
    {
        return $this->redis->zadd($zkey, $score, $value);
    }

    public function set($key, $value)
    {
        return $this->redis->set($key, $value);
    }

    public function get($key)
    {
        return $this->redis->get($key);

The expression return $this->redis->get($key) also could return the type string which is incompatible with the return type mandated by Dtc\QueueBundle\Redis\RedisInterface::get() of false.

    }

    public function hIncrBy($key, $hashKey, $value)
    {
        return $this->redis->hIncrBy($key, $hashKey, $value);
    }

    public function hGetAll($key)
    {
        return $this->redis->hGetAll($key);
    }

    public function setEx($key, $seconds, $value)
    {
        return $this->redis->setex($key, $seconds, $value);
    }

    public function lRem($lKey, $count, $value)
    {
        return $this->redis->lrem($lKey, $value, $count);
    }

    public function lPush($lKey, array $values)
    {
        $args = $values;
        array_unshift($args, $lKey);

        return call_user_func_array([$this->redis, 'lPush'], $args);
    }

    public function lRange($lKey, $start, $stop)
    {
        return $this->redis->lrange($lKey, $start, $stop);
    }

    public function del(array $keys)
    {
        return $this->redis->del($keys);
    }

    public function zRem($zkey, $value)
    {
        return $this->redis->zrem($zkey, $value);
    }

    public function zPop($key)
    {
        $retries = 0;
        do {
            $this->redis->watch($key);
            $elements = $this->redis->zrange($key, 0, 0);
            if (empty($elements)) {
                $this->redis->unwatch();

                return null;
            }
            $result = $this->redis->multi()
                ->zrem($key, $elements[0])
                ->exec();

The method exec() does not exist on integer.

            if (false !== $result) {
                return $elements[0];
            }
            ++$retries;
        } while ($retries < $this->maxRetries);

        return null;
    }

    public function zPopByMaxScore($key, $max)
    {
        $retries = 0;
        do {
            $this->redis->watch($key);
            $elements = $this->redis->zrangebyscore($key, 0, $max, ['limit' => [0, 1]]);
            if (empty($elements)) {
                $this->redis->unwatch();

                return null;
            }
            $result = $this->redis->multi()
                ->zrem($key, $elements[0])
                ->exec();
            if (false !== $result) {
                return $elements[0];
            }
            ++$retries;
        } while ($retries < $this->maxRetries);

        return null;
    }
}