Laganica\Di\Resolver\ResolverFactory

Complexity

Total Complexity

7

Size/Duplication

Total Lines	56
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Test Coverage

Coverage

87.5%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	setContainer()	0	4	1
A	create()	0	16	4
A	resolveDefinition()	0	15	2

<?php

namespace Laganica\Di\Resolver;

use Closure;
use InvalidArgumentException;
use Laganica\Di\Definition\AliasDefinition;
use Laganica\Di\Definition\BindDefinition;
use Laganica\Di\Definition\DefinitionInterface;
use Laganica\Di\Definition\FactoryDefinition;
use Laganica\Di\Definition\ValueDefinition;
use Psr\Container\ContainerInterface;

/**
 * Class ResolverFactory
 *
 * @package Laganica\Di\Resolver
 */
class ResolverFactory implements ResolverFactoryInterface
{
    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @param ContainerInterface $container
     */
    public function setContainer(ContainerInterface $container): void
    {
        $this->container = $container;
    }

    /**
     * @inheritDoc
     */
    public function create($definition): ResolverInterface
    {
        if ($definition instanceof DefinitionInterface) {
            return $this->resolveDefinition($definition);
        }

        if ($definition instanceof Closure) {
            return new ClosureResolver($this->container);
        }

        if (is_string($definition)) {
            return new ClassResolver($this->container);
        }

        throw new InvalidArgumentException('Invalid definition found. Allowed definitions are bind(), value(), factory(), alias(), Closure or string');
    }

    /**
     * @param DefinitionInterface $definition
     *
     * @return ResolverInterface
     */
    private function resolveDefinition(DefinitionInterface $definition): ResolverInterface
    {
        $classMap = [
            BindDefinition::class => BindResolver::class,
            FactoryDefinition::class => FactoryResolver::class,
            ValueDefinition::class => ValueResolver::class,
            AliasDefinition::class => AliasResolver::class,
        ];

        if (!$resolverClass = $classMap[get_class($definition)] ?? null) {
            throw new InvalidArgumentException('Invalid definition found. Allowed definitions are bind(), value(), factory(), alias(), Closure or string');
        }

        return new $resolverClass($this->container);
    }
}