Yiisoft\Data\Reader\Iterable\IterableDataReader

Complexity

Total Complexity

31

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Test Coverage

Coverage

95.6%

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	withSort()	0	5	1
A	getSort()	0	3	1
A	__construct()	0	15	1
A	withFilter()	0	5	1
A	readOne()	0	3	1
A	withLimit()	0	8	2
A	count()	0	3	1
A	withOffset()	0	5	1
A	getIterator()	0	3	1
A	matchFilter()	0	11	2
A	withFilterProcessors()	0	12	3
A	iterableToArray()	0	3	2
A	sortItems()	0	19	5
B	read()	0	33	9

<?php

declare(strict_types=1);

namespace Yiisoft\Data\Reader\Iterable;

use Generator;
use Traversable;
use Yiisoft\Arrays\ArrayHelper;
use Yiisoft\Data\Reader\DataReaderInterface;
use Yiisoft\Data\Reader\Filter\FilterInterface;
use Yiisoft\Data\Reader\Filter\FilterProcessorInterface;
use Yiisoft\Data\Reader\Iterable\Processor\All;
use Yiisoft\Data\Reader\Iterable\Processor\Any;
use Yiisoft\Data\Reader\Iterable\Processor\Equals;
use Yiisoft\Data\Reader\Iterable\Processor\GreaterThan;
use Yiisoft\Data\Reader\Iterable\Processor\GreaterThanOrEqual;
use Yiisoft\Data\Reader\Iterable\Processor\In;
use Yiisoft\Data\Reader\Iterable\Processor\IterableProcessorInterface;
use Yiisoft\Data\Reader\Iterable\Processor\LessThan;
use Yiisoft\Data\Reader\Iterable\Processor\LessThanOrEqual;
use Yiisoft\Data\Reader\Iterable\Processor\Like;
use Yiisoft\Data\Reader\Iterable\Processor\Not;
use Yiisoft\Data\Reader\Sort;

/**
 * @template TKey as array-key
 * @template TValue
 *
 * @implements DataReaderInterface<TKey, TValue>
 */
class IterableDataReader implements DataReaderInterface
{
    /**
     * @psalm-var iterable<TKey, TValue>
     */
    protected iterable $data;
    private ?Sort $sort = null;
    private ?FilterInterface $filter = null;
    private int $limit = 0;
    private int $offset = 0;

    private array $filterProcessors = [];

    /**
     * psalm-param iterable<TKey, TValue> $data
     */
    public function __construct(iterable $data)
    {
        $this->data = $data;
        $this->filterProcessors = $this->withFilterProcessors(
            new All(),
            new Any(),
            new Equals(),
            new GreaterThan(),
            new GreaterThanOrEqual(),
            new In(),
            new LessThan(),
            new LessThanOrEqual(),
            new Like(),
            new Not()
        )->filterProcessors;
    }

    /**
     * @psalm-mutation-free
     */
    public function withSort(?Sort $sort): self
    {
        $new = clone $this;
        $new->sort = $sort;
        return $new;
    }

    public function getSort(): ?Sort
    {
        return $this->sort;
    }

    /**
     * Sorts data items according to the given sort definition.
     *
     * @param iterable $items the items to be sorted
     * @param Sort $sort the sort definition
     *
     * @return iterable the sorted items
     */
    private function sortItems(iterable $items, Sort $sort): iterable
    {
        $criteria = $sort->getCriteria();
        if ($criteria !== []) {
            $items = $this->iterableToArray($items);
            uasort($items, static function ($itemA, $itemB) use ($criteria) {
                foreach ($criteria as $key => $order) {
                    $valueA = ArrayHelper::getValue($itemA, $key);
                    $valueB = ArrayHelper::getValue($itemB, $key);
                    if ($valueB === $valueA) {
                        continue;
                    }
                    return ($valueA > $valueB xor $order === SORT_DESC) ? 1 : -1;
                }
                return 0;
            });
        }

        return $items;
    }

    protected function matchFilter(array $item, array $filter): bool
    {
        $operation = array_shift($filter);
        $arguments = $filter;

        $processor = $this->filterProcessors[$operation] ?? null;
        if ($processor === null) {
            throw new \RuntimeException(sprintf('Operation "%s" is not supported', $operation));
        }
        /* @var $processor IterableProcessorInterface */
        return $processor->match($item, $arguments, $this->filterProcessors);
    }

    /**
     * @psalm-mutation-free
     */
    public function withFilter(?FilterInterface $filter): self
    {
        $new = clone $this;
        $new->filter = $filter;
        return $new;
    }

    /**
     * @psalm-mutation-free
     */
    public function withLimit(int $limit): self
    {
        if ($limit < 0) {
            throw new \InvalidArgumentException('$limit must not be less than 0.');
        }
        $new = clone $this;
        $new->limit = $limit;
        return $new;
    }

    public function read(): array
    {
        $filter = null;
        if ($this->filter !== null) {
            $filter = $this->filter->toArray();
        }

        $data = [];
        $skipped = 0;

        $sortedData = $this->sort === null
            ? $this->data
            : $this->sortItems($this->data, $this->sort);

        foreach ($sortedData as $key => $item) {
            // do not return more than limit items
            if ($this->limit > 0 && count($data) === $this->limit) {
                break;
            }

            // skip offset items
            if ($skipped < $this->offset) {
                ++$skipped;
                continue;
            }

            // filter items
            if ($filter === null || $this->matchFilter($item, $filter)) {
                $data[$key] = $item;
            }
        }

        return $data;
    }

    public function readOne()
    {
        return $this->withLimit(1)->getIterator()->current();
    }

    /**
     * @psalm-return Generator<TValue>
     */
    public function getIterator(): Generator
    {
        yield from $this->read();
    }

    /**
     * @psalm-mutation-free
     */
    public function withOffset(int $offset): self
    {
        $new = clone $this;
        $new->offset = $offset;
        return $new;
    }

    public function count(): int
    {
        return count($this->read());
    }

    private function iterableToArray(iterable $iterable): array
    {
        return $iterable instanceof Traversable ? iterator_to_array($iterable, true) : (array)$iterable;
    }

    /**
     * @psalm-mutation-free
     */
    public function withFilterProcessors(FilterProcessorInterface ...$filterProcessors): self
    {
        $new = clone $this;
        $processors = [];
        foreach ($filterProcessors as $filterProcessor) {
            if ($filterProcessor instanceof IterableProcessorInterface) {
                /** @psalm-suppress ImpureMethodCall */
                $processors[$filterProcessor->getOperator()] = $filterProcessor;
            }
        }
        $new->filterProcessors = array_merge($this->filterProcessors, $processors);
        return $new;
    }
}