Factory::autowire() - Code Metrics - Inspection of "Hotfix/factory make with params cache" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#862)

by Aleksei
created 2023-01-23 20:37 UTC
Factory::autowire() A

↳ Parent: Factory
Complexity

Conditions	6
Paths	3
Size

Total Lines	22
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	14
CRAP Score	6
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
eloc	12
c	2
b	0
f	0
dl	0
loc	22
ccs	14
cts	14
cp	1
rs	9.2222
cc	6
nc	3
nop	3
crap	6
<?php

declare(strict_types=1);

namespace Spiral\Core\Internal;

use Psr\Container\ContainerInterface;
use Spiral\Core\BinderInterface;
use Spiral\Core\Container\Autowire;
use Spiral\Core\Container\InjectorInterface;
use Spiral\Core\Container\SingletonInterface;
use Spiral\Core\Exception\Container\AutowireException;
use Spiral\Core\Exception\Container\ContainerException;
use Spiral\Core\Exception\Container\InjectionException;
use Spiral\Core\Exception\Container\NotCallableException;
use Spiral\Core\Exception\Container\NotFoundException;
use Spiral\Core\Exception\Resolver\ValidationException;
use Spiral\Core\Exception\Resolver\WrongTypeException;
use Spiral\Core\FactoryInterface;
use Spiral\Core\InvokerInterface;
use Spiral\Core\ResolverInterface;
use WeakReference;

/**
 * @internal
 */
final class Factory implements FactoryInterface
{
    use DestructorTrait;

    private State $state;
    private BinderInterface $binder;
    private InvokerInterface $invoker;
    private ContainerInterface $container;
    private ResolverInterface $resolver;
    private Tracer $tracer;

    public function __construct(Registry $constructor)
    {
        $constructor->set('factory', $this);

        $this->state = $constructor->get('state', State::class);
        $this->binder = $constructor->get('binder', BinderInterface::class);
        $this->invoker = $constructor->get('invoker', InvokerInterface::class);
        $this->container = $constructor->get('container', ContainerInterface::class);
        $this->resolver = $constructor->get('resolver', ResolverInterface::class);
        $this->tracer = $constructor->get('tracer', Tracer::class);
    }

    /**
     * @param string|null $context Related to parameter caused injection if any.
     *
     * @throws \Throwable
     */
    public function make(string $alias, array $parameters = [], string $context = null): mixed
    {
        if (!isset($this->state->bindings[$alias])) {
            $this->tracer->push(false, action: 'autowire', alias: $alias, context: $context);
            $this->tracer->push(false, action: 'autowire', alias: $alias, /** @scrutinizer ignore-type */ context: $context);
            try {
                //No direct instructions how to construct class, make is automatically
                return $this->autowire($alias, $parameters, $context);
            } finally {
                $this->tracer->pop(false);
            }
        }

        $avoidCache = $parameters !== [];
        $binding = $this->state->bindings[$alias];
        try {
            $this->tracer->push(
                false,
                action: 'resolve from binding',
                alias: $alias,
                context: $context,
                binding: $binding,
            );
            $this->tracer->push(true);

            if (\is_object($binding)) {
                if ($binding::class === WeakReference::class) {
                    if (($avoidCache || $binding->get() === null) && \class_exists($alias)) {
                        try {
                            $this->tracer->push(false, alias: $alias, source: WeakReference::class, context: $context);
                            $object = $this->createInstance($alias, $parameters, $context);
                            if ($avoidCache) {
                                return $object;
                            }
                            $binding = $this->state->bindings[$alias] = WeakReference::create($object);
                        } catch (\Throwable) {
                            throw new ContainerException($this->tracer->combineTraceMessage(\sprintf(
                                'Can\'t resolve `%s`: can\'t instantiate `%s` from WeakReference binding.',
                                $this->tracer->getRootAlias(),
                                $alias,
                            )));
                        } finally {
                            $this->tracer->pop();
                        }
                    }
                    return $binding->get();
                }
                //When binding is instance, assuming singleton
                return $avoidCache
                    ? $this->createInstance($binding::class, $parameters, $context)
                    : $binding;
            }

            if (\is_string($binding)) {
                //Binding is pointing to something else
                return $this->make($binding, $parameters, $context);
            }

            unset($this->state->bindings[$alias]);
            try {
                $instance = $binding[0] === $alias
                    ? $this->autowire($alias, $parameters, $context)
                    : $this->evaluateBinding($alias, $binding[0], $parameters, $context);
            } finally {
                /** @psalm-var class-string $alias */
                $this->state->bindings[$alias] = $binding;
            }
        } finally {
            $this->tracer->pop(true);
            $this->tracer->pop(false);
        }

        if ($binding[1]) {
            // Indicates singleton
            /** @psalm-var class-string $alias */
            $this->state->bindings[$alias] = $instance;
        }

        return $instance;
    }

