ContainerInterfaceProxy::has() - Code Metrics - Inspection of "Debug server" - yiisoft/yii-debug - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#225)

by Alexander
created 2024-07-07 04:37 UTC
ContainerInterfaceProxy::has() A

↳ Parent: ContainerInterfaceProxy
Complexity

Conditions	2
Paths	4
Size

Total Lines	15
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	7
CRAP Score	2.0438
Importance

Changes
Metric	Value
cc	2
dl	0
loc	15
rs	9.9332
c	0
b	0
f	0
eloc	10
nc	4
nop	1
ccs	7
cts	9
cp	0.7778
crap	2.0438
<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Collector;

use Exception;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Yiisoft\Proxy\ProxyManager;
use Yiisoft\Proxy\ProxyTrait;

use function is_callable;
use function is_object;
use function is_string;

final class ContainerInterfaceProxy implements ContainerInterface
{
    use ProxyLogTrait;
    use ProxyTrait;

    public const LOG_NOTHING = 0;
    public const LOG_ARGUMENTS = 1;
    public const LOG_RESULT = 2;
    public const LOG_ERROR = 4;

    private ProxyManager $proxyManager;

    private array $serviceProxy = [];

    public function __construct(protected ContainerInterface $container, ContainerProxyConfig $config)
    {
        $this->config = $config;
        $this->proxyManager = new ProxyManager($this->config->getProxyCachePath());
    }

    public function withDecoratedServices(array $decoratedServices): self
    {
        $new = clone $this;
        $new->config = $this->config->withDecoratedServices($decoratedServices);
        return $new;
    }

    public function get($id): mixed
    {
        $this->resetCurrentError();
        $timeStart = microtime(true);
        $instance = null;

        try {
            $instance = $this->getInstance($id);
        } catch (ContainerExceptionInterface $e) {
            $this->repeatError($e);
        } finally {
            $this->logProxy(ContainerInterface::class, $this->container, 'get', [$id], $instance, $timeStart);
            $this->logProxy(ContainerInterface::class, $this->container, 'get', [$id], $instance, /** @scrutinizer ignore-type */ $timeStart);
        }

        if (is_object($instance) && ($proxy = $this->getServiceProxy($id, $instance))) {
            $this->setServiceProxyCache($id, $proxy);
            return $proxy;
        }

        return $instance;
    }

    /**
     * @throws ContainerExceptionInterface
     */
    private function getInstance(string $id): mixed
    {
        if ($id === ContainerInterface::class) {
            return $this;
        }

        return $this->container->get($id);
    }

    private function isDecorated(string $service): bool
    {
        return $this->isActive() && $this->config->hasDecoratedService($service);
    }

    public function isActive(): bool
    {
        return $this->config->getIsActive() && $this->config->getDecoratedServices() !== [];
    }

    private function getServiceProxy(string $service, object $instance): ?object
    {
        if (isset($this->serviceProxy[$service])) {
            return $this->serviceProxy[$service];
        }

        if (!$this->isDecorated($service)) {
            return null;
        }

        if ($this->config->hasDecoratedServiceCallableConfig($service)) {
            return $this->getServiceProxyFromCallable($this->config->getDecoratedServiceConfig($service), $instance);
        }

        if ($this->config->hasDecoratedServiceArrayConfigWithStringKeys($service)) {
            return $this->getCommonMethodProxy(
                interface_exists($service) || class_exists($service) ? $service : $instance::class,
                $instance,
                $this->config->getDecoratedServiceConfig($service)
            );
        }

        if ($this->config->hasDecoratedServiceArrayConfig($service)) {
            return $this->getServiceProxyFromArray($instance, $this->config->getDecoratedServiceConfig($service));
        }

        if (interface_exists($service) && ($this->config->hasCollector() || $this->config->hasDispatcher())) {
            return $this->getCommonServiceProxy($service, $instance);
        }

        return null;
    }

    private function getServiceProxyFromCallable(callable $callback, object $instance): ?object
    {
        return $callback($this, $instance);
    }

    /**
     * @psalm-param class-string $service
     */
    private function getCommonMethodProxy(string $service, object $instance, array $callbacks): ?object
    {
        $methods = [];
        foreach ($callbacks as $method => $callback) {
            if (is_string($method) && is_callable($callback)) {
                $methods[$method] = $callback;
            }
        }

        return $this->proxyManager->createObjectProxy(
            $service,
            ServiceMethodProxy::class,
            [$service, $instance, $methods, $this->config]
        );
    }

    private function getServiceProxyFromArray(object $instance, array $params): ?object
    {
        try {
            $proxyClass = array_shift($params);
            foreach ($params as $index => $param) {
                if (is_string($param)) {
                    try {
                        $params[$index] = $this->get($param);
                    } catch (Exception) {
                        //leave as is
                    }
                }
            }
            return new $proxyClass($instance, ...$params);
        } catch (Exception) {
            return null;
        }
    }

    /**
     * @psalm-param class-string $service
     */
    private function getCommonServiceProxy(string $service, object $instance): object
    {
        return $this->proxyManager->createObjectProxy(
            $service,
            ServiceProxy::class,
            [$service, $instance, $this->config]
        );
    }

    private function setServiceProxyCache(string $service, object $instance): void
    {
        $this->serviceProxy[$service] = $instance;
    }

    /**
     * @psalm-suppress InvalidCatch
     */
    public function has($id): bool
    {
        $this->resetCurrentError();
        $timeStart = microtime(true);
        $result = null;


        try {
            $result = $this->container->has($id);
        } catch (ContainerExceptionInterface $e) {
            $this->repeatError($e);
        } finally {
            $this->logProxy(ContainerInterface::class, $this->container, 'has', [$id], $result, $timeStart);
            $this->logProxy(ContainerInterface::class, $this->container, 'has', [$id], $result, /** @scrutinizer ignore-type */ $timeStart);
        }

        return (bool)$result;
    }
}

yiisoft / yii-debug

Pull Request — master (#225)

ContainerInterfaceProxy::has() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
