Antidot\Container\MarshalDelegatorsConfig

Complexity

Total Complexity

6

Size/Duplication

Total Lines	38
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	20	3
A	delegateFactories()	0	14	3

<?php

declare(strict_types=1);

namespace Antidot\Container;

use Psr\Container\ContainerInterface;
use function is_callable;

/**
 *
 * Class MarshalDelegatorsConfig
 * @package Antidot\Container
 */
class MarshalDelegatorsConfig
{
    public function __invoke(ContainerInterface $container, ContainerConfig $dependencies): ContainerConfig
    {
        foreach ($dependencies->get('delegators') as $service => $delegatorNames) {
            $factory = $this->delegateFactories($container, $dependencies, $service);
            if (!is_callable($factory)) {
                continue;
            }
            $dependencies->set(ContainerDelegatorFactory::class, static function () use ($delegatorNames, $factory) {
                return new ContainerDelegatorFactory($delegatorNames, $factory);

The class Antidot\Container\ContainerDelegatorFactory has been deprecated: will remove in version 1.0.0

It seems like $factory can also be of type null; however, parameter $factory of Antidot\Container\ContainerDelegatorFactory::__construct() does only seem to accept callable, maybe add an additional type check?

            });
            $dependencies->set(
                $service,
                static function(ContainerInterface $container) use ($service) {
                    $callable = $container->get(ContainerDelegatorFactory::class);
                    return $callable($container, $service);
                }
            );
        }

        return $dependencies;
    }

    private function delegateFactories(
        ContainerInterface $container,
        ContainerConfig $dependencies,
        string $service
    ): ?callable {
        if (false === $dependencies->has($service)) {
            return null;
        }
        // Marshal from factory
        $serviceFactory = $dependencies->get($service);
        return static function () use ($service, $serviceFactory, $container) {
            return is_callable($serviceFactory)
                ? $serviceFactory($container, $service)
                : (new $serviceFactory())($container, $service);
        };
    }
}