Pay::get() - Code Metrics - Inspection of "feat: thinkphp 框架 container 内置支持" - yansongda/pay - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#675)

by Songda
created 2022-09-08 10:57 UTC
Pay::get() A

↳ Parent: Pay
Complexity

Conditions	5
Paths	11
Size

Total Lines	18
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	13
c	1
b	0
f	0
dl	0
loc	18
rs	9.5222
cc	5
nc	11
nop	1
<?php

declare(strict_types=1);

namespace Yansongda\Pay;

use Closure;
use Illuminate\Container\Container as LaravelContainer;
filter:
    dependency_paths: ["lib/*"]
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use think\Container as ThinkPHPContainer;
filter:
    dependency_paths: ["lib/*"]
use Throwable;
use Yansongda\Pay\Contract\ServiceProviderInterface;
use Yansongda\Pay\Exception\ContainerException;
use Yansongda\Pay\Exception\ContainerNotFoundException;
use Yansongda\Pay\Exception\ServiceNotFoundException;
use Yansongda\Pay\Provider\Alipay;
use Yansongda\Pay\Provider\Wechat;
use Yansongda\Pay\Service\AlipayServiceProvider;
use Yansongda\Pay\Service\ConfigServiceProvider;
use Yansongda\Pay\Service\ContainerServiceProvider;
use Yansongda\Pay\Service\EventServiceProvider;
use Yansongda\Pay\Service\HttpServiceProvider;
use Yansongda\Pay\Service\LoggerServiceProvider;
use Yansongda\Pay\Service\WechatServiceProvider;

/**
 * @method static Alipay alipay(array $config = [], $container = null)
 * @method static Wechat wechat(array $config = [], $container = null)
 */
class Pay
{
    /**
     * 正常模式.
     */
    public const MODE_NORMAL = 0;

    /**
     * 沙箱模式.
     */
    public const MODE_SANDBOX = 1;

    /**
     * 服务商模式.
     */
    public const MODE_SERVICE = 2;

    /**
     * @var string[]
     */
    protected array $service = [
        AlipayServiceProvider::class,
        WechatServiceProvider::class,
    ];

    /**
     * @var string[]
     */
    private array $coreService = [
        ContainerServiceProvider::class,
        ConfigServiceProvider::class,
        LoggerServiceProvider::class,
        EventServiceProvider::class,
        HttpServiceProvider::class,
    ];

    /**
     * @var \Closure|\Psr\Container\ContainerInterface|null
     */
    private static $container = null;

    /**
     * @param \Closure|\Psr\Container\ContainerInterface|null $container
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    private function __construct(array $config, $container = null)
    {
        $this->registerServices($config, $container);
    }

    /**
     * @return mixed
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     * @throws \Yansongda\Pay\Exception\ServiceNotFoundException
     */
    public static function __callStatic(string $service, array $config)
    {
        if (!empty($config)) {
            self::config(...$config);
            self::config(/** @scrutinizer ignore-type */ ...$config);
        }

        return self::get($service);
    }

    /**
     * @param \Closure|\Psr\Container\ContainerInterface|null $container
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    public static function config(array $config = [], $container = null): bool
    {
        if (self::hasContainer() && !($config['_force'] ?? false)) {
            return false;
        }

        new self($config, $container);

        return true;
    }

    /**
     * @codeCoverageIgnore
     *
     * @param mixed $value
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    public static function set(string $name, $value): void
    {
        try {
            $container = Pay::getContainer();

            switch (true) {
                case $container instanceof LaravelContainer:
                    $container->singleton($name, $value instanceof Closure ? $value : static fn () => $value);
                                singleton($name, $value instanceof Closure ? $value : static fn () => $value);
                    break;
                case $container instanceof ThinkPHPContainer:
                    $container->delete($name);
                                delete($name);
                    $container->bind($name, $value instanceof Closure ? $value : static fn () => $value);
                                bind($name, $value instanceof Closure ? $value : static fn () => $value);
                    break;
                default:
                    if (!method_exists($container, 'set')) {
                        throw new ContainerException('Current container does NOT support `set` method');
                    }

                    $container->set($name, $value);
            }
        } catch (ContainerNotFoundException $e) {
            throw $e;
        } catch (Throwable $e) {
            throw new ContainerException($e->getMessage());
        }
    }

    /**
     * @return mixed
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    public static function make(string $service, array $parameters = [])
    {
        try {
            $container = Pay::getContainer();

            if (method_exists($container, 'make')) {
                return $container->make(...func_get_args());
            }
        } catch (ContainerNotFoundException $e) {
            throw $e;
        } catch (Throwable $e) {
            throw new ContainerException($e->getMessage());
        }

        $parameters = array_values($parameters);

        return new $service(...$parameters);
    }

    /**
     * @codeCoverageIgnore
     *
     * @return mixed
     *
     * @throws \Yansongda\Pay\Exception\ServiceNotFoundException
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    public static function get(string $service)
    {
        try {
            $container = Pay::getContainer();

            // thinkphp 在 `get` 中必须是已经 bind 的，否则会报错，所以这里用其 make 替代
            switch (true) {
                case $container instanceof ThinkPHPContainer:
                    return $container->make($service);
                    return $container->/** @scrutinizer ignore-call */ make($service);
                default:
                    return $container->get($service);
            }
        } catch (NotFoundExceptionInterface $e) {
            throw new ServiceNotFoundException($e->getMessage());
        } catch (ContainerNotFoundException $e) {
            throw $e;
        } catch (Throwable $e) {
            throw new ContainerException($e->getMessage());
        }
    }

    /**
     * @throws \Yansongda\Pay\Exception\ContainerNotFoundException
     */
    public static function has(string $service): bool
    {
        return Pay::getContainer()->has($service);
    }

    /**
     * @param \Closure|\Psr\Container\ContainerInterface|null $container
     */
    public static function setContainer($container): void
    {
        self::$container = $container;
    }

    /**
     * @throws \Yansongda\Pay\Exception\ContainerNotFoundException
     */
    public static function getContainer(): ContainerInterface
    {
        if (self::$container instanceof ContainerInterface) {
            return self::$container;
        }

        if (self::$container instanceof Closure) {
            return (self::$container)();
        }

        throw new ContainerNotFoundException('`getContainer()` failed! Maybe you should `setContainer()` first', Exception\Exception::CONTAINER_NOT_FOUND);
    }

    public static function hasContainer(): bool
    {
        return self::$container instanceof ContainerInterface || self::$container instanceof Closure;
    }

    public static function clear(): void
    {
        self::$container = null;
    }

    /**
     * @param mixed $data
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    public static function registerService(string $service, $data): void
    {
        $var = new $service();

        if ($var instanceof ServiceProviderInterface) {
            $var->register($data);
        }
    }

    /**
     * @param \Closure|\Psr\Container\ContainerInterface|null $container
     *
     * @throws \Yansongda\Pay\Exception\ContainerException
     */
    private function registerServices(array $config, $container = null): void
    {
        foreach (array_merge($this->coreService, $this->service) as $service) {
            self::registerService($service, ContainerServiceProvider::class == $service ? $container : $config);
        }
    }
}

yansongda / pay

Pull Request — master (#675)

Pay::get() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
