anonymous//tests/Feature/Framework/BindingInterfacesInGacelaConfigFile/gacela.php$1

Complexity

Total Complexity

1

Size/Duplication

Total Lines	4
Duplicated Lines	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	gacela.php$1 ➔ getClassName()	0	3	1

<?php

declare(strict_types=1);

use Gacela\Framework\Bootstrap\GacelaConfig;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Domain\AbstractClass;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Domain\AbstractFromAnonymousClass;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Domain\AbstractFromCallable;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Domain\InterfaceFromAnonymousClass;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Domain\InterfaceFromCallable;
use GacelaTest\Feature\Framework\BindingInterfacesInGacelaConfigFile\Module\Infrastructure\ConcreteClass;

// Is it also possible to bind classes like => AbstractClass::class => SpecificClass::class
// Check the test BindingInterfacesWithInnerDependencies BUT be aware this way is not possible
// if the class has dependencies that cannot be resolved automatically!
return static fn (GacelaConfig $config): GacelaConfig => $config
    ->addBinding(
        AbstractClass::class,
        new ConcreteClass(true, 'string', 1, 1.2, ['array']),
    )
    // Resolve anonymous-classes/callables from abstract classes and interfaces
    ->addBinding(
        AbstractFromAnonymousClass::class,
        new class() extends AbstractFromAnonymousClass {
            public function getClassName(): string
            {
                return AbstractFromAnonymousClass::class;
            }
        },
    )
    ->addBinding(
        AbstractFromCallable::class,
        static fn (): AbstractFromCallable => new class() extends AbstractFromCallable {
            public function getClassName(): string
            {
                return AbstractFromCallable::class;
            }
        },
    )
    ->addBinding(
        InterfaceFromAnonymousClass::class,
        new class() implements InterfaceFromAnonymousClass {
            public function getClassName(): string
            {
                return InterfaceFromAnonymousClass::class;
            }
        },
    )
    ->addBinding(
        InterfaceFromCallable::class,
        static fn (): InterfaceFromCallable => new class() implements InterfaceFromCallable {
            public function getClassName(): string
            {
                return InterfaceFromCallable::class;
            }
        },
    );