IBM\Watson\Common\HttpClient\Builder

Complexity

Total Complexity

25

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	3
A	createConfiguredClient()	0	9	1
A	withUsername()	0	6	1
A	withPassword()	0	6	1
A	withCredentials()	0	6	1
A	withHost()	0	6	1
A	withVersion()	0	6	1
A	withPath()	0	6	1
A	addPlugin()	0	8	2
A	getHostUri()	0	4	1
A	validateVersion()	0	6	2
A	addHostPlugin()	0	8	2
A	addAuthenticationPlugin()	0	8	3
A	addVersionQueryPlugin()	0	16	3
A	addPathPlugin()	0	8	2

<?php

declare(strict_types=1);

namespace IBM\Watson\Common\HttpClient;

use DateTime;
use Http\Client\Common\Plugin;
use Http\Client\Common\Plugin\AuthenticationPlugin;
use Http\Client\Common\PluginClient;
use Http\Client\HttpClient;
use Http\Message\Authentication\BasicAuth;
use Http\Message\UriFactory;
use IBM\Watson\Common\Exception\Api\InvalidArgumentException;
use IBM\Watson\Common\Util\DiscoveryTrait;
use Psr\Http\Message\UriInterface;

/**
 * HttpClient builder
 */
final class Builder
{
    use DiscoveryTrait;

    /**
     * @var \Http\Client\HttpClient|null
     */
    private $httpClient;

    /**
     * @var \Http\Message\UriFactory|null
     */
    private $uriFactory;

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

    /**
     * @var string
     */
    private $username;

    /**
     * @var string
     */
    private $password;

    /**
     * @var string
     */
    private $host;

    /**
     * @var string
     */
    private $path;

    /**
     * @var string
     */
    private $version;

    /**
     * @param \Http\Client\HttpClient|null  $httpClient
     * @param \Http\Message\UriFactory|null $uriFactory
     */
    public function __construct(
        HttpClient $httpClient = null,
        UriFactory $uriFactory = null
    ) {
        $this->httpClient = $httpClient ?: $this->discoverHttpClient();
        $this->uriFactory = $uriFactory ?: $this->discoverUriFactory();
    }

    /**
     * Create a configured HTTP client
     *
     * @return \Http\Client\Common\PluginClient
     * @throws \Exception
     */
    public function createConfiguredClient(): PluginClient
    {
        $this->addHostPlugin();
        $this->addPathPlugin();
        $this->addVersionQueryPlugin();
        $this->addAuthenticationPlugin();

        return new PluginClient($this->httpClient, $this->plugins);

It seems like $this->httpClient can be null; however, __construct() does not accept null, maybe add an additional type check?

    }

    /**
     * Add username to client
     *
     * @param string $username
     *
     * @return $this
     */
    public function withUsername(string $username): self
    {
        $this->username = $username;

        return $this;
    }

    /**
     * Add password to client
     *
     * @param string $password
     *
     * @return $this
     */
    public function withPassword(string $password): self
    {
        $this->password = $password;

        return $this;
    }

    /**
     * Add username and password to client
     *
     * @param string $username
     * @param string $password
     *
     * @return \IBM\Watson\Common\HttpClient\Builder
     */
    public function withCredentials(string $username, string $password): self
    {
        return $this
            ->withUsername($username)
            ->withPassword($password);
    }

    /**
     * @param string $host
     *
     * @return $this
     */
    public function withHost(string $host): self
    {
        $this->host = $host;

        return $this;
    }

    /**
     * @param string $version
     *
     * @return $this
     */
    public function withVersion($version): self
    {
        $this->version = $version;

        return $this;
    }

    /**
     * @param string $path
     *
     * @return $this
     */
    public function withPath(string $path): self
    {
        $this->path = $path;

        return $this;
    }

    /**
     * @param \Http\Client\Common\Plugin ...$plugins
     *
     * @return $this
     */
    public function addPlugin(Plugin ...$plugins): self
    {
        foreach ($plugins as $plugin) {
            $this->plugins[] = $plugin;
        }

        return $this;
    }

    /**
     * @return \Psr\Http\Message\UriInterface
     */
    private function getHostUri(): UriInterface
    {
        return $this->uriFactory->createUri($this->host);
    }

    /**
     * @param string $version
     *
     * @return boolean
     */
    private function validateVersion($version): bool
    {
        $date = DateTime::createFromFormat('Y-m-d', $version);

        return $date && $date->format('Y-m-d') === $version;
    }

    /**
     * @return $this
     */
    private function addHostPlugin(): self
    {
        if (null !== $this->host) {
            $this->plugins[] = new Plugin\AddHostPlugin($this->getHostUri());
        }

        return $this;
    }

    /**
     * @return $this
     */
    private function addAuthenticationPlugin(): self
    {
        if (null !== $this->username && null !== $this->password) {
            $this->plugins[] = new AuthenticationPlugin(new BasicAuth($this->username, $this->password));
        }

        return $this;
    }

    /**
     * @return $this
     *
     * @throws InvalidArgumentException
     */
    private function addVersionQueryPlugin(): self
    {
        if (null === $this->version) {
            $this->version = date('Y-m-d');
        }

        if (!$this->validateVersion($this->version)) {
            throw new InvalidArgumentException('Version must be a date in the Y-m-d format');
        }

        $this->plugins[] = new Plugin\QueryDefaultsPlugin([
            'version' => $this->version
        ]);

        return $this;
    }

    /**
     * @return $this
     */
    private function addPathPlugin(): self
    {
        if (null !== $this->path) {
            $this->plugins[] = new Plugin\AddPathPlugin($this->uriFactory->createUri($this->path));
        }

        return $this;
    }
}