AlecRabbit\Spinner\Core\Builder\DriverBuilder

Complexity

Total Complexity

8

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	withInitialInterval()	0	5	1
A	withObserver()	0	5	1
A	withIntervalComparator()	0	5	1
A	validate()	0	9	1
A	withDeltaTimer()	0	5	1
A	build()	0	11	1
A	withRenderer()	0	5	1
A	withDriverMessages()	0	5	1

<?php

declare(strict_types=1);

namespace AlecRabbit\Spinner\Core\Builder;

use AlecRabbit\Spinner\Contract\IDeltaTimer;
use AlecRabbit\Spinner\Contract\IInterval;
use AlecRabbit\Spinner\Contract\IObserver;
use AlecRabbit\Spinner\Core\Contract\IDriver;
use AlecRabbit\Spinner\Core\Contract\IDriverBuilder;
use AlecRabbit\Spinner\Core\Contract\IDriverMessages;
use AlecRabbit\Spinner\Core\Contract\IIntervalComparator;
use AlecRabbit\Spinner\Core\Contract\IRenderer;
use AlecRabbit\Spinner\Core\Driver;
use AlecRabbit\Spinner\Exception\LogicException;

/**
 * @psalm-suppress PossiblyNullArgument
 */
final class DriverBuilder implements IDriverBuilder
{
    private ?IDeltaTimer $deltaTimer = null;
    private ?IInterval $initialInterval = null;
    private ?IObserver $observer = null;
    private ?IDriverMessages $driverMessages = null;
    private ?IIntervalComparator $intervalComparator = null;
    private ?IRenderer $renderer = null;

    public function withDeltaTimer(IDeltaTimer $timer): IDriverBuilder
    {
        $clone = clone $this;
        $clone->deltaTimer = $timer;
        return $clone;
    }

    public function withInitialInterval(IInterval $interval): IDriverBuilder
    {
        $clone = clone $this;
        $clone->initialInterval = $interval;
        return $clone;
    }

    public function withObserver(IObserver $observer): IDriverBuilder
    {
        $clone = clone $this;
        $clone->observer = $observer;
        return $clone;
    }

    public function build(): IDriver
    {
        $this->validate();

        return new Driver(
            initialInterval: $this->initialInterval,

It seems like $this->initialInterval can also be of type null; however, parameter $initialInterval of AlecRabbit\Spinner\Core\Driver::__construct() does only seem to accept AlecRabbit\Spinner\Contract\IInterval, maybe add an additional type check?

            driverMessages: $this->driverMessages,

It seems like $this->driverMessages can also be of type null; however, parameter $driverMessages of AlecRabbit\Spinner\Core\Driver::__construct() does only seem to accept AlecRabbit\Spinner\Core\Contract\IDriverMessages, maybe add an additional type check?

            renderer: $this->renderer,

It seems like $this->renderer can also be of type null; however, parameter $renderer of AlecRabbit\Spinner\Core\Driver::__construct() does only seem to accept AlecRabbit\Spinner\Core\Contract\IRenderer, maybe add an additional type check?

            intervalComparator: $this->intervalComparator,

It seems like $this->intervalComparator can also be of type null; however, parameter $intervalComparator of AlecRabbit\Spinner\Core\Driver::__construct() does only seem to accept AlecRabbit\Spinner\Core\Contract\IIntervalComparator, maybe add an additional type check?

            deltaTimer: $this->deltaTimer,

It seems like $this->deltaTimer can also be of type null; however, parameter $deltaTimer of AlecRabbit\Spinner\Core\Driver::__construct() does only seem to accept AlecRabbit\Spinner\Contract\IDeltaTimer, maybe add an additional type check?

            observer: $this->observer,
        );
    }

    /**
     * @throws LogicException
     */
    private function validate(): void
    {
        match (true) {
            $this->renderer === null => throw new LogicException('Renderer is not set.'),
            $this->deltaTimer === null => throw new LogicException('Timer is not set.'),
            $this->initialInterval === null => throw new LogicException('InitialInterval is not set.'),
            $this->driverMessages === null => throw new LogicException('DriverMessages is not set.'),
            $this->intervalComparator === null => throw new LogicException('IntervalComparator is not set.'),
            default => null,
        };
    }

    public function withIntervalComparator(IIntervalComparator $intervalComparator): IDriverBuilder
    {
        $clone = clone $this;
        $clone->intervalComparator = $intervalComparator;
        return $clone;
    }

    public function withDriverMessages(IDriverMessages $driverMessages): IDriverBuilder
    {
        $clone = clone $this;
        $clone->driverMessages = $driverMessages;
        return $clone;
    }

    public function withRenderer(IRenderer $renderer): IDriverBuilder
    {
        $clone = clone $this;
        $clone->renderer = $renderer;
        return $clone;
    }
}