RedisDataManager - Code Metrics - Inspection of "Redis database alias and display database name(s)..." - lulco/uniman - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e38c4...3f7c7b )

by Michal

created 2017-03-03 18:14 UTC

RedisDataManager D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	347
Duplicated Lines	11.24 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

1.59%

Importance

Changes

Metric	Value
wmc	80
lcom	1
cbo	5
dl	39
loc	347
ccs	4
cts	252
cp	0.0159
rs	4.8717
c	0
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	databases()	0	13	3
A	getDatabaseNameColumn()	0	4	1
B	tables()	0	39	6
D	itemsCount()	19	92	22
D	items()	20	102	28
A	deleteItem()	0	13	4
A	deleteTable()	0	4	1
A	selectDatabase()	0	4	1
A	execute()	0	19	2
B	headers()	0	16	6
B	getItems()	0	16	5
A	__construct()	0	5	1

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 RedisDataManager 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 RedisDataManager, and based on these observations, apply Extract Interface, too.

<?php

namespace UniMan\Drivers\Redis;

use RedisProxy\RedisProxy;
use UniMan\Core\DataManager\AbstractDataManager;
use UniMan\Core\Utils\Filter;
use UniMan\Core\Utils\Multisort;
use UniMan\Drivers\Redis\RedisDatabaseAliasStorage;

class RedisDataManager extends AbstractDataManager
{
    private $connection;

    private $databaseAliasStorage;

    private $itemsCountCache = false;

    public function __construct(RedisProxy $connection, RedisDatabaseAliasStorage $databaseAliasStorage)
    {
        $this->connection = $connection;
        $this->databaseAliasStorage = $databaseAliasStorage;
    }

    public function databases(array $sorting = [])
    {
        $keyspace = $this->connection->info('keyspace');
        $aliases = $this->databaseAliasStorage->loadAll();
        $databases = [];
        foreach ($keyspace as $db => $info) {
            $db = str_replace('db', '', $db);
            $alias = isset($aliases[$db]) ? ' (' . $aliases[$db] . ')' : '';
            $info['database'] = $db . $alias;
            $databases[$db] = $info;
        }
        return Multisort::sort($databases, $sorting);
    }

    protected function getDatabaseNameColumn()
    {
        return 'database';
    }

    public function tables(array $sorting = [])
    {
        $tables = [
            RedisDriver::TYPE_KEY => [
                'all' => [
                    'key' => 'Show all keys',
                ]
            ],
            RedisDriver::TYPE_HASH => [],
            RedisDriver::TYPE_SET => [],
        ];
        $commands = [
            'hLen' => RedisDriver::TYPE_HASH,
            'sCard' => RedisDriver::TYPE_SET,
        ];
        foreach ($this->connection->keys('*') as $key) {
            foreach ($commands as $command => $label) {
                $result = $this->connection->$command($key);
                if ($this->connection->getLastError() !== null) {
                    $this->connection->clearLastError();
                    continue;
                }
                $tables[$label][$key] = [
                    'key' => $key
                ];
                if ($label == RedisDriver::TYPE_HASH) {
                    $tables[$label][$key]['number_of_fields'] = $result;
                } elseif ($label == RedisDriver::TYPE_SET) {
                    $tables[$label][$key]['number_of_members'] = $result;
                }
                break;
            }
        }
        return [
            RedisDriver::TYPE_KEY => Multisort::sort($tables[RedisDriver::TYPE_KEY], $sorting),
            RedisDriver::TYPE_HASH => Multisort::sort($tables[RedisDriver::TYPE_HASH], $sorting),
            RedisDriver::TYPE_SET => Multisort::sort($tables[RedisDriver::TYPE_SET], $sorting),
        ];
    }

