AlecRabbit\Spinner\Helper\Asserter

Complexity

Total Complexity

23

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getSeeMethodStr()	0	6	2
A	assertStream()	0	6	3
A	assertIntColor()	0	37	3
A	assertHexStringColor()	0	22	2
A	assertExtensionLoaded()	0	5	2
A	assertColorModes()	0	12	4
A	assertClassExists()	0	8	2
A	assertIntInRange()	0	13	2
A	isSubClass()	0	13	3

<?php

declare(strict_types=1);
// 15.02.23

namespace AlecRabbit\Spinner\Helper;

use AlecRabbit\Spinner\Contract\StyleMode;
use AlecRabbit\Spinner\Exception\InvalidArgumentException;
use AlecRabbit\Spinner\Exception\RuntimeException;
use Traversable;

use function class_exists;
use function extension_loaded;

final class Asserter
{
    /**
     * @param object|class-string $c

The doc comment object|class-string at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in object|class-string.

     * @param class-string $i
     * @param string|null $callerMethod
     * @param bool $allowString
     * @throws InvalidArgumentException
     */
    public static function isSubClass(
        object|string $c,
        string $i,
        ?string $callerMethod = null,
        bool $allowString = true
    ): void {
        if (!is_subclass_of($c, $i, $allowString)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Class "%s" must be a subclass of "%s"%s.',
                    is_object($c) ? get_class($c) : $c,
                    $i,
                    self::getSeeMethodStr($callerMethod),
                )
            );
        }
    }

    private static function getSeeMethodStr(?string $callerMethod): string
    {
        return
            $callerMethod
                ? sprintf(', see "%s()"', $callerMethod)
                : '';
    }

    /**
     * @param resource $stream
     * @throws InvalidArgumentException
     *
     */
    public static function assertStream(mixed $stream): void
    {
        /** @psalm-suppress DocblockTypeContradiction */
        if (!is_resource($stream) || 'stream' !== get_resource_type($stream)) {
            throw new InvalidArgumentException(
                sprintf('Argument is expected to be a stream(resource), "%s" given.', get_debug_type($stream))
            );
        }
    }

    /**
     * @throws InvalidArgumentException
     */
    public static function assertColorModes(Traversable $colorModes): void
    {
        if (0 === count(iterator_to_array($colorModes))) {
            throw new InvalidArgumentException('Color modes must not be empty.');
        }
        /** @var StyleMode $colorMode */
        foreach ($colorModes as $colorMode) {
            if (!$colorMode instanceof StyleMode) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Unsupported color mode of type "%s".',
                        get_debug_type($colorMode)
                    )
                );
            }
        }
    }

    /**
     * @throws RuntimeException
     */
    public static function assertExtensionLoaded(string $extensionName, ?string $message = null): void
    {
        if (!extension_loaded($extensionName)) {
            throw new RuntimeException(
                $message ?? sprintf('Extension "%s" is not loaded.', $extensionName)
            );
        }
    }

    /**
     * @throws InvalidArgumentException
     */
    public static function assertClassExists(string $class, ?string $callerMethod = null): void
    {
        if (!class_exists($class)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Class "%s" does not exist%s.',
                    $class,
                    self::getSeeMethodStr($callerMethod)
                )
            );
        }
    }

    /**
     * @throws InvalidArgumentException
     */
    public static function assertHexStringColor(string $entry): void
    {
        $strlen = strlen($entry);
        $entry = strtolower($entry);
        match (true) {
            0 === $strlen => throw new InvalidArgumentException(
                'Value should not be empty string.'
            ),
            !str_starts_with($entry, '#') => throw new InvalidArgumentException(
                sprintf(
                    'Value should be a valid hex color code("#rgb", "#rrggbb"), "%s" given. No "#" found.',
                    $entry
                )
            ),
            4 !== $strlen && 7 !== $strlen => throw new InvalidArgumentException(
                sprintf(
                    'Value should be a valid hex color code("#rgb", "#rrggbb"), "%s" given. Length: %d.',
                    $entry,
                    $strlen
                )
            ),
            default => null,
        };
    }

    /**
     * @throws InvalidArgumentException
     */
    public static function assertIntInRange(int $value, int $min, int $max, ?string $callerMethod = null): void
    {
        match (true) {
            $min > $value || $max < $value => throw new InvalidArgumentException(
                sprintf(
                    'Value should be in range %d..%d, int(%d) given%s.',
                    $min,
                    $max,
                    $value,
                    self::getSeeMethodStr($callerMethod)
                )
            ),
            default => null,
        };
    }

    /**
     * @throws InvalidArgumentException
     */
    public static function assertIntColor(int $color, StyleMode $styleMode, ?string $callerMethod = null): void
    {
        match (true) {
            0 > $color => throw new InvalidArgumentException(
                sprintf(
                    'Value should be positive integer, %d given%s.',
                    $color,
                    self::getSeeMethodStr($callerMethod)
                )
            ),
            StyleMode::ANSI24->name === $styleMode->name => throw new InvalidArgumentException(

The property name does not seem to exist on AlecRabbit\Spinner\Contract\StyleMode.

                sprintf(
                    'For %s::%s style mode rendering from int is not allowed%s.',
                    StyleMode::class,
                    StyleMode::ANSI24->name,
                    self::getSeeMethodStr($callerMethod)
                )
            ),
            StyleMode::ANSI8->name === $styleMode->name && 255 < $color => throw new InvalidArgumentException(
                sprintf(
                    'For %s::%s style mode value should be in range 0..255, %d given%s.',
                    StyleMode::class,
                    StyleMode::ANSI8->name,
                    $color,
                    self::getSeeMethodStr($callerMethod)
                )
            ),
            StyleMode::ANSI4->name === $styleMode->name && 16 < $color => throw new InvalidArgumentException(
                sprintf(
                    'For %s::%s style mode value should be in range 0..15, %d given%s.',
                    StyleMode::class,
                    StyleMode::ANSI4->name,
                    $color,
                    self::getSeeMethodStr($callerMethod)
                )
            ),
            default => null,
        };
    }
}