IterableDataReader::count() - Code Metrics - Inspection of "Refactoring + More tests (#134)" - yiisoft/data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6c8383...fe7e74 )

by Alexander

created 2023-01-14 19:01 UTC

IterableDataReader::count() A

↳ Parent: IterableDataReader

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Yiisoft\Data\Reader\Iterable;

use Generator;
use InvalidArgumentException;
use RuntimeException;
use Traversable;
use Yiisoft\Arrays\ArrayHelper;
use Yiisoft\Data\Reader\DataReaderException;
use Yiisoft\Data\Reader\DataReaderInterface;
use Yiisoft\Data\Reader\FilterHandlerInterface;
use Yiisoft\Data\Reader\FilterInterface;
use Yiisoft\Data\Reader\Iterable\FilterHandler\AllHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\AnyHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\BetweenHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsEmptyHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsNullHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\GreaterThanHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\GreaterThanOrEqualHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\InHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\LessThanHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\LessThanOrEqualHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\LikeHandler;
use Yiisoft\Data\Reader\Iterable\FilterHandler\NotHandler;
use Yiisoft\Data\Reader\Sort;

use function array_merge;
use function array_shift;
use function count;
use function is_string;
use function iterator_to_array;
use function sprintf;
use function uasort;

/**
 * Iterable data reader takes an iterable data as a source and can:
 *
 * - Limit items read
 * - Skip N items from the beginning
 * - Sort items
 * - Form a filter criteria with {@see FilterInterface}
 * - Post-filter items with {@see IterableFilterHandlerInterface}
 *
 * @template TKey as array-key
 * @template TValue as array|object
 *
 * @implements DataReaderInterface<TKey, TValue>
 */
final class IterableDataReader implements DataReaderInterface
{
    private ?Sort $sort = null;
    private ?FilterInterface $filter = null;
    private int $limit = 0;
    private int $offset = 0;

    /**
     * @psalm-var array<string, IterableFilterHandlerInterface>
     */
    private array $iterableFilterHandlers = [];

    /**
     * @param iterable $data Data to iterate.
     * @psalm-param iterable<TKey, TValue> $data
     */
    public function __construct(private iterable $data)
    {
        $this->iterableFilterHandlers = $this->prepareFilterHandlers([
            new AllHandler(),
            new AnyHandler(),
            new BetweenHandler(),
            new EqualsHandler(),
            new EqualsEmptyHandler(),
            new EqualsNullHandler(),
            new GreaterThanHandler(),
            new GreaterThanOrEqualHandler(),
            new InHandler(),
            new LessThanHandler(),
            new LessThanOrEqualHandler(),
            new LikeHandler(),
            new NotHandler(),
        ]);
    }

    /**
     * @psalm-return $this
     */
    public function withFilterHandlers(FilterHandlerInterface ...$iterableFilterHandlers): static
    {
        $new = clone $this;
        $new->iterableFilterHandlers = array_merge(
            $this->iterableFilterHandlers,
            $this->prepareFilterHandlers($iterableFilterHandlers)
        );
        return $new;
    }

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

    /**
     * @psalm-return $this
     */
    public function withLimit(int $limit): static
    {
        if ($limit < 0) {
            throw new InvalidArgumentException('The limit must not be less than 0.');
        }

        $new = clone $this;
        $new->limit = $limit;
        return $new;
    }

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

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

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

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

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