    public function itemsCount($type, $table, array $filter = [])
    {
        if ($this->itemsCountCache !== false) {
            return $this->itemsCountCache;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
        if ($type == RedisDriver::TYPE_HASH) {
            if (!$filter) {

                $this->itemsCountCache = $this->connection->hLen($table);
$answer = 42;

$correct = false;

$correct = (bool) $answer;
                return $this->itemsCountCache;
            } else {
                $totalItems = 0;
                foreach ($filter as $filterParts) {
                    if (isset($filterParts['key'][Filter::OPERATOR_EQUAL])) {
                        $res = $this->connection->hget($table, $filterParts['key'][Filter::OPERATOR_EQUAL]);
                        if ($res) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                            $item = [
                                'key' => $filterParts['key'][Filter::OPERATOR_EQUAL],
                                'length' => strlen($res),
                                'value' => $res,
                            ];
                            if (Filter::apply($item, $filter)) {
                                $totalItems++;
                            }
                        }
                        $this->itemsCountCache = $totalItems;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
                        return $this->itemsCountCache;
                    }
                }
                $iterator = '';
                do {
                    $pattern = null;
                    $res = $this->connection->hscan($table, $iterator, $pattern, 1000);
                    $res = $res ?: [];
                    foreach ($res as $key => $value) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                        $item = [
                            'key' => $key,
                            'length' => strlen($value),
                            'value' => $value,
                        ];
                        if (Filter::apply($item, $filter)) {
                            $totalItems++;
                        }
                    }
                } while ($iterator !== 0);
                $this->itemsCountCache = $totalItems;
                return $this->itemsCountCache;
            }
        }
        if ($type == RedisDriver::TYPE_KEY) {
            $totalItems = 0;
            foreach ($this->connection->keys('*') as $key) {
                $result = $this->connection->get($key);
                if ($this->connection->getLastError() !== null) {
                    $this->connection->clearLastError();
                    continue;
                }

                $item = [
                    'key' => $key,
                    'value' => $result,
                    'length' => strlen($result),
                ];

                if (Filter::apply($item, $filter)) {
                    $totalItems++;
                }
            }
            return $totalItems;
        }
        if ($type == RedisDriver::TYPE_SET) {
            if (!$filter) {

                return $this->connection->scard($table);
            }
            $iterator = '';
            $totalItems = 0;
            do {
                $res = $this->connection->sscan($table, $iterator, null, 1000);
                $res = $res ?: [];
                foreach ($res as $member) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                    $item = [
                        'member' => $member,
                        'length' => strlen($member),
                    ];
                    if (Filter::apply($item, $filter)) {
                        $totalItems++;
                    }
                }
            } while ($iterator !== 0);
            return $totalItems;
        }
        return 0;
    }

    public function items($type, $table, $page, $onPage, array $filter = [], array $sorting = [])
    {
        $items = [];
        $offset = ($page - 1) * $onPage;
        $skipped = 0;
        if ($type == RedisDriver::TYPE_HASH) {
            foreach ($filter as $filterParts) {
                if (isset($filterParts['key'][Filter::OPERATOR_EQUAL])) {
                    $items = [];
                    $res = $this->connection->hget($table, $filterParts['key'][Filter::OPERATOR_EQUAL]);
                    if ($res) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $item = [
                            'key' => $filterParts['key'][Filter::OPERATOR_EQUAL],
                            'length' => strlen($res),
                            'value' => $res,
                        ];
                        if (Filter::apply($item, $filter)) {
                            $items[$item['key']] = $item;
                        }
                    }
                    return $items;
                }
            }


            $iterator = '';
            do {
                $pattern = null;
                $res = $this->connection->hscan($table, $iterator, $pattern, $onPage * 10);
                $res = $res ?: [];
                foreach ($res as $key => $value) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                    $item = [
                        'key' => $key,
                        'length' => strlen($value),
                        'value' => $value,
                    ];
                    if (Filter::apply($item, $filter)) {

                        if ($skipped < $offset) {
                            $skipped++;
                        } else {
                            $items[$key] = $item;
                            if (count($items) === $onPage) {
                                break;
                            }
                        }
                    }
                }
            } while ($iterator !== 0 && count($items) < $onPage);
        } elseif ($type == RedisDriver::TYPE_KEY) {
            foreach ($this->connection->keys('*') as $key) {
                $result = $this->connection->get($key);
                if ($this->connection->getLastError() !== null) {
                    $this->connection->clearLastError();
                    continue;
                }

                $item = [
                    'key' => $key,
                    'value' => $result,
                    'length' => strlen($result),
                ];

                if (Filter::apply($item, $filter)) {

                    if ($skipped < $offset) {
                        $skipped++;
                    } else {
                        $items[$key] = $item;
                        if (count($items) === $onPage) {
                            break;
                        }
                    }
                }
            }
        } elseif ($type == RedisDriver::TYPE_SET) {
            $iterator = '';
            do {
                $pattern = null;
                $res = $this->connection->sscan($table, $iterator, $pattern, $onPage * 10);
                $res = $res ?: [];
                foreach ($res as $member) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                    $item = [
                        'member' => $member,
                        'length' => strlen($member),
                    ];
                    if (Filter::apply($item, $filter)) {
                        $items[$member] = $item;
                        if (count($items) === $onPage) {
                            break;
                        }
                    }
                }
            } while ($iterator !== 0 && count($items) < $onPage);
        }

        if ($this->itemsCount($type, $table, $filter) <= $onPage) {
            $items = Multisort::sort($items, $sorting);
        } elseif ($sorting) {

            $this->addMessage('Sorting has not been applied because the number of items is greater then the limit. Increase the limit or modify the filter.');
        }

        return $items;
    }

    public function deleteItem($type, $table, $item)
    {
        if ($type == RedisDriver::TYPE_HASH) {
            return $this->connection->hdel($table, $item);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
        if ($type == RedisDriver::TYPE_KEY) {
            return $this->connection->del($item);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
        if ($type == RedisDriver::TYPE_SET) {
            return $this->connection->srem($table, $item);
        }
        return parent::deleteItem($type, $table, $item);
    }

    public function deleteTable($type, $table)
    {
        return $this->connection->del($table);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    public function selectDatabase($database)
    {
        $this->connection->select($database);
    }

    public function execute($commands)
    {
        $listOfCommands = array_filter(array_map('trim', explode("\n", $commands)), function ($command) {
            return $command;
        });

        $results = [];
        foreach ($listOfCommands as $command) {
            $commandParts = explode(' ', $command);
            $function = array_shift($commandParts);
            $function = strtolower($function);
            $results[$command]['headers'] = $this->headers($function);
            $rows = call_user_func_array([$this->connection, $function], $commandParts);
            $items = $this->getItems($function, $rows);
            $results[$command]['items'] = $items;
            $results[$command]['count'] = count($items);
        }
        return $results;
    }

    private function headers($function)
    {
        if ($function === 'get' || $function === 'hget') {
            return ['value'];
        }
        if ($function === 'keys') {
            return ['key'];
        }
        if ($function === 'hgetall') {
            return ['key', 'value'];
        }
        if ($function === 'hlen') {
            return ['items_count'];
        }
        return [];
    }

    private function getItems($function, $rows)
    {
        $items = [];
        if ($function === 'keys') {
            foreach ($rows as $key) {
                $items[] = [$key];
            }
        } elseif ($function === 'hgetall') {
            foreach ($rows as $key => $value) {
                $items[] = [$key, $value];
            }
        } else {
            return [[$rows]];
        }
        return $items;
    }
}


1		<?php
2
3		namespace UniMan\Drivers\Redis;
4
5		use RedisProxy\RedisProxy;
6		use UniMan\Core\DataManager\AbstractDataManager;
7		use UniMan\Core\Utils\Filter;
8		use UniMan\Core\Utils\Multisort;
9		use UniMan\Drivers\Redis\RedisDatabaseAliasStorage;
10
11		class RedisDataManager extends AbstractDataManager
12		{
13		private $connection;
14
15		private $databaseAliasStorage;
16
17		private $itemsCountCache = false;
18
19	2	public function __construct(RedisProxy $connection, RedisDatabaseAliasStorage $databaseAliasStorage)
20		{
21	2	$this->connection = $connection;
22	2	$this->databaseAliasStorage = $databaseAliasStorage;
23	2	}
24
25		public function databases(array $sorting = [])
26		{
27		$keyspace = $this->connection->info('keyspace');
28		$aliases = $this->databaseAliasStorage->loadAll();
29		$databases = [];
30		foreach ($keyspace as $db => $info) {
31		$db = str_replace('db', '', $db);
32		$alias = isset($aliases[$db]) ? ' (' . $aliases[$db] . ')' : '';
33		$info['database'] = $db . $alias;
34		$databases[$db] = $info;
35		}
36		return Multisort::sort($databases, $sorting);
37		}
38
39		protected function getDatabaseNameColumn()
40		{

lulco / uniman