DependencyResolver::resolveDependenciesRecursively()

Complexity

Conditions	10
Paths	12

Size

Total Lines	50
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	10.4096

Importance

Changes	2
Bugs	0	Features	0

<?php
    private function resolveDependenciesRecursively(ReflectionParameter $parameter)
    {
        if (!$parameter->hasType()) {
            throw new RuntimeException("No parameter type for '{$parameter->getName()}'");
        }

        /** @var ReflectionNamedType $paramType */
        $paramType = $parameter->getType();
        $paramTypeName = $paramType->getName();
        if (!class_exists($paramTypeName) && !interface_exists($paramTypeName)) {
            return $parameter->getDefaultValue();
        }

        $reflection = new ReflectionClass($paramTypeName);

        // If it's an interface we need to figure out which concrete class do we want to use.
        if ($reflection->isInterface()) {
            $mappingInterfaces = $this->gacelaConfigFile->getMappingInterfaces();
            $concreteClass = $mappingInterfaces[$reflection->getName()] ?? '';
            // a callable will be a way to bypass the instantiation and instead
            // use the result from the callable that was defined in the gacela config file.
            if (is_callable($concreteClass)) {
                return $concreteClass();
            }
            // an Exception will be thrown if there is no concrete class found for the interface.
            if (empty($concreteClass)) {
                throw new DependencyResolverNotFoundException($reflection->getName());
            }
            // finally, override the $reflection (the interface) by the concrete resolved class.
            /** @var class-string $concreteClass */
            $reflection = new ReflectionClass($concreteClass);
        }

        $constructor = $reflection->getConstructor();
        if (!$constructor) {
            return $reflection->newInstance();
        }

        /** @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\Framework\ClassResolver\DependencyResolver\list is incompatible with the type array expected by parameter $args of ReflectionClass::newInstanceArgs().

    }