Addiks\SymfonyGenerics\Services\ArgumentCompiler

Complexity

Total Complexity

24

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

98.84%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	buildArguments()	0	29	3
B	buildCallArguments()	0	62	8
C	resolveArgumentConfiguration()	0	92	12

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 *
 * @license GPL-3.0
 *
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\SymfonyGenerics\Services;

use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
use Psr\Container\ContainerInterface;
use ErrorException;
use ReflectionParameter;
use ReflectionType;
use ReflectionMethod;
use Symfony\Component\HttpFoundation\Request;
use Webmozart\Assert\Assert;
use Addiks\SymfonyGenerics\Services\EntityRepositoryInterface;
use ReflectionClass;
use ReflectionFunctionAbstract;
use InvalidArgumentException;
use ReflectionException;

final class ArgumentCompiler implements ArgumentCompilerInterface
{

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var EntityRepositoryInterface
     */
    private $entityRepository;

    public function __construct(
        ContainerInterface $container,
        EntityRepositoryInterface $entityRepository
    ) {
        $this->container = $container;
        $this->entityRepository = $entityRepository;
    }

    public function buildArguments(
        array $argumentsConfiguration,
        Request $request
    ): array {
        /** @var array<int, mixed> $routeArguments */
        $routeArguments = array();

        foreach ($argumentsConfiguration as $key => $argumentConfiguration) {
            /** @var array|string $argumentConfiguration */

            /** @var string|null $parameterTypeName */
            $parameterTypeName = null;

            if (isset($argumentConfiguration['entity-class'])) {
                $parameterTypeName = $argumentConfiguration['entity-class'];
            }

            /** @var mixed $argumentValue */
            $argumentValue = $this->resolveArgumentConfiguration(
                $argumentConfiguration,
                $request,
                $parameterTypeName
            );

            $routeArguments[$key] = $argumentValue;
        }

        return $routeArguments;
    }

    public function buildCallArguments(
        ReflectionFunctionAbstract $routineReflection,
        array $argumentsConfiguration,
        Request $request
    ): array {
        /** @var array<int, mixed> $callArguments */
        $callArguments = array();

        foreach ($routineReflection->getParameters() as $index => $parameterReflection) {
            /** @var ReflectionParameter $parameterReflection */

            /** @var string $parameterName */
            $parameterName = $parameterReflection->getName();

Consider using $parameterReflection->name. There is an issue with getName() and APC-enabled PHP versions.

            /** @var mixed $requestValue */
            $requestValue = $request->get($parameterName);

            if (isset($argumentsConfiguration[$parameterName])) {
                /** @var array|string $argumentConfiguration */
                $argumentConfiguration = $argumentsConfiguration[$parameterName];

                Assert::true(is_string($argumentConfiguration) || is_array($argumentConfiguration));

                /** @var string|null $parameterTypeName */
                $parameterTypeName = null;

                if ($parameterReflection->hasType()) {
                    /** @var ReflectionType|null $parameterType */
                    $parameterType = $parameterReflection->getType();

                    if ($parameterType instanceof ReflectionType) {

The class ReflectionType does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json?

                        $parameterTypeName = $parameterType->__toString();
                    }
                }

                /** @var mixed $argumentValue */
                $argumentValue = $this->resolveArgumentConfiguration(
                    $argumentConfiguration,
                    $request,
                    $parameterTypeName
                );

                $callArguments[$index] = $argumentValue;

            } elseif (!is_null($requestValue)) {
                $callArguments[$index] = $requestValue;

            } else {
                try {
                    $callArguments[$index] = $parameterReflection->getDefaultValue();

                } catch (ReflectionException $exception) {
                    throw new InvalidArgumentException(sprintf(
                        "Missing argument '%s' for this call!",
                        $parameterName
                    ));
                }
            }
        }

        return $callArguments;
    }

    /**
     * @param array|string $argumentConfiguration
     *
     * @return mixed
     */
    private function resolveArgumentConfiguration(
        $argumentConfiguration,
        Request $request,
        ?string $parameterTypeName
    ) {
        /** @var mixed $argumentValue */
        $argumentValue = null;

        if (is_array($argumentConfiguration)) {
            if (isset($argumentConfiguration['id'])) {
                $argumentValue = $this->container->get($argumentConfiguration['id']);
                Assert::object($argumentValue, sprintf(
                    "Did not find service '%s'!",
                    $argumentConfiguration['id']
                ));
            }

            if (isset($argumentConfiguration['method'])) {
                $methodReflection = new ReflectionMethod($argumentValue, $argumentConfiguration['method']);

                if (!isset($argumentConfiguration['arguments'])) {
                    $argumentConfiguration['arguments'] = [];
                }

                /** @var array $callArguments */
                $callArguments = $this->buildCallArguments(
                    $methodReflection,
                    $argumentConfiguration['arguments'],
                    $request
                );

                $argumentValue = $methodReflection->invokeArgs($argumentValue, $callArguments);
            }

        } else {
            if (is_int(strpos($argumentConfiguration, '::'))) {
                [$factoryClass, $factoryMethod] = explode('::', $argumentConfiguration);

The variable $factoryClass does not exist. Did you forget to declare it?

The variable $factoryMethod does not exist. Did you forget to declare it?

                if (!empty($factoryClass)) {
                    if ($factoryClass[0] == '@') {
                        /** @var string $factoryServiceId */
                        $factoryServiceId = substr($factoryClass, 1);

                        /** @var object|null $factoryObject */
                        $factoryObject = $this->container->get($factoryServiceId);

                        Assert::methodExists($factoryObject, $factoryMethod, sprintf(
                            "Did not find service with id '%s' that has a method '%s'!",
                            $factoryServiceId,
                            $factoryMethod
                        ));

                        $factoryReflection = new ReflectionClass($factoryObject);

                        /** @var ReflectionMethod $methodReflection */
                        $methodReflection = $factoryReflection->getMethod($factoryMethod);

                        $callArguments = $this->buildCallArguments(
                            $methodReflection,
                            [], # TODO
                            $request
                        );

                        # Create by factory-service-object
                        $argumentValue = call_user_func_array([$factoryObject, $factoryMethod], $callArguments);

                    } else {
                        # Create by static factory-method of other class
                        $argumentValue = call_user_func_array($argumentConfiguration, []);
                    }

                } else {
                    # TODO: What to do here? What could "::Something" be? A template?
                }

            } elseif ($argumentConfiguration[0] == '$') {
                $argumentValue = $request->get(substr($argumentConfiguration, 1));

            } elseif ($argumentConfiguration[0] == '@') {
                $argumentValue = $this->container->get(substr($argumentConfiguration, 1));
            }
        }

        if (!empty($parameterTypeName)) {
            if (class_exists($parameterTypeName)) {
                $argumentValue = $this->entityRepository->findEntity($parameterTypeName, $argumentValue);
                # TODO: error handling "not an entty", "entity not found", ...
            }
        }

        return $argumentValue;
    }

}