Ninja\Sorter\Strategy\ComplexSortStrategy

Complexity

Total Complexity

17

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	sort()	0	7	2
A	__construct()	0	4	2
A	createSortTransformFunction()	0	22	3
A	sortBy()	0	9	1
B	getPropertyExtractor()	0	23	9

<?php

namespace Ninja\Sorter\Strategy;

use ArrayAccess;
use Closure;
use Ninja\Sorter\Comparator\ComparatorInterface;
use Ninja\Sorter\Comparator\UnicodeCIComparator;

The type Ninja\Sorter\Comparator\UnicodeCIComparator was not found. Maybe you did not declare it correctly or list all dependencies?

class ComplexSortStrategy extends AbstractSortStrategy
{
    /**
     * @var array<string|int, mixed>
     */
    private array $property_map = [];

    public function __construct(protected ?ComparatorInterface $comparator = null)
    {
        if ($this->comparator === null) {
            $this->comparator = new UnicodeCIComparator();
        }
    }

    public function sortBy(mixed $accessor, int $order = null, ComparatorInterface $comparator = null): static
    {
        $this->property_map[] = [
            'accessor'   => $accessor,
            'direction'  => $order      ?? $this->getOrder(),
            'comparator' => $comparator ?? $this->getComparator(),
        ];

        return $this;
    }

    protected function createSortTransformFunction(): Closure
    {
        $propertyMap       = $this->property_map;
        $propertyExtractor = $this->getPropertyExtractor();
        $valueChecker      = $this->getValueChecker();

        return static function (mixed $a, mixed $b) use ($propertyMap, $propertyExtractor, $valueChecker) {

            foreach ($propertyMap as $property) {
                $valueA = $propertyExtractor($a, $property['accessor']);
                $valueB = $propertyExtractor($b, $property['accessor']);

                $cmp = $property['comparator'];
                $valueChecker($valueA, $valueB, $cmp);
                $result = $cmp->compare($valueA, $valueB);

                if ($result !== 0) {
                    return $result * $property['direction'];
                }
            }

            return 0;
        };
    }

    /**
     * Get callable used for extracting values from sortable entities (objects, arrays etc.)
     * This method extracts value from k, where k is an element of collection(i => k).
     * Accessor can be customized to add sorting ability to a complex objects.
     *
     * @return Closure Takes two arguments, $property and $accessor
     */
    private function getPropertyExtractor(): Closure
    {
        return static function (mixed $property, mixed $accessor = null): mixed {

            if (is_string($property) || !$accessor) {
                return $property;
            }

            if ($accessor instanceof Closure) {
                return $accessor($property);
            }

            if (is_string($accessor)) {
                if (is_array($property) || $property instanceof ArrayAccess) {
                    return $property[$accessor];
                }

                if (is_object($property) && property_exists($property, $accessor)) {
                    return $property->{$accessor};
                }
            }

            throw new \RuntimeException(sprintf('Unable to resolve property value: %s', gettype($property)));
        };
    }

    /**
     * @param array<string|int, mixed> $collection
     * @return array<string|int, mixed>
     */
    public function sort(array $collection): array
    {
        if (empty($this->property_map)) {
            throw new \RuntimeException('Missing sort properties - add them using sortBy(...)');
        }

        return parent::sort($collection);
    }
}