Gacela\Framework\Bootstrap\SetupGacela

Complexity

Total Complexity

38

Size/Duplication

Total Lines	331
Duplicated Lines	0 %

Test Coverage

Coverage

97.37%

Importance

Changes	4
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	setGenericListeners()	0	5	1
A	setSuffixTypesBuilder()	0	5	1
A	setAreEventListenersEnabled()	0	5	1
A	getConfigKeyValues()	0	3	1
A	getFileCacheDirectory()	0	3	1
A	buildConfig()	0	9	2
A	setFileCacheEnabled()	0	5	1
A	isFileCacheEnabled()	0	3	1
A	setConfigBuilder()	0	5	1
A	setListenersPerEvent()	0	5	1
A	setMappingInterfacesBuilder()	0	5	1
A	setSuffixTypesFn()	0	5	1
A	buildMappingInterfaces()	0	14	2
A	setMappingInterfacesFn()	0	5	1
A	__construct()	0	7	1
A	setConfigKeyValues()	0	5	1
A	getProjectNamespaces()	0	3	1
A	setShouldResetInMemoryCache()	0	5	1
A	shouldResetInMemoryCache()	0	3	1
A	fromGacelaConfig()	0	17	1
A	setConfigFn()	0	5	1
A	fromCallable()	0	6	1
A	setExternalServices()	0	5	1
A	externalServices()	0	3	1
A	fromFile()	0	13	3
A	setFileCacheDirectory()	0	5	1
A	setProjectNamespaces()	0	5	1
A	buildSuffixTypes()	0	9	2
A	getEventDispatcher()	0	20	5

<?php

declare(strict_types=1);

namespace Gacela\Framework\Bootstrap;

use Gacela\Framework\ClassResolver\Cache\GacelaFileCache;
use Gacela\Framework\Config\GacelaConfigBuilder\ConfigBuilder;
use Gacela\Framework\Config\GacelaConfigBuilder\MappingInterfacesBuilder;
use Gacela\Framework\Config\GacelaConfigBuilder\SuffixTypesBuilder;
use Gacela\Framework\EventListener\EventDispatcher;
use Gacela\Framework\EventListener\EventDispatcherInterface;
use Gacela\Framework\EventListener\NullEventDispatcher;
use RuntimeException;

use function is_callable;

final class SetupGacela extends AbstractSetupGacela
{
    /** @var callable(ConfigBuilder):void */
    private $configFn;

    /** @var callable(MappingInterfacesBuilder,array<string,mixed>):void */
    private $mappingInterfacesFn;

    /** @var callable(SuffixTypesBuilder):void */
    private $suffixTypesFn;

    /** @var array<string,class-string|object|callable> */

The doc comment array<string,class-string|object|callable> at position 4 could not be parsed: Unknown type name 'class-string' at position 4 in array<string,class-string|object|callable>.

    private array $externalServices = [];

    private ?ConfigBuilder $configBuilder = null;

    private ?SuffixTypesBuilder $suffixTypesBuilder = null;

    private ?MappingInterfacesBuilder $mappingInterfacesBuilder = null;

    private bool $shouldResetInMemoryCache = false;

    private bool $fileCacheEnabled = GacelaFileCache::DEFAULT_ENABLED_VALUE;

    private string $fileCacheDirectory = GacelaFileCache::DEFAULT_DIRECTORY_VALUE;

    /** @var list<string> */
    private array $projectNamespaces = [];

    /** @var array<string,mixed> */
    private array $configKeyValues = [];

    private bool $areEventListenersEnabled = false;

    /** @var list<callable> */
    private array $genericListeners = [];

    /** @var array<class-string,list<callable>> */

The doc comment array<class-string,list<callable>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string,list<callable>>.

    private array $listenersPerEvent = [];

    private ?EventDispatcherInterface $eventDispatcher = null;

    public function __construct()
    {
        $this->configFn = static function (): void {
        };
        $this->mappingInterfacesFn = static function (): void {
        };
        $this->suffixTypesFn = static function (): void {
        };
    }

