Shlinkio\Shlink\Core\Model\ShortUrlsOrdering

Complexity

Total Complexity

9

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Test Coverage

Coverage

92%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	validateAndInit()	0	23	5
A	fromRawData()	0	6	1
A	orderField()	0	3	1
A	orderDirection()	0	3	1
A	hasOrderField()	0	3	1

<?php

declare(strict_types=1);

namespace Shlinkio\Shlink\Core\Model;

use Shlinkio\Shlink\Core\Exception\ValidationException;

use function explode;
use function is_array;
use function is_string;
use function key;

final class ShortUrlsOrdering
{
    public const ORDER_BY = 'orderBy';
    private const DEFAULT_ORDER_DIRECTION = 'ASC';

    private ?string $orderField = null;
    private string $orderDirection = self::DEFAULT_ORDER_DIRECTION;

    /**
     * @throws ValidationException
     */
    public static function fromRawData(array $query): self
    {
        $instance = new self();
        $instance->validateAndInit($query);

        return $instance;
    }

    /**
     * @throws ValidationException
     */
    private function validateAndInit(array $data): void
    {
        /** @var string|array|null $orderBy */
        $orderBy = $data[self::ORDER_BY] ?? null;
        if ($orderBy === null) {
            return;
        }

        // FIXME Providing the ordering as array is considered deprecated. To be removed in v3.0.0
        $isArray = is_array($orderBy);
        if (! $isArray && ! is_string($orderBy)) {

The condition is_string($orderBy) is always true.

            throw ValidationException::fromArray([
                'orderBy' => '"Order by" must be an array, string or null',
            ]);
        }

        if (! $isArray) {
            $parts = explode('-', $orderBy);

It seems like $orderBy can also be of type array; however, parameter $string of explode() does only seem to accept string, maybe add an additional type check?

            $this->orderField = $parts[0];
            $this->orderDirection = $parts[1] ?? self::DEFAULT_ORDER_DIRECTION;
        } else {
            $this->orderField = key($orderBy);

It seems like $orderBy can also be of type string; however, parameter $array of key() does only seem to accept array, maybe add an additional type check?

            $this->orderDirection = $orderBy[$this->orderField];
        }
    }

    public function orderField(): ?string
    {
        return $this->orderField;
    }

    public function orderDirection(): string
    {
        return $this->orderDirection;
    }

    public function hasOrderField(): bool
    {
        return $this->orderField !== null;
    }
}