Esi\IPQuery\HttpClient\Builder

Complexity

Total Complexity

14

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getUriFactory()	0	3	1
A	getStreamFactory()	0	3	1
A	removeCache()	0	4	1
A	__construct()	0	10	1
A	removePlugin()	0	14	4
A	addPlugin()	0	4	1
A	addCache()	0	4	1
A	getRequestFactory()	0	3	1
A	getHttpClient()	0	17	3

<?php

declare(strict_types=1);

/**
 * This file is part of Esi\IPQuery.
 *
 * (c) Eric Sizemore <admin@secondversion.com>
 *
 * This source file is subject to the MIT license. For the full copyright and
 * license information, please view the LICENSE file that was distributed with
 * this source code.
 */

namespace Esi\IPQuery\HttpClient;

use Http\Client\Common\HttpMethodsClient;
use Http\Client\Common\HttpMethodsClientInterface;
use Http\Client\Common\Plugin;
use Http\Client\Common\Plugin\CachePlugin;
use Http\Client\Common\PluginClientFactory;
use Http\Discovery\Psr17FactoryDiscovery;
use Http\Discovery\Psr18ClientDiscovery;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UriFactoryInterface;

/**
 * The HTTP client builder class.
 */
final class Builder
{
    private ?CachePlugin $cachePlugin = null;

    private readonly ClientInterface $httpClient;

    private ?HttpMethodsClientInterface $httpMethodsClient = null;

    /**
     * @var array<Plugin>
     */
    private array $plugins = [];

    private readonly RequestFactoryInterface $requestFactory;

    private readonly StreamFactoryInterface $streamFactory;

    private readonly UriFactoryInterface $uriFactory;

    /**
     * Create a new client builder instance.
     */
    public function __construct(
        ?ClientInterface $httpClient = null,
        ?RequestFactoryInterface $requestFactory = null,
        ?StreamFactoryInterface $streamFactory = null,
        ?UriFactoryInterface $uriFactory = null
    ) {
        $this->httpClient     = $httpClient ?? Psr18ClientDiscovery::find();

The property httpClient is declared read-only in Esi\IPQuery\HttpClient\Builder.

        $this->requestFactory = $requestFactory ?? Psr17FactoryDiscovery::findRequestFactory();

The property requestFactory is declared read-only in Esi\IPQuery\HttpClient\Builder.

        $this->streamFactory  = $streamFactory ?? Psr17FactoryDiscovery::findStreamFactory();

The property streamFactory is declared read-only in Esi\IPQuery\HttpClient\Builder.

        $this->uriFactory     = $uriFactory ?? Psr17FactoryDiscovery::findUriFactory();

The property uriFactory is declared read-only in Esi\IPQuery\HttpClient\Builder.

    }

    /**
     * @template T
     *
     * @param array<array-key, T> $config

The doc comment array<array-key, T> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, T>.

     */
    public function addCache(CacheItemPoolInterface $cacheItemPool, array $config = []): void
    {
        $this->cachePlugin       = CachePlugin::clientCache($cacheItemPool, $this->streamFactory, $config);
        $this->httpMethodsClient = null;
    }

    public function addPlugin(Plugin $plugin): void
    {
        $this->plugins[]         = $plugin;
        $this->httpMethodsClient = null;
    }

    public function getHttpClient(): HttpMethodsClientInterface
    {
        if (\is_null($this->httpMethodsClient)) {
            $plugins = $this->plugins;

            if (!\is_null($this->cachePlugin)) {
                $plugins[] = $this->cachePlugin;
            }

            $this->httpMethodsClient = new HttpMethodsClient(
                (new PluginClientFactory())->createClient($this->httpClient, $plugins),
                $this->requestFactory,
                $this->streamFactory
            );
        }

        return $this->httpMethodsClient;

The expression return $this->httpMethodsClient could return the type null which is incompatible with the type-hinted return Http\Client\Common\HttpMethodsClientInterface. Consider adding an additional type-check to rule them out.

    }

    public function getRequestFactory(): RequestFactoryInterface
    {
        return $this->requestFactory;
    }

    public function getStreamFactory(): StreamFactoryInterface
    {
        return $this->streamFactory;
    }

    public function getUriFactory(): UriFactoryInterface
    {
        return $this->uriFactory;
    }

    public function removeCache(): void
    {
        $this->cachePlugin       = null;
        $this->httpMethodsClient = null;
    }

    /**
     * @param class-string<Plugin> $pluginClassName

The doc comment class-string<Plugin> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<Plugin>.

     */
    public function removePlugin(string $pluginClassName): void
    {
        $pluginRemoved = false;

        foreach ($this->plugins as $key => $plugin) {
            if ($plugin instanceof $pluginClassName) {
                unset($this->plugins[$key]);

                $pluginRemoved = true;
            }
        }

        if ($pluginRemoved) {
            $this->httpMethodsClient = null;
        }
    }
}