loophp\collection\Operation\Sort

Complexity

Total Complexity

5

Size/Duplication

Total Lines	69
Duplicated Lines	0 %

Test Coverage

Coverage

78.79%

Importance

Changes	1
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	64	5

<?php

declare(strict_types=1);

namespace loophp\collection\Operation;

use Closure;
use Exception;
use Generator;
use loophp\collection\Contract\Operation;
use loophp\iterators\SortIterableAggregate;

/**
 * @immutable
 *
 * @template TKey
 * @template T
 */
final class Sort extends AbstractOperation
{
    /**
     * @return Closure(int): Closure(null|(Closure(T, T, TKey, TKey): int)): Closure(iterable<TKey, T>): Generator<TKey, T>
     */
    public function __invoke(): Closure
    {
        return
            /**
             * @return Closure(null|Closure(T, T, TKey, TKey): int): Closure(iterable<TKey, T>): Generator<TKey, T>
             */
            static fn (int $type = Operation\Sortable::BY_VALUES): Closure =>
                /**
                 * @param null|(Closure(T, T, TKey, TKey): int)|(callable(T, T, TKey, TKey): int) $callback

The doc comment null|(Closure(T, T, TKey, TKey): int)|(callable(T, T, TKey, TKey): int) at position 3 could not be parsed: Expected ')' at position 3, but found 'Closure'.

                 *
                 * @return Closure(iterable<TKey, T>): Generator<TKey, T>
                 */
                static function (null|callable|Closure $callback = null) use ($type): Closure {
                    if (Operation\Sortable::BY_VALUES !== $type && Operation\Sortable::BY_KEYS !== $type) {
                        throw new Exception('Invalid sort type.');
                    }

                    $callback ??=
                        /**
                         * @param T $left
                         * @param T $right
                         * @param TKey $leftKey
                         * @param TKey $rightKey

The type loophp\collection\Operation\TKey was not found. Maybe you did not declare it correctly or list all dependencies?

                         */
                        static fn (mixed $left, mixed $right, mixed $leftKey, mixed $rightKey): int => $right <=> $left;

The parameter $rightKey is not used and could be removed.

The parameter $leftKey is not used and could be removed.

                    if (!($callback instanceof Closure)) {
                        trigger_deprecation(
                            'loophp/collection',
                            '7.4',
                            'Passing a callable as argument is deprecated and will be removed in 8.0. Use a closure instead.',
                            self::class
                        );

                        $callback = Closure::fromCallable($callback);
                    }

                    $operations = Operation\Sortable::BY_VALUES === $type ?
                        [
                            'before' => [],
                            'after' => [],
                        ] :
                        [
                            'before' => [(new Flip())()],
                            'after' => [(new Flip())()],
                        ];

                    $sortedIterator =
                        /**
                         * @param iterable<TKey, T> $iterable
                         *
                         * @return SortIterableAggregate<TKey, T>
                         */
                        static fn (iterable $iterable): SortIterableAggregate => new SortIterableAggregate($iterable, $callback);

                    /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $sort */
                    $sort = (new Pipe())()(
                        ...$operations['before'],
                        ...[$sortedIterator],
                        ...$operations['after']
                    );

                    // Point free style.
                    return $sort;
                };
    }
}