    /**
     * Automatically create class.
     * Object will be cached if the $arguments list is empty.
     *
     * @param class-string $class

     *
     * @throws AutowireException
     * @throws \Throwable
     */
    private function autowire(string $class, array $arguments, string $context = null): object
    {
        if (!(\class_exists($class) || (
            \interface_exists($class)
                &&
                (isset($this->state->injectors[$class]) || $this->binder->hasInjector($class))
        ))
        ) {
            throw new NotFoundException($this->tracer->combineTraceMessage(\sprintf(
                'Can\'t resolve `%s`: undefined class or binding `%s`.',
                $this->tracer->getRootAlias(),
                $class
            )));
        }

        // automatically create instance
        $instance = $this->createInstance($class, $arguments, $context);

        // apply registration functions to created instance
        return $arguments === []
            ? $this->registerInstance($instance)
            : $instance;
    }

    /**
     * @param mixed $target Value that was bound by user.
     *
     * @throws ContainerException
     * @throws \Throwable
     */
    private function evaluateBinding(
        string $alias,
        mixed $target,
        array $parameters,
        string $context = null
    ): mixed {
        if (\is_string($target)) {
            // Reference
            return $this->make($target, $parameters, $context);
        }

        if ($target instanceof Autowire) {
            return $target->resolve($this, $parameters);
        }

        try {
            return $this->invoker->invoke($target, $parameters);
        } catch (NotCallableException $e) {
            throw new ContainerException(
                $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $alias)),
                $e->getCode(),
                $e,
            );
        }
    }

    /**
     * Create instance of desired class.
     *
     * @template TObject
     *
     * @param class-string<TObject> $class

     * @param array $parameters Constructor parameters.
     *
     * @return TObject
     *
     * @throws ContainerException
     * @throws \Throwable
     */
    private function createInstance(string $class, array $parameters, string $context = null): object
    {
        try {
            $reflection = new \ReflectionClass($class);
        } catch (\ReflectionException $e) {
            throw new ContainerException($e->getMessage(), $e->getCode(), $e);
        }

        //We have to construct class using external injector when we know exact context
        if ($parameters === [] && $this->binder->hasInjector($class)) {
            $injector = $this->state->injectors[$reflection->getName()];

            try {
                $injectorInstance = $this->container->get($injector);

                if (!$injectorInstance instanceof InjectorInterface) {
                    throw new InjectionException(
                        \sprintf(
                            "Class '%s' must be an instance of InjectorInterface for '%s'.",
                            $injectorInstance::class,
                            $reflection->getName()
                        )
                    );
                }

                /** @var InjectorInterface<TObject> $injectorInstance */
                $instance = $injectorInstance->createInjection($reflection, $context);
                if (!$reflection->isInstance($instance)) {
                    throw new InjectionException(
                        \sprintf(
                            "Invalid injection response for '%s'.",
                            $reflection->getName()
                        )
                    );
                }

                return $instance;
            } finally {
                $this->state->injectors[$reflection->getName()] = $injector;
            }
        }

        if (!$reflection->isInstantiable()) {
            $itIs = match (true) {
                $reflection->isEnum() => 'Enum',
                             isEnum() => 'Enum',
                $reflection->isAbstract() => 'Abstract class',
                default => 'Class',
            };
            throw new ContainerException(
                $this->tracer->combineTraceMessage(\sprintf('%s `%s` can not be constructed.', $itIs, $class)),
            );
        }

        $constructor = $reflection->getConstructor();

        if ($constructor !== null) {
            try {
                $this->tracer->push(false, action: 'resolve arguments', signature: $constructor);
                $this->tracer->push(false, /** @scrutinizer ignore-type */ action: 'resolve arguments', signature: $constructor);
                $this->tracer->push(true);
                $arguments = $this->resolver->resolveArguments($constructor, $parameters);
            } catch (ValidationException $e) {
                throw new ContainerException(
                    $this->tracer->combineTraceMessage(
                        \sprintf(
                            'Can\'t resolve `%s`. %s',
                            $this->tracer->getRootAlias(),
                            $e->getMessage()
                        )
                    ),
                );
            } finally {
                $this->tracer->pop(true);
                $this->tracer->pop(false);
            }
            try {
                // Using constructor with resolved arguments
                $this->tracer->push(false, call: "$class::__construct", arguments: $arguments);
                $this->tracer->push(true);
                $instance = new $class(...$arguments);
            } catch (\TypeError $e) {
                throw new WrongTypeException($constructor, $e);
            } finally {
                $this->tracer->pop(true);
                $this->tracer->pop(false);
            }
        } else {
            // No constructor specified
            $instance = $reflection->newInstance();
        }

        return $instance;
    }

    /**
     * Register instance in container, might perform methods like auto-singletons, log populations
     * and etc.
     *
     * @template TObject of object
     *
     * @param TObject $instance Created object.
filter:
    dependency_paths: ["lib/*"]
     *
     * @return TObject
     */
    private function registerInstance(object $instance): object
    {
        //Declarative singletons
        if ($instance instanceof SingletonInterface) {
            $alias = $instance::class;
            if (!isset($this->state->bindings[$alias])) {
                $this->state->bindings[$alias] = $instance;
            }
        }

        return $instance;
    }
}

spiral / framework

Pull Request — master (#862)

Factory::autowire() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
