RedisProxy - Code Metrics - Inspection of "Added some tests for Redis and Predis driver" - lulco/redis-proxy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Michal

created 2017-01-11 07:15 UTC

RedisProxy B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	292
Duplicated Lines	19.86 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

81.55%

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	52
c	2
b	0
f	0
lcom	1
cbo	3
dl	58
loc	292
ccs	137
cts	168
cp	0.8155
rs	7.9487

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setDriversOrder()	0	13	4
A	init()	0	5	1
B	prepareDriver()	0	18	7
A	connect()	0	4	1
A	isConnected()	0	4	1
A	__call()	0	9	3
B	select()	0	20	5
C	info()	0	69	11
A	get()	9	9	3
A	del()	0	5	1
A	delete()	0	4	1
A	scan()	10	10	2
A	hget()	9	9	3
A	hdel()	0	9	2
A	hscan()	10	10	2
A	zscan()	10	10	2
A	sscan()	10	10	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like RedisProxy often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use RedisProxy, and based on these observations, apply Extract Interface, too.

<?php

namespace RedisProxy;

use Exception;
use InvalidArgumentException;
use Predis\Client;
use Predis\Response\Status;
use Redis;

/**
 * @method boolean set(string $key, string $value) Set the string value of a key
 * @method array mget(array $keys) Multi get - Returns the values of all specified keys. For every key that does not hold a string value or does not exist, FALSE is returned.
 * @method integer hset(string $key, string $field, string $value) Set the string value of a hash field
 * @method array hgetall(string $key) Get all fields and values in hash
 * @method array hGetAll(string $key) Get all fields and values in hash
 * @method integer hlen(string $key) Get the number of fields in hash
 * @method integer hLen(string $key) Get the number of fields in hash
 * @method boolean flushall() Remove all keys from all databases
 * @method boolean flushAll() Remove all keys from all databases
 * @method boolean flushdb() Remove all keys from the current database
 * @method boolean flushDb() Remove all keys from the current database
 */
class RedisProxy
{
    const DRIVER_REDIS = 'redis';

    const DRIVER_PREDIS = 'predis';

    private $driver;

    private $host;

    private $port;

    private $database = 0;

    private $timeout;

    private $supportedDrivers = [
        self::DRIVER_REDIS,
        self::DRIVER_PREDIS,
    ];

    private $driversOrder = [];

    public function __construct($host, $port, $timeout = null)
    {
        $this->host = $host;
        $this->port = $port;
        $this->timeout = $timeout;
        $this->driversOrder = $this->supportedDrivers;
    }

    public function setDriversOrder(array $driversOrder)
    {
        if (empty($driversOrder)) {
            throw new InvalidArgumentException('You need to set at least one driver');
        }
        foreach ($driversOrder as $driver) {
            if (!in_array($driver, $this->supportedDrivers)) {
                throw new InvalidArgumentException('Driver "' . $driver . '" is not supported');
            }
        }
        $this->driversOrder = $driversOrder;
        return $this;
    }

    private function init()
    {
        $this->prepareDriver();
        $this->select($this->database);
    }

    private function prepareDriver()
    {
        if ($this->driver !== null) {
            return;
        }

        foreach ($this->driversOrder as $preferredDriver) {
            if ($preferredDriver === self::DRIVER_REDIS && extension_loaded('redis')) {
                $this->driver = new Redis();
                return;
            }
            if ($preferredDriver === self::DRIVER_PREDIS && class_exists('Predis\Client')) {
                $this->driver = new Client();
                return;
            }
        }
        throw new RedisProxyException('No redis library loaded (ext-redis or predis)');
    }

    private function connect($host, $port, $timeout = null)
    {
        return $this->driver->connect($host, $port, $timeout);

    }

