UniMan\Drivers\Redis\DataManager\RedisSetDataManager

Complexity

Total Complexity

15

Size/Duplication

Total Lines	69
Duplicated Lines	50.72 %

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()	9	24	6
B	items()	26	34	8

<?php

namespace UniMan\Drivers\Redis\DataManager;

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

class RedisSetDataManager
{
    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->scard($table);
        }
        $iterator = '';
        $totalItems = 0;
        do {
            $res = $this->connection->sscan($table, $iterator, null, 1000);
            if (!$res) {
                return $totalItems;
            }
            foreach ($res as $member) {

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

This code seems to be duplicated across your project.

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

    public function items(string $table, int $page, int $onPage, array $filter = []): array
    {
        $skipped = 0;
        $offset = ($page - 1) * $onPage;
        $items = [];
        $iterator = '';
        do {

This code seems to be duplicated across your project.

            $pattern = null;
            $res = $this->connection->sscan($table, $iterator, $pattern, $onPage * 10);
            if (!$res) {
                return $items;
            }
            foreach ($res as $member) {

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

                $item = [
                    'member' => $member,
                    'length' => strlen($member),
                ];
                if (!Filter::apply($item, $filter)) {
                    continue;
                }

                if ($skipped < $offset) {
                    $skipped++;
                    continue;
                }

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