Rade\DI\Injector\Injectable

Complexity

Total Complexity

23

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	11	3
A	__construct()	0	4	1
A	build()	0	13	3
B	doProperties()	0	27	8
B	getProperties()	0	32	8

<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2021 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade\DI\Injector;

use Nette\Utils\{Reflection, Type};
use PhpParser\Builder\Method;
use PhpParser\BuilderFactory;
use PhpParser\Node\Expr\{Assign, Variable};
use Rade\DI\Attribute\Inject;
use Rade\DI\Definitions\Reference;
use Rade\DI\Exceptions\ContainerResolutionException;
use Rade\DI\Resolver;

/**
 * An injectable class used by service definitions.
 *
 * @internal This is almost a final class
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
class Injectable
{
    private object $service;

    /** @var array<int,array<string,mixed>> */
    private array $properties;

    /**
     * @param array<string,array<string,mixed[]>> $properties
     */
    public function __construct(object $service, array $properties)
    {
        $this->service = $service;
        $this->properties = $properties;
    }

    public function resolve(): object
    {
        foreach ($this->properties[0] ?? [] as $property => $propertyValue) {
            $this->service->{$property} = $propertyValue;
        }

        foreach ($this->properties[1] ?? [] as $method => $methodValue) {
            \call_user_func_array([$this->service, $method], (array) $methodValue);
        }

        return $this->service;
    }

    public function build(Method $definition, Variable $service, BuilderFactory $builder): Assign
    {
        $definition->addStmt($createdService = new Assign($service, $this->service));

        foreach ($this->properties[0] ?? [] as $property => $propertyValue) {
            $definition->addStmt(new Assign($builder->propertyFetch($service, $property), $builder->val($propertyValue)));
        }

        foreach ($this->properties[1] ?? [] as $method => $methodValue) {
            $definition->addStmt($builder->methodCall($service, $method, $methodValue));
        }

        return $createdService;
    }

    /**
     * Generates list of properties with #[Inject] attributes.
     *
     * @return array<string,array<string,mixed[]>>
     */
    public static function getProperties(Resolver $resolver, object $service, \ReflectionClass $reflection): object
    {
        if (\PHP_VERSION_ID < 80000) {
            return $service;

The expression return $service returns the type object which is incompatible with the documented return type array<string,array<string,array<mixed,mixed>>>.

        }

        $properties = [];
        self::doProperties($reflection, $resolver, $properties);

        foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
            if ([] === $methodAttributes = $method->getAttributes(Inject::class)) {
                continue;
            }

            if (null === $methodAttribute = $methodAttributes[0] ?? null) {
                continue;
            }

            if ([] !== $methodAttribute->getArguments()) {
                throw new ContainerResolutionException(\sprintf('Method with Inject attributes does not support having arguments.'));
            }

            $properties[1][$method->getName()] = $resolver->autowireArguments($method);
        }

        if ([] === $properties) {
            return $service;

The expression return $service returns the type object which is incompatible with the documented return type array<string,array<string,array<mixed,mixed>>>.

        }

        $injected = new self($service, $properties);

        return null === $resolver->getBuilder() ? $injected->resolve() : $injected;

The expression return null === $resolver->getBuilder() ? $injected->resolve() : $injected returns the type Rade\DI\Injector\Injectable|object which is incompatible with the documented return type array<string,array<string,array<mixed,mixed>>>.

    }

    private static function doProperties(\ReflectionClass $reflection, Resolver $resolver, array &$properties): void
    {
        foreach ($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
            if ([] === $propertyAttributes = $property->getAttributes(Inject::class)) {
                continue;
            }

            if (null === $propertyAttribute = $propertyAttributes[0] ?? null) {
                continue;
            }

            if ([] !== $pValue = $propertyAttribute->getArguments()) {
                $properties[0][$property->getName()] = $resolver->resolve(new Reference($pValue[0]));

                continue;
            }

            if (null === $pTypes = Type::fromReflection($property)) {
                continue;
            }

            foreach ($pTypes->getNames() as $pType) {
                if (Reflection::isBuiltinType($pType)) {
                    continue;
                }

                $properties[0][$property->getName()] = $resolver->resolve(new Reference($pType));
            }
        }
    }
}