AlecRabbit\Spinner\Asynchronous\Loop\Adapter\RevoltLoopAdapter

Complexity

Total Complexity

15

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getLoop()	0	3	1
A	detachSpinner()	0	4	2
A	delay()	0	4	1
A	onSignal()	0	4	1
A	assertExtPcntl()	0	10	4
A	repeat()	0	4	1
A	attach()	0	7	1
A	autoStart()	0	18	4

<?php

declare(strict_types=1);
// 17.02.23

namespace AlecRabbit\Spinner\Asynchronous\Loop\Adapter;

use AlecRabbit\Spinner\Asynchronous\Loop\Adapter\A\ALoopAdapter;
use AlecRabbit\Spinner\Core\Contract\ISpinner;
use Closure;
use React\EventLoop\LoopInterface;
use Revolt\EventLoop;
use Revolt\EventLoop\Driver;
use Revolt\EventLoop\Driver\EvDriver;
use Revolt\EventLoop\Driver\EventDriver;
use Revolt\EventLoop\Driver\UvDriver;

class RevoltLoopAdapter extends ALoopAdapter
{
    private static bool $stopped = false;
    private ?string $spinnerTimer = null;

    public function attach(ISpinner $spinner): void
    {
        $this->detachSpinner();
        $this->spinnerTimer =
            EventLoop::repeat(
                $spinner->getInterval()->toSeconds(),
                static fn() => $spinner->spin()
            );
    }

    protected function detachSpinner(): void
    {
        if ($this->spinnerTimer) {
            EventLoop::cancel($this->spinnerTimer);
        }
    }

    public function repeat(float $interval, Closure $closure): void
    {
        /** @psalm-suppress MixedArgumentTypeCoercion */
        EventLoop::repeat($interval, $closure);
    }

    public function autoStart(): void
    {
        // Automatically run loop at end of program, unless already started or stopped explicitly.
        // @codeCoverageIgnoreStart
        $hasRun = false;
        EventLoop::defer(static function () use (&$hasRun): void {
            $hasRun = true;
        });

        $stopped =& self::$stopped;
        register_shutdown_function(static function () use (&$hasRun, &$stopped) {
            // Don't run if we're coming from a fatal error (uncaught exception).
            if (self::error()) {
                return;
            }

            if (!$hasRun && !$stopped) {
                EventLoop::run();
            }
        });
        // @codeCoverageIgnoreEnd
    }

    public function delay(float $delay, Closure $closure): void
    {
        /** @psalm-suppress MixedArgumentTypeCoercion */
        EventLoop::delay($delay, $closure);
    }

    protected function assertExtPcntl(): void
    {
        $driver = $this->getLoop();
        if ($driver instanceof UvDriver
            || $driver instanceof EvDriver
            || $driver instanceof EventDriver) {
            return; // these drivers do not require pcntl extension
        }

        parent::assertExtPcntl();
    }

    public function getLoop(): LoopInterface|Driver
    {
        return EventLoop::getDriver();
    }

    protected function onSignal(int $signal, Closure $closure): void
    {
        /** @psalm-suppress MixedArgumentTypeCoercion */
        EventLoop::onSignal($signal, $closure);
    }
}