RedisDataManager::itemsCount() - Code Metrics - Inspection of "Rename adminerng to uniman in all namespaces, sett..." - lulco/uniman - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#21)

by Michal
created 2017-03-01 18:06 UTC
RedisDataManager::itemsCount() D

↳ Parent: RedisDataManager
Complexity

Conditions	22
Paths	29
Size

Total Lines	92
Code Lines	67
Duplication

Lines	19
Ratio	20.65 %
Code Coverage

Tests	0
CRAP Score	506
Importance

Changes
Metric	Value
dl	19
loc	92
ccs	0
cts	73
cp	0
rs	4.6625
c	0
b	0
f	0
cc	22
eloc	67
nc	29
nop	3
crap	506
How to fix Long Method Complexity

<?php

namespace UniMan\Drivers\Redis;

use UniMan\Core\DataManager\AbstractDataManager;
use UniMan\Core\Utils\Multisort;
use UniMan\Core\Utils\Filter;
use RedisProxy\RedisProxy;

class RedisDataManager extends AbstractDataManager
{
    private $connection;

    private $itemsCountCache = false;

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

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

    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 UniMan\Core\DataManager\AbstractDataManager;
6		use UniMan\Core\Utils\Multisort;
7		use UniMan\Core\Utils\Filter;
8		use RedisProxy\RedisProxy;
9
10		class RedisDataManager extends AbstractDataManager
11		{
12		private $connection;
13
14		private $itemsCountCache = false;
15
16	2	public function __construct(RedisProxy $connection)
17		{
18	2	$this->connection = $connection;
19	2	}
20
21		public function databases(array $sorting = [])
22		{
23		$keyspace = $this->connection->info('keyspace');
24		$databases = [];
25		foreach ($keyspace as $db => $info) {
26		$db = str_replace('db', '', $db);
27		$info['database'] = $db;
28		$databases[$db] = $info;
29		}
30		return Multisort::sort($databases, $sorting);
31		}
32
33		public function tables(array $sorting = [])
34		{
35		$tables = [
36		RedisDriver::TYPE_KEY => [
37		'all' => [
38		'key' => 'Show all keys',
39		]
40		],
lulco / uniman

Pull Request — master (#21)

RedisDataManager::itemsCount() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
