UniMan\Drivers\Redis\DataManager\RedisHashDataManager

Complexity

Total Complexity

23

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	itemsCount()	0	41	10
C	items()	0	53	12

<?php

namespace UniMan\Drivers\Redis\DataManager;

use RedisProxy\RedisProxy;
use UniMan\Core\Utils\Filter;

class RedisHashDataManager
{
    private $connection;

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

    public function itemsCount(string $table, array $filter): int
    {
        if (!$filter) {

The expression $filter of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this->connection->hlen($table);
        }

        $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) {

The expression $res of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                    $item = [
                        'key' => $filterParts['key'][Filter::OPERATOR_EQUAL],
                        'length' => strlen($res),
                        'value' => $res,
                    ];
                    if (Filter::apply($item, $filter)) {
                        $totalItems++;
                    }
                }
                return $totalItems;
            }
        }
        $iterator = '';
        do {
            $pattern = null;
            $res = $this->connection->hscan($table, $iterator, $pattern, 1000);
            $res = $res ?: [];
            foreach ($res as $key => $value) {

The expression $res of type array|boolean is not guaranteed to be traversable. How about adding an additional type check?

                $item = [
                    'key' => $key,
                    'length' => strlen($value),
                    'value' => $value,
                ];
                if (Filter::apply($item, $filter)) {
                    $totalItems++;
                }
            }
        } while ($iterator !== 0);
        return $totalItems;
    }

    public function items(string $table, int $page, int $onPage, array $filter = []): array
    {
        $items = [];
        foreach ($filter as $filterParts) {
            if (!isset($filterParts['key'][Filter::OPERATOR_EQUAL])) {
                continue;
            }
            $res = $this->connection->hget($table, $filterParts['key'][Filter::OPERATOR_EQUAL]);
            if (!$res) {

The expression $res of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

                return $items;
            }
            $item = [
                'key' => $filterParts['key'][Filter::OPERATOR_EQUAL],
                'length' => strlen($res),
                'value' => $res,
            ];
            if (Filter::apply($item, $filter)) {
                $items[$item['key']] = $item;
            }
            return $items;
        }

        $skipped = 0;
        $offset = ($page - 1) * $onPage;
        $iterator = '';
        do {
            $pattern = null;
            $res = $this->connection->hscan($table, $iterator, $pattern, $onPage * 10);
            if (!$res) {
                return $items;
            }
            foreach ($res as $key => $value) {

The expression $res of type array|boolean is not guaranteed to be traversable. How about adding an additional type check?

                $item = [
                    'key' => $key,
                    'length' => strlen($value),
                    'value' => $value,
                ];
                if (!Filter::apply($item, $filter)) {
                    continue;
                }
                if ($skipped < $offset) {
                    $skipped++;
                    continue;
                }

                $items[$key] = $item;
                if (count($items) === $onPage) {
                    break;
                }
            }
        } while ($iterator !== 0 && count($items) < $onPage);
        return $items;
    }
}