Gacela\Container\DependencyResolver

Complexity

Total Complexity

29

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveReflectionClass()	0	21	4
A	__construct()	0	3	1
A	resolveDependencies()	0	13	2
A	getConstructor()	0	8	2
A	resolveInnerDependencies()	0	20	3
A	checkCircularDependency()	0	6	2
A	resolveClass()	0	22	4
A	isScalar()	0	4	2
A	getParametersToResolve()	0	12	3
A	checkInvalidArgumentParam()	0	14	4
A	resolveDependenciesRecursively()	0	14	2

<?php

declare(strict_types=1);

namespace Gacela\Container;

use Closure;
use Gacela\Container\Exception\CircularDependencyException;
use Gacela\Container\Exception\DependencyInvalidArgumentException;
use Gacela\Container\Exception\DependencyNotFoundException;
use ReflectionClass;
use ReflectionFunction;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionParameter;

use function is_callable;
use function is_object;
use function is_string;

final class DependencyResolver
{
    /** @var array<class-string, ReflectionClass> */

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

    private array $reflectionCache = [];

    /** @var array<class-string, ?ReflectionMethod> */

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

    private array $constructorCache = [];

    /** @var array<class-string, bool> */

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

    private array $resolvingStack = [];

    /**
     * @param array<class-string,class-string|callable|object> $bindings
     */
    public function __construct(
        private array $bindings = [],
    ) {
    }

    /**
     * @param class-string|Closure $toResolve

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

     *
     * @return list<mixed>
     */
    public function resolveDependencies(string|Closure $toResolve): array
    {
        /** @var list<mixed> $dependencies */
        $dependencies = [];

        $parameters = $this->getParametersToResolve($toResolve);

        foreach ($parameters as $parameter) {
            /** @psalm-suppress MixedAssignment */
            $dependencies[] = $this->resolveDependenciesRecursively($parameter);
        }

        return $dependencies;

The expression return $dependencies returns the type Gacela\Container\list which is incompatible with the type-hinted return array.

    }

    /**
     * @param class-string|Closure $toResolve

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

     *
     * @return list<ReflectionParameter>
     */
    private function getParametersToResolve(Closure|string $toResolve): array
    {
        if (is_string($toResolve)) {
            $constructor = $this->getConstructor($toResolve);
            if (!$constructor) {
                return [];
            }
            return $constructor->getParameters();

The expression return $constructor->getParameters() returns the type ReflectionParameter[] which is incompatible with the documented return type Gacela\Container\list.

        }

        $reflection = new ReflectionFunction($toResolve);
        return $reflection->getParameters();

The expression return $reflection->getParameters() returns the type ReflectionParameter[] which is incompatible with the documented return type Gacela\Container\list.

    }

    /**
     * @param class-string $className
     */
    private function getConstructor(string $className): ?ReflectionMethod
    {
        if (!isset($this->constructorCache[$className])) {
            $reflection = new ReflectionClass($className);
            $this->constructorCache[$className] = $reflection->getConstructor();
        }

        return $this->constructorCache[$className];
    }

    private function resolveDependenciesRecursively(ReflectionParameter $parameter): mixed
    {
        $this->checkInvalidArgumentParam($parameter);

        /** @var ReflectionNamedType $paramType */
        $paramType = $parameter->getType();

        /** @var class-string $paramTypeName */
        $paramTypeName = $paramType->getName();
        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }

        return $this->resolveClass($paramTypeName);
    }

    private function checkInvalidArgumentParam(ReflectionParameter $parameter): void
    {
        if (!$parameter->hasType()) {
            throw DependencyInvalidArgumentException::noParameterTypeFor($parameter->getName());
        }

        /** @var ReflectionNamedType $paramType */
        $paramType = $parameter->getType();
        $paramTypeName = $paramType->getName();

        if ($this->isScalar($paramTypeName) && !$parameter->isDefaultValueAvailable()) {
            /** @var ReflectionClass $reflectionClass */
            $reflectionClass = $parameter->getDeclaringClass();
            throw DependencyInvalidArgumentException::unableToResolve($paramTypeName, $reflectionClass->getName());
        }
    }

    private function isScalar(string $paramTypeName): bool
    {
        return !class_exists($paramTypeName)
            && !interface_exists($paramTypeName);
    }

    /**
     * @param class-string $paramTypeName
     */
    private function resolveClass(string $paramTypeName): mixed
    {
        /** @var mixed $bindClass */
        $bindClass = $this->bindings[$paramTypeName] ?? null;
        if (is_callable($bindClass)) {
            return $bindClass();
        }

        if (is_object($bindClass)) {
            return $bindClass;
        }

        $this->checkCircularDependency($paramTypeName);

        $reflection = $this->resolveReflectionClass($paramTypeName);
        // Use the concrete class name for caching, not the original parameter type
        $constructor = $this->getConstructor($reflection->getName());
        if ($constructor === null) {
            return $reflection->newInstance();
        }

        return $this->resolveInnerDependencies($constructor, $reflection);
    }

    /**
     * @param class-string $className
     */
    private function checkCircularDependency(string $className): void
    {
        if (isset($this->resolvingStack[$className])) {
            $chain = array_keys($this->resolvingStack);
            $chain[] = $className;
            throw CircularDependencyException::create($chain);
        }
    }

    /**
     * @param class-string $paramTypeName
     */
    private function resolveReflectionClass(string $paramTypeName): ReflectionClass
    {
        if (!isset($this->reflectionCache[$paramTypeName])) {
            $reflection = new ReflectionClass($paramTypeName);

            if (!$reflection->isInstantiable()) {
                /** @var mixed $concreteClass */
                $concreteClass = $this->bindings[$reflection->getName()] ?? null;

                if ($concreteClass !== null) {
                    /** @var class-string $concreteClass */
                    $reflection = new ReflectionClass($concreteClass);
                } else {
                    throw DependencyNotFoundException::mapNotFoundForClassName($reflection->getName());
                }
            }

            $this->reflectionCache[$paramTypeName] = $reflection;
        }

        return $this->reflectionCache[$paramTypeName];
    }

    private function resolveInnerDependencies(ReflectionMethod $constructor, ReflectionClass $reflection): object
    {
        $className = $reflection->getName();
        $this->resolvingStack[$className] = true;

        try {
            /** @var list<mixed> $innerDependencies */
            $innerDependencies = [];

            foreach ($constructor->getParameters() as $constructorParameter) {
                $paramType = $constructorParameter->getType();
                if ($paramType) {
                    /** @psalm-suppress MixedAssignment */
                    $innerDependencies[] = $this->resolveDependenciesRecursively($constructorParameter);
                }
            }

            return $reflection->newInstanceArgs($innerDependencies);

$innerDependencies of type Gacela\Container\list is incompatible with the type array expected by parameter $args of ReflectionClass::newInstanceArgs().

        } finally {
            unset($this->resolvingStack[$className]);
        }
    }
}