Tebru\Retrofit\Internal\DefaultProxyFactory::create()

Complexity

Conditions	20
Paths	661

Size

Total Lines	136
Code Lines	78

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	78
CRAP Score	20

Importance

Changes

0

<?php
    public function create(string $service): ?Proxy
    {
        $className = self::PROXY_PREFIX.$service;
        if ($this->enableCache && class_exists($className)) {
            return new $className($this->serviceMethodFactory, $this->httpClient);
        }

        if (!$this->enableCache && class_exists($className, false)) {
            return new $className($this->serviceMethodFactory, $this->httpClient);
        }

        if (!interface_exists($service)) {
            throw new InvalidArgumentException(sprintf('Retrofit: %s is expected to be an interface', $service));
        }

        /** @noinspection ExceptionsAnnotatingAndHandlingInspection */
        $reflectionClass = new ReflectionClass($service);
        $builder = $this->builderFactory
            ->class($reflectionClass->getShortName())
            ->extend('\\'.AbstractProxy::class)
            ->implement('\\'.$reflectionClass->name);

        foreach ($reflectionClass->getMethods() as $reflectionMethod) {
            $methodBuilder = $this->builderFactory
                ->method($reflectionMethod->name)
                ->makePublic();

            if ($reflectionMethod->isStatic()) {
                $methodBuilder->makeStatic();
            }

            $defaultValues = [];

            foreach ($reflectionMethod->getParameters() as $reflectionParameter) {
                $paramBuilder = $this->builderFactory->param($reflectionParameter->name);

                if ($reflectionParameter->isDefaultValueAvailable()) {
                    $paramBuilder->setDefault($reflectionParameter->getDefaultValue());
                }

                if ($reflectionParameter->getType() === null) {
                    throw new LogicException(sprintf(
                        'Retrofit: Parameter types are required. None found for parameter %s in %s::%s()',
                        $reflectionParameter->name,
                        $reflectionClass->name,
                        $reflectionMethod->name
                    ));
                }

                $reflectionTypeName = (string)$reflectionParameter->getType();
                if ((new TypeToken($reflectionTypeName))->isObject()) {
                    $reflectionTypeName = '\\'.$reflectionTypeName;
                }

                $type = $reflectionParameter->getType()->allowsNull() ? new NullableType($reflectionTypeName): $reflectionTypeName;
                $paramBuilder->setTypeHint($type);

                if ($reflectionParameter->isPassedByReference()) {
                    $paramBuilder->makeByRef();
                }

                if ($reflectionParameter->isVariadic()) {
                    $paramBuilder->makeVariadic();
                }

                $methodBuilder->addParam($paramBuilder->getNode());

                // set all default values
                // if a method is called with two few arguments, a native exception will be thrown
                // so we can safely use null as a placeholder here.
                $defaultValues[] = $reflectionParameter->isDefaultValueAvailable()
                    ? $reflectionParameter->getDefaultValue()
                    : null;
            }

            if (!$reflectionMethod->hasReturnType()) {
                throw new LogicException(sprintf(
                    'Retrofit: Method return types are required. None found for %s::%s()',
                    $reflectionClass->name,
                    $reflectionMethod->name
                ));
            }

            /** @noinspection NullPointerExceptionInspection */
            $methodBuilder->setReturnType('\\'.(string)$reflectionMethod->getReturnType());

            $defaultNodes = $this->mapArray($defaultValues);

            $methodBuilder->addStmt(
                new Return_(
                    new MethodCall(
                        new Variable('this'),
                        '__handleRetrofitRequest',
                        [
                            new String_($reflectionClass->name),
                            new ConstFetch(new Name('__FUNCTION__')),
                            new FuncCall(new Name('func_get_args')),
                            new Array_($defaultNodes)
                        ]
                    )
                )
            );

            $builder->addStmt($methodBuilder->getNode());
        }

        $namespaceBuilder = $this->builderFactory
            ->namespace(self::PROXY_PREFIX.$reflectionClass->getNamespaceName())
            ->addStmt($builder);

        $source = $this->printer->prettyPrint([$namespaceBuilder->getNode()]);

        eval($source);

        if (!$this->enableCache) {
            return new $className($this->serviceMethodFactory, $this->httpClient);
        }

        $directory = $this->cacheDir.DIRECTORY_SEPARATOR.$reflectionClass->getNamespaceName();
        $directory = str_replace('\\', DIRECTORY_SEPARATOR, $directory);
        $filename = $directory.DIRECTORY_SEPARATOR.$reflectionClass->getShortName().'.php';

        $class = '<?php'.PHP_EOL.PHP_EOL.$source;
        if (!$this->filesystem->makeDirectory($directory)) {
            throw new RuntimeException(sprintf(
                'Retrofit: There was an issue creating the cache directory: %s',
                $directory)
            );
        }

        if (!$this->filesystem->put($filename, $class)) {
            throw new RuntimeException(sprintf('Retrofit: There was an issue writing proxy class to: %s', $filename));
        }

        return new $className($this->serviceMethodFactory, $this->httpClient);
    }