    private function isConnected()
    {
        return $this->driver->isConnected();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function __call($name, $arguments)
    {
        $this->init();
        $result = call_user_func_array([$this->driver, $name], $arguments);
        if ($this->driver instanceof Client && $result instanceof Status) {
            $result = $result->getPayload() === 'OK';
        }
        return $result;
    }

    /**
     * @param integer $database
     * @return boolean true on success
     * @throws RedisProxyException on failure
     */
    public function select($database)
    {
        $this->prepareDriver();
        if (!$this->isConnected()) {
            $this->connect($this->host, $this->port, $this->timeout);
        }
        try {
            $result = $this->driver->select($database);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        } catch (Exception $e) {
            throw new RedisProxyException('Invalid DB index');
        }
        if ($this->driver instanceof Client) {
            $result = $result->getPayload() === 'OK';
        }
        if ($result === false) {
            throw new RedisProxyException('Invalid DB index');
        }
        $this->database = $database;
        return $result;
    }

    /**
     * @param string|null $section
     * @return array
     * @todo need refactoring
     */
    public function info($section = null)
    {
        $this->init();
        if ($section === null) {
            $result = $this->driver->info();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        } else {
            $section = strtolower($section);
            $result = $this->driver->info($section);
        }

        $groupedResult = [];
        $groupedResult['keyspace'] = [];
        for ($db = 0; $db < $this->config('get', 'databases')['databases']; ++$db) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $groupedResult['keyspace']["db$db"] = [
                'keys' => 0,
                'expires' => null,
                'avg_ttl' => null,
            ];
        }
        if ($this->driver instanceof Client) {
            $result = array_change_key_case($result, CASE_LOWER);
            $groupedResult['keyspace'] = array_merge($groupedResult['keyspace'], $result['keyspace']);
            unset($result['keyspace']);
            $groupedResult = array_merge($groupedResult, $result);
        } else {
            $keyStartToSectionMap = [
                'redis_' => 'server',
                'uptime_' => 'server',
                'client_' => 'clients',
                'used_memory' => 'memory',
                'mem_' => 'memory',
                'rdb_' => 'persistence',
                'aof_' => 'persistence',
                'total_' => 'stats',
                'keyspace_' => 'stats',
                'repl_backlog_' => 'replication',
                'used_cpu_' => 'cpu',
                'db' => 'keyspace',
            ];
            $keyToSectionMap = [
                'connected_clients' => 'clients',
            ];
            foreach ($result as $key => $value) {
                foreach ($keyStartToSectionMap as $keyStart => $targetSection) {
                    if (strpos($key, $keyStart) === 0) {
                        if ($keyStart === 'db') {
                            $dbKeyspace = explode(',', $value);
                            $info['keys'] = explode('=', $dbKeyspace[0])[1];
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                            $info['expires'] = explode('=', $dbKeyspace[1])[1];
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                            $info['avg_ttl'] = explode('=', $dbKeyspace[2])[1];
                            $value = $info;
                        }
                        $groupedResult[$targetSection][$key] = $value;
                        continue;
                    }
                }
                if (isset($keyToSectionMap[$key])) {
                    $groupedResult[$keyToSectionMap[$key]][$key] = $value;
                }
            }
        }

        if ($section !== null) {
            if (isset($groupedResult[$section])) {
                return $groupedResult[$section];
            }
        }
        return $groupedResult;
    }

    /**
     * @param string $key
     * @return string
     */
    public function get($key)

    {
        $this->init();
        $result = $this->driver->get($key);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        if ($this->driver instanceof Client) {
            $result = $result === null ? false : $result;
        }
        return $result;
    }

    public function del(...$key)
    {
        $this->init();
        return $this->driver->del(...$key);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function delete(...$key)
    {
        return $this->del(...$key);
    }

    public function scan(&$iterator, $pattern = null, $count = null)

    {
        $this->init();
        if ($this->driver instanceof Client) {
            $returned = $this->driver->scan($iterator, ['match' => $pattern, 'count' => $count]);
            $iterator = $returned[0];
            return $returned[1];
        }
        return $this->driver->scan($iterator, $pattern, $count);
    }

    /**
     * Get the value of a hash field
     * @param string $key
     * @param string $field
     * @return string|boolean false if hash field is not set
     */
    public function hget($key, $field)

    {
        $this->init();
        $result = $this->driver->hget($key, $field);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        if ($this->driver instanceof Client) {
            $result = $result === null ? false : $result;
        }
        return $result;
    }

    /**
     * Delete one or more hash fields, returns number of deleted fields
     * @param string $key
     * @param array $fields
     * @return integer
     */
    public function hdel($key, ...$fields)
    {
        if (is_array($fields[0])) {
            $fields = $fields[0];
        }
        $res = $this->driver->hdel($key, ...$fields);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        return $res;
    }

    public function hscan($key, &$iterator, $pattern = null, $count = null)

    {
        $this->init();
        if ($this->driver instanceof Client) {
            $returned = $this->driver->hscan($key, $iterator, ['match' => $pattern, 'count' => $count]);
            $iterator = $returned[0];
            return $returned[1];
        }
        return $this->driver->hscan($key, $iterator, $pattern, $count);
    }

    public function zscan($key, &$iterator, $pattern = null, $count = null)

    {
        $this->init();
        if ($this->driver instanceof Client) {
            $returned = $this->driver->zscan($key, $iterator, ['match' => $pattern, 'count' => $count]);
            $iterator = $returned[0];
            return $returned[1];
        }
        return $this->driver->zscan($key, $iterator, $pattern, $count);
    }

    public function sscan($key, &$iterator, $pattern = null, $count = null)

    {
        $this->init();
        if ($this->driver instanceof Client) {
            $returned = $this->driver->sscan($key, $iterator, ['match' => $pattern, 'count' => $count]);
            $iterator = $returned[0];
            return $returned[1];
        }
        return $this->driver->sscan($key, $iterator, $pattern, $count);
    }
}


Pull Request — master (#1)

RedisProxy B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

18 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

lulco / redis-proxy

Pull Request — master (#1)

RedisProxy B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

18 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like