loophp\collection\Operation\Sort::__invoke()

Complexity

Conditions	5
Paths	1

Size

Total Lines	64
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	5.2385

Importance

Changes	1
Bugs	0	Features	0

<?php
    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 => $left <=> $right;

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;
                };