    public static function fromFile(string $gacelaFilePath): self
    {
        if (!is_file($gacelaFilePath)) {
            throw new RuntimeException("Invalid file path: '{$gacelaFilePath}'");
        }

        /** @var callable(GacelaConfig):void|null $setupGacelaFileFn */
        $setupGacelaFileFn = include $gacelaFilePath;
        if (!is_callable($setupGacelaFileFn)) {
            return new self();
        }

        return self::fromCallable($setupGacelaFileFn);
    }

    /**
     * @param callable(GacelaConfig):void $setupGacelaFileFn
     */
    public static function fromCallable(callable $setupGacelaFileFn): self
    {
        $gacelaConfig = new GacelaConfig();
        $setupGacelaFileFn($gacelaConfig);

        return self::fromGacelaConfig($gacelaConfig);
    }

    public static function fromGacelaConfig(GacelaConfig $gacelaConfig): self
    {
        $build = $gacelaConfig->build();

        return (new self())
            ->setConfigBuilder($build['config-builder'])
            ->setSuffixTypesBuilder($build['suffix-types-builder'])
            ->setMappingInterfacesBuilder($build['mapping-interfaces-builder'])
            ->setExternalServices($build['external-services'])
            ->setShouldResetInMemoryCache($build['should-reset-in-memory-cache'])
            ->setFileCacheEnabled($build['file-cache-enabled'])
            ->setFileCacheDirectory($build['file-cache-directory'])
            ->setProjectNamespaces($build['project-namespaces'])
            ->setConfigKeyValues($build['config-key-values'])
            ->setAreEventListenersEnabled($build['are-event-listeners-enabled'])
            ->setGenericListeners($build['generic-listeners'])
            ->setListenersPerEvent($build['listeners-per-event']);
    }

    public function setMappingInterfacesBuilder(MappingInterfacesBuilder $builder): self
    {
        $this->mappingInterfacesBuilder = $builder;

        return $this;
    }

    public function setSuffixTypesBuilder(SuffixTypesBuilder $builder): self
    {
        $this->suffixTypesBuilder = $builder;

        return $this;
    }

    public function setConfigBuilder(ConfigBuilder $builder): self
    {
        $this->configBuilder = $builder;

        return $this;
    }

    /**
     * @param callable(ConfigBuilder):void $callable
     */
    public function setConfigFn(callable $callable): self
    {
        $this->configFn = $callable;

        return $this;
    }

    public function buildConfig(ConfigBuilder $builder): ConfigBuilder
    {
        if ($this->configBuilder) {
            $builder = $this->configBuilder;
        }

        ($this->configFn)($builder);

        return $builder;
    }

    /**
     * @param callable(MappingInterfacesBuilder,array<string,mixed>):void $callable
     */
    public function setMappingInterfacesFn(callable $callable): self
    {
        $this->mappingInterfacesFn = $callable;

        return $this;
    }

    /**
     * Define the mapping between interfaces and concretions, so Gacela services will auto-resolve them automatically.
     *
     * @param array<string,class-string|object|callable> $externalServices

The doc comment array<string,class-string|object|callable> at position 4 could not be parsed: Unknown type name 'class-string' at position 4 in array<string,class-string|object|callable>.

     */
    public function buildMappingInterfaces(
        MappingInterfacesBuilder $builder,
        array $externalServices
    ): MappingInterfacesBuilder {
        if ($this->mappingInterfacesBuilder) {
            $builder = $this->mappingInterfacesBuilder;
        }

        ($this->mappingInterfacesFn)(
            $builder,
            array_merge($this->externalServices, $externalServices)
        );

        return $builder;
    }

    /**
     * @param callable(SuffixTypesBuilder):void $callable
     */
    public function setSuffixTypesFn(callable $callable): self
    {
        $this->suffixTypesFn = $callable;

        return $this;
    }

