Gacela\Framework\ClassResolver\DependencyResolver\DependencyResolver

Complexity

Total Complexity

16

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Test Coverage

Coverage

77.27%

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	findConcreteClassThatImplements()	0	16	2
B	resolveDependenciesRecursively()	0	48	9
A	resolveDependencies()	0	19	4

<?php

declare(strict_types=1);

namespace Gacela\Framework\ClassResolver\DependencyResolver;

use Gacela\Framework\Config\GacelaFileConfig\GacelaConfigFileInterface;
use ReflectionClass;
use ReflectionNamedType;
use ReflectionParameter;
use RuntimeException;
use function is_callable;

final class DependencyResolver
{
    private GacelaConfigFileInterface $gacelaConfigFile;

    public function __construct(GacelaConfigFileInterface $gacelaConfigFile)
    {
        $this->gacelaConfigFile = $gacelaConfigFile;
    }

    /**
     * @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)
    {
        /** @var ReflectionNamedType $paramType */
        $paramType = $parameter->getType();
        $type = $paramType->getName();

        if (!class_exists($type) && !interface_exists($type)) {
            return $parameter->getDefaultValue();
        }

        $reflection = new ReflectionClass($type);

        // If it's an interface we need to figure out which concrete class do we want to use
        if ($reflection->isInterface()) {
            $gacelaFileDependencies = $this->gacelaConfigFile->dependencies();
            $concreteClass = $gacelaFileDependencies[$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();
            }
            // if at this point there is no concrete class found for the interface we can
            // try one more thing looking for 1 concrete class that implements this interface
            if (empty($concreteClass)) {
                $concreteClass = $this->findConcreteClassThatImplements($reflection);
            }

            /** @var class-string $concreteClass */
            $reflection = new ReflectionClass($concreteClass);

It seems like $concreteClass can also be of type callable; however, parameter $objectOrClass of ReflectionClass::__construct() does only seem to accept object|string, maybe add an additional type check?

        }

        $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().

    }

    /**
     * @return class-string|string

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

     */
    private function findConcreteClassThatImplements(ReflectionClass $interface): string
    {
        // TODO: Not implemented yet

        // Dummy solution: if the concrete class lives next to its interface, and with the same name.
        $concreteClass = str_replace('Interface', '', $interface->getName());
        if (!class_exists($concreteClass)) {
            $error = <<<TXT
No concrete class was found that implements:
{$interface->getName()}
Did you forget to map this interface to a concrete class in gacela.json using the 'dependencies' key?
TXT;
            throw new RuntimeException($error);
        }

        return $concreteClass;
    }
}