Spiral\Boot\BootloadManager\Initializer

Complexity

Total Complexity

43

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Test Coverage

Coverage

98.92%

Importance

Changes	1
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	findBootloaderClassesInMethod()	0	11	4
A	initBindings()	0	8	3
A	__construct()	0	6	1
B	init()	0	27	10
A	getRegistry()	0	3	1
A	getDependencies()	0	17	3
A	initDefaultChecker()	0	8	1
A	initBootloader()	0	9	2
A	isBootloader()	0	3	1
A	shouldBeBooted()	0	7	2
A	getBootloadConfigAttribute()	0	13	4
B	getBootloadConfig()	0	29	11

<?php

declare(strict_types=1);

namespace Spiral\Boot\BootloadManager;

use Psr\Container\ContainerInterface;
use Spiral\Boot\Attribute\BootloadConfig;
use Spiral\Boot\Bootloader\BootloaderInterface;
use Spiral\Boot\Bootloader\DependedInterface;
use Spiral\Boot\BootloadManager\Checker\BootloaderChecker;
use Spiral\Boot\BootloadManager\Checker\BootloaderCheckerInterface;
use Spiral\Boot\BootloadManager\Checker\CanBootedChecker;
use Spiral\Boot\BootloadManager\Checker\CheckerRegistry;
use Spiral\Boot\BootloadManager\Checker\ClassExistsChecker;
use Spiral\Boot\BootloadManager\Checker\ConfigChecker;
use Spiral\Boot\BootloadManagerInterface;
use Spiral\Core\BinderInterface;
use Spiral\Core\Container;
use Spiral\Core\ResolverInterface;

/**
 * @internal
 * @psalm-import-type TClass from BootloadManagerInterface
 * @psalm-import-type TFullBinding from BootloaderInterface
 */
class Initializer implements InitializerInterface, Container\SingletonInterface
{
    protected ?BootloaderCheckerInterface $checker = null;

    public function __construct(
        protected readonly ContainerInterface $container,
        protected readonly BinderInterface $binder,
        protected readonly ClassesRegistry $bootloaders = new ClassesRegistry(),
        ?BootloaderCheckerInterface $checker = null,

The parameter $checker is not used and could be removed.

    ) {
    }

    /**
     * Instantiate bootloader objects and resolve dependencies
     *
     * @param TClass[]|array<TClass, array<string,mixed>> $classes
     */
    public function init(array $classes, bool $useConfig = true): \Generator
    {
        $this->checker ??= $this->initDefaultChecker();

        foreach ($classes as $bootloader => $options) {
            // default bootload syntax as simple array
            if (\is_string($options) || $options instanceof BootloaderInterface) {
                $bootloader = $options;
                $options = [];
            }
            $options = $useConfig ? $this->getBootloadConfig($bootloader, $options) : [];

            if (!$this->checker->canInitialize($bootloader, $useConfig ? $options : null)) {

It seems like $useConfig ? $options : null can also be of type array; however, parameter $config of Spiral\Boot\BootloadManager\Checker\BootloaderCheckerInterface::canInitialize() does only seem to accept Spiral\Boot\Attribute\BootloadConfig|null, maybe add an additional type check?

The method canInitialize() does not exist on null.

                continue;
            }

            $this->bootloaders->register($bootloader instanceof BootloaderInterface ? $bootloader::class : $bootloader);

            if (!$bootloader instanceof BootloaderInterface) {
                $bootloader = $this->container->get($bootloader);
            }

            /** @var BootloaderInterface $bootloader */
            yield from $this->initBootloader($bootloader);
            yield $bootloader::class => [
                'bootloader' => $bootloader,
                'options' => $options instanceof BootloadConfig ? $options->args : $options,
            ];
        }
    }

    public function getRegistry(): ClassesRegistry
    {
        return $this->bootloaders;
    }

    /**
     * Resolve all bootloader dependencies and init bindings
     */
    protected function initBootloader(BootloaderInterface $bootloader): iterable
    {
        if ($bootloader instanceof DependedInterface) {
            yield from $this->init($this->getDependencies($bootloader));
        }

        $this->initBindings(
            $bootloader->defineBindings(),
            $bootloader->defineSingletons()
        );
    }