    /**
     * Allow overriding gacela resolvable types.
     */
    public function buildSuffixTypes(SuffixTypesBuilder $builder): SuffixTypesBuilder
    {
        if ($this->suffixTypesBuilder) {
            $builder = $this->suffixTypesBuilder;
        }

        ($this->suffixTypesFn)($builder);

        return $builder;
    }

    /**
     * @param array<string,class-string|object|callable> $array

The doc comment array<string,class-string|object|callable> at position 4 could not be parsed: Unknown type name 'class-string' at position 4 in array<string,class-string|object|callable>.

     */
    public function setExternalServices(array $array): self
    {
        $this->externalServices = $array;

        return $this;
    }

    /**
     * @return array<string,class-string|object|callable>

The doc comment array<string,class-string|object|callable> at position 4 could not be parsed: Unknown type name 'class-string' at position 4 in array<string,class-string|object|callable>.

     */
    public function externalServices(): array
    {
        return $this->externalServices;
    }

    public function setShouldResetInMemoryCache(bool $flag): self
    {
        $this->shouldResetInMemoryCache = $flag;

        return $this;
    }

    public function shouldResetInMemoryCache(): bool
    {
        return $this->shouldResetInMemoryCache;
    }

    public function setFileCacheEnabled(bool $flag): self
    {
        $this->fileCacheEnabled = $flag;

        return $this;
    }

    public function isFileCacheEnabled(): bool
    {
        return $this->fileCacheEnabled;
    }

    public function getFileCacheDirectory(): string
    {
        return $this->fileCacheDirectory;
    }

    public function setFileCacheDirectory(string $dir): self
    {
        $this->fileCacheDirectory = $dir;

        return $this;
    }

    /**
     * @param list<string> $list
     */
    public function setProjectNamespaces(array $list): self
    {
        $this->projectNamespaces = $list;

It seems like $list of type array is incompatible with the declared type Gacela\Framework\Bootstrap\list of property $projectNamespaces.

        return $this;
    }

    /**
     * @return list<string>
     */
    public function getProjectNamespaces(): array
    {
        return $this->projectNamespaces;
    }

    /**
     * @return array<string,mixed>
     */
    public function getConfigKeyValues(): array
    {
        return $this->configKeyValues;
    }

    public function getEventDispatcher(): EventDispatcherInterface
    {
        if ($this->eventDispatcher !== null) {
            return $this->eventDispatcher;
        }

        if ($this->areEventListenersEnabled) {
            $this->eventDispatcher = new EventDispatcher();
            $this->eventDispatcher->registerGenericListeners($this->genericListeners);

The method registerGenericListeners() does not exist on null.

            foreach ($this->listenersPerEvent as $event => $listeners) {
                foreach ($listeners as $callable) {
                    $this->eventDispatcher->registerSpecificListener($event, $callable);
                }
            }
        } else {
            $this->eventDispatcher = new NullEventDispatcher();
        }

        return $this->eventDispatcher;

The expression return $this->eventDispatcher returns the type null which is incompatible with the type-hinted return Gacela\Framework\EventListener\EventDispatcherInterface.

    }

    public function setAreEventListenersEnabled(bool $flag): self
    {
        $this->areEventListenersEnabled = $flag;

        return $this;
    }

    /**
     * @param array<string,mixed> $configKeyValues
     */
    private function setConfigKeyValues(array $configKeyValues): self
    {
        $this->configKeyValues = $configKeyValues;

        return $this;
    }

    /**
     * @param list<callable> $listeners
     */
    private function setGenericListeners(array $listeners): self
    {
        $this->genericListeners = $listeners;

It seems like $listeners of type array is incompatible with the declared type Gacela\Framework\Bootstrap\list of property $genericListeners.

        return $this;
    }

    /**
     * @param array<class-string,list<callable>> $listeners

The doc comment array<class-string,list<callable>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string,list<callable>>.

     */
    private function setListenersPerEvent(array $listeners): self
    {
        $this->listenersPerEvent = $listeners;

        return $this;
    }
}