AlecRabbit\Spinner\Core\Sentinel

Complexity

Total Complexity

23

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	assertFrame()	0	6	2
A	assertFrames()	0	9	3
A	assertOutput()	0	9	5
A	assertJugglersOrder()	0	17	4
A	assertSettings()	0	5	4
A	assertFrameLength()	0	8	2
A	assertStyles()	0	8	3

<?php declare(strict_types=1);

namespace AlecRabbit\Spinner\Core;

use AlecRabbit\Spinner\Core\Contracts\OutputInterface;
use AlecRabbit\Spinner\Settings\Contracts\Defaults;
use AlecRabbit\Spinner\Settings\Settings;
use function AlecRabbit\typeOf;

/**
 * Class Sentinel.
 * Contains data asserts
 * @internal
 */
class Sentinel
{
    /**
     * @param array $frames
     */
    public static function assertFrames(array $frames): void
    {
        if (Defaults::MAX_FRAMES_COUNT < $count = count($frames)) {
            throw new \InvalidArgumentException(
                sprintf('MAX_SYMBOLS_COUNT limit [%s] exceeded: [%s].', Defaults::MAX_FRAMES_COUNT, $count)
            );
        }
        foreach ($frames as $frame) {
            self::assertFrame($frame);
        }
    }

    /**
     * @param mixed $frame
     */
    public static function assertFrame($frame): void
    {
        if (!\is_string($frame)) {
            throw new \InvalidArgumentException('All frames should be of string type.');
        }
        self::assertFrameLength($frame);
    }

    /**
     * @param string $frame
     */
    public static function assertFrameLength(string $frame): void
    {
        if (Defaults::MAX_FRAME_LENGTH < $length = mb_strwidth($frame)) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Single frame max length [%s] exceeded [%s]',
                    Defaults::MAX_FRAME_LENGTH,
                    $length
                )
            );
        }
    }

    /**
     * @param array $styles
     * @param array $against
     */
    public static function assertStyles(array $styles, array $against): void
    {
        $keys = array_keys($against);
        foreach ($keys as $index) {
            if (!\array_key_exists($index, $styles)) {
                // @codeCoverageIgnoreStart
                throw new \InvalidArgumentException(
                    'Styles array does not have [' . $index . '] key.'
                );
                // @codeCoverageIgnoreEnd
            }
        }
    }

    /**
     * @param mixed $output
     */
    public static function assertOutput($output): void
    {
        if (null !== $output && false !== $output && !$output instanceof OutputInterface) {
            $typeOrValue =
                true === $output ? 'true' : typeOf($output);
            throw new \InvalidArgumentException(
                'Incorrect parameter: ' .
                '[null|false|' . OutputInterface::class . '] expected'
                . ' "' . $typeOrValue . '" given.'
            );
        }
    }

    /**
     * @param mixed $settings
     */
    public static function assertSettings($settings): void
    {
        if (null !== $settings && !\is_string($settings) && !$settings instanceof Settings) {
            throw new \InvalidArgumentException(
                'Instance of [' . Settings::class . '] or string expected ' . typeOf($settings) . ' given.'
            );
        }
    }

    /**
     * @param array $order
     */
    public static function assertJugglersOrder(array $order): void
    {
        if (Defaults::NUMBER_OF_ORDER_DIRECTIVES !== $count = count($order)) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Incorrect count of order directives [%s] when exactly %s was expected',
                    $count,
                    Defaults::NUMBER_OF_ORDER_DIRECTIVES
                )
            );
        }
        foreach (Defaults::DEFAULT_ORDER_DIRECTIVES as $directive) {
            if (!in_array($directive, $order, true)) {
                throw new \InvalidArgumentException(
                    sprintf(
                        'Directive for %s position not found',
                        Defaults::DIRECTIVES_NAMES[$directive]
                    )
                );
            }
        }
    }
}