    /**
     * Bind declared bindings.
     *
     * @param TFullBinding $bindings

The type Spiral\Boot\BootloadManager\TFullBinding was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param TFullBinding $singletons
     */
    protected function initBindings(array $bindings, array $singletons): void
    {
        foreach ($bindings as $aliases => $resolver) {
            $this->binder->bind($aliases, $resolver);
        }

        foreach ($singletons as $aliases => $resolver) {
            $this->binder->bindSingleton($aliases, $resolver);
        }
    }

    protected function getDependencies(DependedInterface $bootloader): array
    {
        $deps = $bootloader->defineDependencies();

        $reflectionClass = new \ReflectionClass($bootloader);

        $methodsDeps = [];

        foreach (Methods::cases() as $method) {
            if ($reflectionClass->hasMethod($method->value)) {
                $methodsDeps[] = $this->findBootloaderClassesInMethod(
                    $reflectionClass->getMethod($method->value)
                );
            }
        }

        return \array_values(\array_unique(\array_merge($deps, ...$methodsDeps)));
    }

    protected function findBootloaderClassesInMethod(\ReflectionMethod $method): array
    {
        $args = [];
        foreach ($method->getParameters() as $parameter) {
            $type = $parameter->getType();
            if ($type instanceof \ReflectionNamedType && $this->shouldBeBooted($type)) {
                $args[] = $type->getName();
            }
        }

        return $args;
    }

    protected function shouldBeBooted(\ReflectionNamedType $type): bool
    {
        /** @var TClass $class */
        $class = $type->getName();

        return $this->isBootloader($class)
            && !$this->bootloaders->isBooted($class);
    }

    /**
     * @psalm-pure
     * @psalm-assert-if-true TClass $class
     */
    protected function isBootloader(string|object $class): bool
    {
        return \is_subclass_of($class, BootloaderInterface::class);
    }

    protected function initDefaultChecker(): BootloaderCheckerInterface
    {
        $registry = new CheckerRegistry();
        $registry->register($this->container->get(ConfigChecker::class));
        $registry->register(new ClassExistsChecker());
        $registry->register(new CanBootedChecker($this->bootloaders));

        return new BootloaderChecker($registry);
    }

    /**
     * Returns merged config. Attribute config have lower priority.
     *
     * @param class-string<BootloaderInterface>|BootloaderInterface $bootloader

The doc comment class-string<BootloaderInterface>|BootloaderInterface at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<BootloaderInterface>|BootloaderInterface.

     */
    private function getBootloadConfig(
        string|BootloaderInterface $bootloader,
        array|callable|BootloadConfig $config
    ): BootloadConfig {
        if ($config instanceof \Closure) {

$config is never a sub-type of Closure.

            $config = $this->container instanceof ResolverInterface
                ? $config(...$this->container->resolveArguments(new \ReflectionFunction($config)))
                : $config();
        }
        $attr = $this->getBootloadConfigAttribute($bootloader);

        $getArgument = static function (string $key, bool $override, mixed $default = []) use ($config, $attr): mixed {
            return match (true) {
                $config instanceof BootloadConfig && $override => $config->{$key},
                $config instanceof BootloadConfig && !$override && \is_array($default) =>
                    $config->{$key} + ($attr->{$key} ?? []),
                $config instanceof BootloadConfig && !$override && \is_bool($default) => $config->{$key},
                \is_array($config) && $config !== [] && $key === 'args' => $config,
                default => $attr->{$key} ?? $default,
            };
        };

        $override = $config instanceof BootloadConfig ? $config->override : true;

$config is never a sub-type of Spiral\Boot\Attribute\BootloadConfig.

        return new BootloadConfig(
            args: $getArgument('args', $override),
            enabled: $getArgument('enabled', $override, true),
            allowEnv: $getArgument('allowEnv', $override),
            denyEnv: $getArgument('denyEnv', $override),
        );
    }

    /**
     * @param class-string<BootloaderInterface>|BootloaderInterface $bootloader

The doc comment class-string<BootloaderInterface>|BootloaderInterface at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<BootloaderInterface>|BootloaderInterface.

     */
    private function getBootloadConfigAttribute(string|BootloaderInterface $bootloader): ?BootloadConfig
    {
        $attribute = null;
        if ($bootloader instanceof BootloaderInterface || \class_exists($bootloader)) {
            $ref = new \ReflectionClass($bootloader);
            $attribute = $ref->getAttributes(BootloadConfig::class)[0] ?? null;
        }

        if ($attribute === null) {
            return null;
        }

        return $attribute->newInstance();
    }
}