    /**
     * @psalm-return array<TKey, TValue>
     */
    public function read(): array
    {
        $data = [];
        $skipped = 0;
        $filter = $this->filter?->toCriteriaArray();
        $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) {
                /** @infection-ignore-all Here continue === break */
                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(): array|object|null
    {
        /** @infection-ignore-all Any value more one in `withLimit()` will be ignored because returned `current()` */
        return $this
            ->withLimit(1)
            ->getIterator()
            ->current();
    }

    /**
     * Return whether an item matches iterable filter.
     *
     * @param array|object $item Item to check.
     * @param array $filter Filter.
     *
     * @return bool Whether an item matches iterable filter.
     */
    private function matchFilter(array|object $item, array $filter): bool
    {
        $operation = array_shift($filter);
        $arguments = $filter;

        if (!is_string($operation)) {
            throw new RuntimeException(
                sprintf(
                    'The operator should be string. The %s is received.',
                    get_debug_type($operation),
                )
            );
        }

        if ($operation === '') {
            throw new RuntimeException('The operator string cannot be empty.');
        }

        $processor = $this->iterableFilterHandlers[$operation] ?? null;

        if ($processor === null) {
            throw new RuntimeException(sprintf('Operation "%s" is not supported.', $operation));
        }

        return $processor->match($item, $arguments, $this->iterableFilterHandlers);
    }

    /**
     * Sorts data items according to the given sort definition.
     *
     * @param iterable $items The items to be sorted.
     * @param Sort $sort The sort definition.
     *
     * @return array The sorted items.
     *
     * @psalm-param iterable<TKey, TValue> $items
     * @psalm-return iterable<TKey, TValue>
     */
    private function sortItems(iterable $items, Sort $sort): iterable
    {
        $criteria = $sort->getCriteria();

        if ($criteria !== []) {
            $items = $this->iterableToArray($items);
            /** @infection-ignore-all */
            uasort(
                $items,
                static function (array|object $itemA, array|object $itemB) use ($criteria) {
                    foreach ($criteria as $key => $order) {
                        /** @psalm-var mixed $valueA */
                        $valueA = ArrayHelper::getValue($itemA, $key);
                        /** @psalm-var mixed $valueB */
                        $valueB = ArrayHelper::getValue($itemB, $key);

                        if ($valueB === $valueA) {
                            continue;
                        }

                        return ($valueA > $valueB xor $order === SORT_DESC) ? 1 : -1;
                    }

                    return 0;
                }
            );
        }

        return $items;
    }

    /**
     * @param FilterHandlerInterface[] $filterHandlers
     *
     * @return IterableFilterHandlerInterface[]
     * @psalm-return array<string, IterableFilterHandlerInterface>
     */
    private function prepareFilterHandlers(array $filterHandlers): array
    {
        $result = [];

        foreach ($filterHandlers as $filterHandler) {
            if (!$filterHandler instanceof IterableFilterHandlerInterface) {
                throw new DataReaderException(
                    sprintf(
                        '%s::withFilterHandlers() accepts instances of %s only.',
                        static::class,
                        IterableFilterHandlerInterface::class
                    )
                );
            }
            $result[$filterHandler->getOperator()] = $filterHandler;
        }

        return $result;
    }

    /**
     * Convert iterable to array.
     *
     * @param iterable $iterable Iterable to convert.
     *
     * @psalm-param iterable<TKey, TValue> $iterable
     *
     * @return array Resulting array.
     * @psalm-return array<TKey, TValue>
     */
    private function iterableToArray(iterable $iterable): array
    {
        return $iterable instanceof Traversable ? iterator_to_array($iterable, true) : $iterable;

    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Data\Reader\Iterable;
6
7		use Generator;
8		use InvalidArgumentException;
9		use RuntimeException;
10		use Traversable;
11		use Yiisoft\Arrays\ArrayHelper;
12		use Yiisoft\Data\Reader\DataReaderException;
13		use Yiisoft\Data\Reader\DataReaderInterface;
14		use Yiisoft\Data\Reader\FilterHandlerInterface;
15		use Yiisoft\Data\Reader\FilterInterface;
16		use Yiisoft\Data\Reader\Iterable\FilterHandler\AllHandler;
17		use Yiisoft\Data\Reader\Iterable\FilterHandler\AnyHandler;
18		use Yiisoft\Data\Reader\Iterable\FilterHandler\BetweenHandler;
19		use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsHandler;
20		use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsEmptyHandler;
21		use Yiisoft\Data\Reader\Iterable\FilterHandler\EqualsNullHandler;
22		use Yiisoft\Data\Reader\Iterable\FilterHandler\GreaterThanHandler;
23		use Yiisoft\Data\Reader\Iterable\FilterHandler\GreaterThanOrEqualHandler;
24		use Yiisoft\Data\Reader\Iterable\FilterHandler\InHandler;
25		use Yiisoft\Data\Reader\Iterable\FilterHandler\LessThanHandler;
26		use Yiisoft\Data\Reader\Iterable\FilterHandler\LessThanOrEqualHandler;
27		use Yiisoft\Data\Reader\Iterable\FilterHandler\LikeHandler;
28		use Yiisoft\Data\Reader\Iterable\FilterHandler\NotHandler;
29		use Yiisoft\Data\Reader\Sort;
30
31		use function array_merge;
32		use function array_shift;
33		use function count;
34		use function is_string;
35		use function iterator_to_array;
36		use function sprintf;
37		use function uasort;
38
39		/**
40		* Iterable data reader takes an iterable data as a source and can:
41		*
42		* - Limit items read
43		* - Skip N items from the beginning
44		* - Sort items
45		* - Form a filter criteria with {@see FilterInterface}
46		* - Post-filter items with {@see IterableFilterHandlerInterface}
47		*
48		* @template TKey as array-key
49		* @template TValue as array\|object
50		*
51		* @implements DataReaderInterface<TKey, TValue>
52		*/
53		final class IterableDataReader implements DataReaderInterface
54		{
55		private ?Sort $sort = null;
56		private ?FilterInterface $filter = null;
57		private int $limit = 0;
58		private int $offset = 0;
59
60		/**
61		* @psalm-var array<string, IterableFilterHandlerInterface>
62		*/
63		private array $iterableFilterHandlers = [];
64
65		/**
66		* @param iterable $data Data to iterate.
67		* @psalm-param iterable<TKey, TValue> $data
68		*/
69	110	public function __construct(private iterable $data)
70		{
71	110	$this->iterableFilterHandlers = $this->prepareFilterHandlers([
72	110	new AllHandler(),
73	110	new AnyHandler(),
74	110	new BetweenHandler(),
75	110	new EqualsHandler(),
76	110	new EqualsEmptyHandler(),
77	110	new EqualsNullHandler(),
78	110	new GreaterThanHandler(),
79	110	new GreaterThanOrEqualHandler(),
80	110	new InHandler(),
81	110	new LessThanHandler(),
82	110	new LessThanOrEqualHandler(),
83	110	new LikeHandler(),
84	110	new NotHandler(),
85	110	]);
86		}
87
88		/**
89		* @psalm-return $this
90		*/
91	4	public function withFilterHandlers(FilterHandlerInterface ...$iterableFilterHandlers): static
92		{
93	4	$new = clone $this;
94	4	$new->iterableFilterHandlers = array_merge(
95	4	$this->iterableFilterHandlers,
96	4	$this->prepareFilterHandlers($iterableFilterHandlers)
97	4	);
98	3	return $new;
99		}
100
101		/**
102		* @psalm-return $this
103		*/
104	39	public function withFilter(?FilterInterface $filter): static
105		{
106	39	$new = clone $this;
107	39	$new->filter = $filter;
108	39	return $new;
109		}
110
111		/**
112		* @psalm-return $this
113		*/
114	44	public function withLimit(int $limit): static
115		{
116	44	if ($limit < 0) {
117	1	throw new InvalidArgumentException('The limit must not be less than 0.');
118		}
119
120	43	$new = clone $this;
121	43	$new->limit = $limit;
122	43	return $new;
123		}
124
125		/**
126		* @psalm-return $this
127		*/
128	7	public function withOffset(int $offset): static
129		{
130	7	$new = clone $this;
131	7	$new->offset = $offset;
132	7	return $new;
133		}
134
135		/**
136		* @psalm-return $this
137		*/
138	49	public function withSort(?Sort $sort): static
139		{
140	49	$new = clone $this;
141	49	$new->sort = $sort;
142	49	return $new;
143		}
144
145		/**
146		* @psalm-return Generator<array-key, TValue, mixed, void>
147		*/
148	14	public function getIterator(): Generator
149		{
150	14	yield from $this->read();
151		}
152
153	41	public function getSort(): ?Sort
154		{
155	41	return $this->sort;
156		}
157
158	21	public function count(): int
159		{
160	21	return count($this->read());
161		}
162
163		/**
164		* @psalm-return array<TKey, TValue>
165		*/
166	91	public function read(): array
167		{
168	91	$data = [];
169	91	$skipped = 0;
170	91	$filter = $this->filter?->toCriteriaArray();
171	91	$sortedData = $this->sort === null ? $this->data : $this->sortItems($this->data, $this->sort);
172
173	91	foreach ($sortedData as $key => $item) {
174		// Do not return more than limit items.
175	86	if ($this->limit > 0 && count($data) === $this->limit) {
176		/** @infection-ignore-all Here continue === break */
177	20	break;
178		}
179
180		// Skip offset items.
181	86	if ($skipped < $this->offset) {
182	4	++$skipped;
183	4	continue;
184		}
185
186		// Filter items.
187	86	if ($filter === null \|\| $this->matchFilter($item, $filter)) {
188	76	$data[$key] = $item;
189		}
190		}
191
192	81	return $data;
193		}
194
195	14	public function readOne(): array\|object\|null
196		{
197		/** @infection-ignore-all Any value more one in `withLimit()` will be ignored because returned `current()` */
198	14	return $this
199	14	->withLimit(1)
200	14	->getIterator()
201	14	->current();
202		}
203
204		/**
205		* Return whether an item matches iterable filter.
206		*
207		* @param array\|object $item Item to check.
208		* @param array $filter Filter.
209		*
210		* @return bool Whether an item matches iterable filter.
211		*/
212	37	private function matchFilter(array\|object $item, array $filter): bool
213		{
214	37	$operation = array_shift($filter);
215	37	$arguments = $filter;
216
217	37	if (!is_string($operation)) {
218	8	throw new RuntimeException(
219	8	sprintf(
220	8	'The operator should be string. The %s is received.',
221	8	get_debug_type($operation),
222	8	)
223	8	);
224		}
225
226	29	if ($operation === '') {
227	1	throw new RuntimeException('The operator string cannot be empty.');
228		}
229
230	28	$processor = $this->iterableFilterHandlers[$operation] ?? null;
231
232	28	if ($processor === null) {
233	1	throw new RuntimeException(sprintf('Operation "%s" is not supported.', $operation));
234		}
235
236	27	return $processor->match($item, $arguments, $this->iterableFilterHandlers);
237		}
238
239		/**
240		* Sorts data items according to the given sort definition.
241		*
242		* @param iterable $items The items to be sorted.
243		* @param Sort $sort The sort definition.
244		*
245		* @return array The sorted items.
246		*
247		* @psalm-param iterable<TKey, TValue> $items
248		* @psalm-return iterable<TKey, TValue>
249		*/
250	41	private function sortItems(iterable $items, Sort $sort): iterable
251		{
252	41	$criteria = $sort->getCriteria();
253
254	41	if ($criteria !== []) {
255	41	$items = $this->iterableToArray($items);
256		/** @infection-ignore-all */
257	41	uasort(
258	41	$items,
259	41	static function (array\|object $itemA, array\|object $itemB) use ($criteria) {
260	33	foreach ($criteria as $key => $order) {
261		/** @psalm-var mixed $valueA */
262	33	$valueA = ArrayHelper::getValue($itemA, $key);
263		/** @psalm-var mixed $valueB */
264	33	$valueB = ArrayHelper::getValue($itemB, $key);
265
266	33	if ($valueB === $valueA) {
267	2	continue;
268		}
269
270	33	return ($valueA > $valueB xor $order === SORT_DESC) ? 1 : -1;
271		}
272
273	1	return 0;
274	41	}
275	41	);
276		}
277
278	41	return $items;
279		}
280
281		/**
282		* @param FilterHandlerInterface[] $filterHandlers
283		*
284		* @return IterableFilterHandlerInterface[]
285		* @psalm-return array<string, IterableFilterHandlerInterface>
286		*/
287	110	private function prepareFilterHandlers(array $filterHandlers): array
288		{
289	110	$result = [];
290
291	110	foreach ($filterHandlers as $filterHandler) {
292	110	if (!$filterHandler instanceof IterableFilterHandlerInterface) {
293	1	throw new DataReaderException(
294	1	sprintf(
295	1	'%s::withFilterHandlers() accepts instances of %s only.',
296	1	static::class,
297	1	IterableFilterHandlerInterface::class
298	1	)
299	1	);
300		}
301	110	$result[$filterHandler->getOperator()] = $filterHandler;
302		}
303
304	110	return $result;
305		}
306
307		/**
308		* Convert iterable to array.
309		*
310		* @param iterable $iterable Iterable to convert.
311		*
312		* @psalm-param iterable<TKey, TValue> $iterable
313		*
314		* @return array Resulting array.
315		* @psalm-return array<TKey, TValue>
316		*/
317	41	private function iterableToArray(iterable $iterable): array
318		{
319	41	return $iterable instanceof Traversable ? iterator_to_array($iterable, true) : $iterable;
		0 ignored issues – show Bug Best Practice introduced 2021-09-02 20:36 UTC by Report Bug Copy Issue Report The expression `return $iterable instanc...able, true) : $iterable` could return the type `iterable` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
320		}
321		}
322

yiisoft / data

Push — master ( 6c8383...fe7e74 )

IterableDataReader::count() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like