Micro\Component\DependencyInjection\Autowire\AutowireHelper

Complexity

Total Complexity

44

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Test Coverage

Coverage

90.53%

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	2	1
A	resolveStringAsObject()	0	7	2
A	throwAutowireException()	0	15	5
D	autowire()	0	77	23
B	resolveArgumentsFromReflectionParametersObject()	0	43	7
A	resolveArguments()	0	21	6

<?php

/*
 *  This file is part of the Micro framework package.
 *
 *  (c) Stanislau Komar <kost@micro-php.net>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Micro\Component\DependencyInjection\Autowire;

use Micro\Component\DependencyInjection\Autowire\Exception\AutowireException;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;

class AutowireHelper implements AutowireHelperInterface
{
    public function __construct(private ContainerInterface $container)
    {
    }

    public function autowire(string|array|callable $target): callable
    {
        return function () use ($target) {
            if (\is_array($target)) {

The condition is_array($target) is always true.

                $target = array_filter($target); // Don't allow [class-name::class-name] method
                $tc = \count($target);
                if (0 === $tc || $tc > 2) {
                    $this->throwAutowireException($target, '');
                }
            }

            try {
                if ($target instanceof \Closure) {

$target is never a sub-type of Closure.

                    $arguments = $this->resolveArguments($target);

                    return \call_user_func($target, ...$arguments);
                }

                if (\is_string($target) && class_exists($target)) {

The condition is_string($target) is always false.

                    $arguments = $this->resolveArguments($target);

                    return new $target(...$arguments);
                }

                if (\is_object($target) && \is_callable($target)) {

The condition is_object($target) is always false.

                    $arguments = $this->resolveArguments([$target, '__invoke']);

                    return \call_user_func($target, ...$arguments);
                }

                if (!\is_array($target)) {

The condition is_array($target) is always true.

                    $this->throwAutowireException($target, '');
                }

                $object = $target[0] ?? null;
                $method = $target[1] ?? null;
                $arguments = null;

                if (\is_object($object)) {
                    if (!$method) {
                        if (!\is_callable($object)) {
                            $this->throwAutowireException($target, sprintf('Object `%s` is not callable.', $object::class));
                        }

                        if (!($object instanceof \Closure)) {
                            $method = '__invoke';
                        }
                    }

                    if (!\is_string($method)) {
                        $this->throwAutowireException($target, '');
                    }

                    $arguments = $this->resolveArguments($object, $method);
                }

                if (($object instanceof \Closure) && !$method) {
                    return \call_user_func($object, ...$arguments);
                }

                if (!$object || !$method) {
                    $this->throwAutowireException($target, '');
                }

                if (\is_string($object)) {
                    $object = $this->resolveStringAsObject($object);
                }

                if (!\is_string($method)) {
                    $this->throwAutowireException($target, '');
                }

                return \call_user_func([$object, $method], ...$arguments); // @phpstan-ignore-line
            } catch (\InvalidArgumentException $exception) {
                $this->throwAutowireException($target, '', $exception);
            } catch (AutowireException $exception) {
                throw $exception;
            }
        };
    }

    protected function resolveStringAsObject(string $target): object
    {
        if (!class_exists($target)) {
            $this->throwAutowireException($target, 'The target class does not exist or no callable.');
        }

        return new $target(...$this->resolveArguments($target));
    }

    /**
     * @throws ContainerExceptionInterface
     *
     * @phpstan-ignore-next-line
     */
    protected function throwAutowireException(string|array|callable $target, string $message, \Throwable $parent = null): void
    {
        if (\is_array($target)) {

The condition is_array($target) is always true.

            $target = $target[0] ?? null;
        }

        if (\is_callable($target) && !\is_string($target)) {
            $target = 'Anonymous';
        }

        if (\is_object($target)) {
            $target = $target::class;
        }

        throw new AutowireException(sprintf('Can not autowire "%s". %s', $target, $message), 0, $parent);
    }

    /**
     * @phpstan-ignore-next-line
     */
    protected function resolveArguments(string|array|object $target, string $method = null): array
    {
        if (\is_callable($target) && !$method && !\is_string($target)) {
            $ref = new \ReflectionFunction($target); // @phpstan-ignore-line

$target of type array is incompatible with the type Closure|string expected by parameter $function of ReflectionFunction::__construct().

            return $this->resolveArgumentsFromReflectionParametersObject($ref->getParameters());
        }

        $reflectionClass = new \ReflectionClass($target); // @phpstan-ignore-line

$target of type array is incompatible with the type object|string expected by parameter $objectOrClass of ReflectionClass::__construct().

        $reflectionClassMethod = null === $method ?
            $reflectionClass->getConstructor() :
            $reflectionClass->getMethod($method)
        ;

        if (null === $reflectionClassMethod) {
            return [];
        }

        return $this->resolveArgumentsFromReflectionParametersObject(
            $reflectionClassMethod->getParameters()
        );
    }

    /**
     * @throws \Psr\Container\ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     *
     * @phpstan-ignore-next-line
     */
    private function resolveArgumentsFromReflectionParametersObject(array $reflectionParameters): array
    {
        $arguments = [];
        /** @var \ReflectionParameter $parameter */
        foreach ($reflectionParameters as $parameter) {
            $parameterType = $parameter->getType();
            $allowedNull = $parameter->isOptional();
            $parameterName = $parameter->getName();
            if (!$parameterType) {
                if (!$allowedNull) {
                    throw new \InvalidArgumentException(sprintf('The untyped argument `%s` cannot be autowired.', $parameterName));
                }

                $arguments[] = null;

                continue;
            }

            if (
                !$parameterType instanceof \ReflectionNamedType
            ) {
                throw new \InvalidArgumentException(sprintf('The argument `%s` has invalid type.', $parameterName));
            }

            $parameterTypeName = $parameterType->getName();

            $classImplements = class_implements($parameterTypeName);
            if (false === $classImplements) {
                $arguments[] = null;

                continue;
            }

            if (\in_array(ContainerInterface::class, $classImplements)) {
                $arguments[] = $this->container;

                continue;
            }

            $arguments[] = $this->container->get($parameterTypeName);
        }

        return $arguments;
    }
}