Gacela\Framework\ClassResolver\DependencyResolver\DependencyResolver

Complexity

Total Complexity

24

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Test Coverage

Coverage

91.23%

Importance

Changes	5
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	resolveDependencies()	0	19	4
A	resolveDependenciesRecursively()	0	14	3
A	isScalar()	0	4	2
A	resolveClass()	0	19	4
A	checkInvalidArgumentParam()	0	14	4
A	resolveInnerDependencies()	0	14	3
A	resolveReflectionClass()	0	17	3

<?php

declare(strict_types=1);

namespace Gacela\Framework\ClassResolver\DependencyResolver;

use ReflectionClass;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionParameter;

use function is_callable;
use function is_object;

final class DependencyResolver
{
    /** @var array<class-string,class-string|callable|object> */
    private array $mappingInterfaces;

    /**
     * @param array<class-string,class-string|callable|object> $mappingInterfaces
     */
    public function __construct(array $mappingInterfaces)
    {
        $this->mappingInterfaces = $mappingInterfaces;
    }

    /**
     * @param class-string $resolvedClassName

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

     *
     * @return list<mixed>
     */
    public function resolveDependencies(string $resolvedClassName): array
    {
        $reflection = new ReflectionClass($resolvedClassName);
        $constructor = $reflection->getConstructor();
        if (!$constructor) {
            return [];

The expression return array() returns the type array which is incompatible with the documented return type Gacela\Framework\ClassResolver\DependencyResolver\list.

        }

        /** @var list<mixed> $dependencies */
        $dependencies = [];
        foreach ($constructor->getParameters() as $parameter) {
            $paramType = $parameter->getType();
            if ($paramType) {
                /** @psalm-suppress MixedAssignment */
                $dependencies[] = $this->resolveDependenciesRecursively($parameter);
            }
        }

        return $dependencies;

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

    }

    /**
     * @return mixed
     */
    private function resolveDependenciesRecursively(ReflectionParameter $parameter)
    {
        $this->checkInvalidArgumentParam($parameter);

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

        /** @var class-string $paramTypeName */
        $paramTypeName = $paramType->getName();
        if ($this->isScalar($paramTypeName) && $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

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

     *
     * @return mixed
     */
    private function resolveClass(string $paramTypeName)
    {
        /** @var mixed $mappedClass */
        $mappedClass = $this->mappingInterfaces[$paramTypeName] ?? null;
        if (is_callable($mappedClass)) {
            return $mappedClass();
        }

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

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

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

    /**
     * @param class-string $paramTypeName

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

     */
    private function resolveReflectionClass(string $paramTypeName): ReflectionClass
    {
        $reflection = new ReflectionClass($paramTypeName);

        if ($reflection->isInstantiable()) {
            return $reflection;
        }

        /** @var mixed $concreteClass */
        $concreteClass = $this->mappingInterfaces[$reflection->getName()];

        if ($concreteClass !== null) {
            /** @var class-string $concreteClass */
            return new ReflectionClass($concreteClass);
        }

        throw DependencyNotFoundException::mapNotFoundForClassName($reflection->getName());
    }

    private function resolveInnerDependencies(ReflectionMethod $constructor, ReflectionClass $reflection): object
    {
        /** @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);
    }
}