Spiral\Core\Internal\Proxy\ProxyClassRenderer::renderClass()

Complexity

Conditions	17
Paths	1940

Size

Total Lines	101
Code Lines	67

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	68
CRAP Score	17.0928

Importance

Changes	1
Bugs	0	Features	0

<?php
    public static function renderClass(
        \ReflectionClass $type,
        string $className,
        bool $defineOverload = false,
        bool $attachContainer = false,
    ): string {
        $traits = $defineOverload ? [
            MagicCallTrait::class,
        ] : [];

        if (\str_contains($className, '\\')) {
            $classShortName = \substr($className, \strrpos($className, '\\') + 1);
            $classNamespaceStr = 'namespace ' . \substr($className, 0, \strrpos($className, '\\')) . ';';
        } else {
            $classShortName = $className;
            $classNamespaceStr = '';
        }

        $interface = $type->getName();
        $classBody = [];
        foreach ($type->getMethods() as $method) {
            if ($method->isConstructor()) {
                throw new \LogicException('Constructor is not allowed in a proxy.');
            }

            if ($method->isDestructor()) {
                $classBody[] = self::renderMethod($method);
                continue;
            }

            $hasRefs = false;
            $return = $method->hasReturnType() && (string)$method->getReturnType() === 'void' ? '' : 'return ';
            $call = ($method->isStatic() ? '::' : '->') . $method->getName();
            $context = $method->isStatic() ? 'null' : '$this->__container_proxy_context';
            $containerStr = match (false) {
                $attachContainer => 'null',
                /** @see \Spiral\Core\Internal\Proxy\ProxyTrait::__container_proxy_container */
                $method->isStatic() => '$this->__container_proxy_container',
                default => \sprintf(
                    'throw new \Spiral\Core\Exception\Container\ContainerException(\'%s\')',
                    'Static method call is not allowed on a Proxy that was created without dynamic scope.',
                ),
            };
            $resolveStr = <<<PHP
                \\Spiral\\Core\\Internal\\Proxy\\Resolver::resolve(
                    '{$interface}',
                    {$context},
                    {$containerStr},
                )
                PHP;

            $args = [];
            foreach ($method->getParameters() as $param) {
                $hasRefs = $hasRefs || $param->isPassedByReference();
                $args[] = ($param->isVariadic() ? '...' : '') . '$' . $param->getName();
            }

            if (!$hasRefs && !$method->isVariadic()) {
                $classBody[] = self::renderMethod(
                    $method,
                    <<<PHP
                    {$return}{$resolveStr}{$call}(...\\func_get_args());
                PHP
                );
                continue;
            }

            $argsStr = \implode(', ', $args);

            if ($method->isVariadic()) {
                $classBody[] = self::renderMethod(
                    $method,
                    <<<PHP
                    {$return}{$resolveStr}{$call}($argsStr);
                PHP
                );
                continue;
            }

            $countParams = $method->getNumberOfParameters();
            $classBody[] = self::renderMethod(
                $method,
                <<<PHP
                {$return}{$resolveStr}{$call}($argsStr, ...\\array_slice(\\func_get_args(), {$countParams}));
            PHP
            );
        }
        $bodyStr = \implode("\n\n", $classBody);

        $traitsStr = $traits === [] ? '' : \implode(
            "\n    ",
            \array_map(fn (string $trait): string => 'use \\' . \ltrim($trait, '\\') . ';', $traits)
        );
        return <<<PHP
            $classNamespaceStr

            final class $classShortName implements \\$interface {
                use \Spiral\Core\Internal\Proxy\ProxyTrait;
                $traitsStr

            $bodyStr
            }