CybozuHttp\Config

Complexity

Total Complexity

35

Size/Duplication

Total Lines	236
Duplicated Lines	0 %

Test Coverage

Coverage

78.82%

Importance

Changes	4
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	hasRequired()	0	11	5
A	getConfig()	0	3	1
A	getBaseUri()	0	14	3
A	hasRequiredOnCert()	0	3	1
A	hasRequiredOnAuth()	0	7	3
A	toGuzzleConfig()	0	19	4
A	__construct()	0	13	2
A	configureBasicAuth()	0	4	2
A	hasKeysByUse()	0	13	4
A	getBasicAuthOptions()	0	9	2
A	hasRequiredOnBasicAuth()	0	3	1
A	configureAuth()	0	7	2
A	getCertOptions()	0	9	2
A	get()	0	3	1
A	configureCert()	0	7	2

<?php

namespace CybozuHttp;

use CybozuHttp\Exception\NotExistRequiredException;
use CybozuHttp\Middleware\FinishMiddleware;
use GuzzleHttp\HandlerStack;

/**
 * @author ochi51 <ochiai07@gmail.com>
 */
class Config
{

    /**
     * @var array $config
     */
    private $config;

    /**
     * @var array $default
     */
    private static $default = [
        'domain' => 'cybozu.com',
        'use_api_token' => false,
        'use_basic' => false,
        'use_client_cert' => false,
        'base_uri' => null,
        'concurrency' => 1,
        'response_middleware' => true,
        'debug' => false
    ];

    /**
     * @var array $required
     */
    private static $required = [
        'handler',
        'domain',
        'subdomain',
        'use_api_token',
        'use_basic',
        'use_client_cert',
        'base_uri',
        'debug'
    ];

    /**
     * Config constructor.
     * @param array $config
     */
    public function __construct(array $config)
    {
        $this->config = array_merge(self::$default, $config);

        $this->config['base_uri'] = $this->getBaseUri();
        $this->config['handler'] = $handler = $config['handler'] ?? HandlerStack::create();

        $this->configureAuth();
        $this->configureBasicAuth();
        $this->configureCert();

        if ($this->config['response_middleware']) {
            $handler->before('http_errors', new FinishMiddleware(), 'cybozu_http.finish');
        }
    }


    private function configureAuth(): void
    {
        if ($this->get('use_api_token')) {
            $this->config['headers']['X-Cybozu-API-Token'] = $this->get('token');
        } else {
            $this->config['headers']['X-Cybozu-Authorization'] =
                base64_encode($this->get('login') . ':' . $this->get('password'));
        }
    }

    private function configureBasicAuth(): void
    {
        if ($this->get('use_basic')) {
            $this->config['auth'] = $this->getBasicAuthOptions();
        }
    }

    private function configureCert(): void
    {
        if ($this->get('use_client_cert')) {
            $this->config['verify'] = true;
            $this->config['cert'] = $this->getCertOptions();
        } else {
            $this->config['verify'] = false;
        }
    }

    /**
     * @return array
     * @throws NotExistRequiredException
     */
    private function getBasicAuthOptions(): array
    {
        if ($this->hasRequiredOnBasicAuth()) {
            return [
                $this->get('basic_login'),
                $this->get('basic_password')
            ];
        }
        throw new NotExistRequiredException('kintone.empty_basic_password');
    }

    /**
     * @return array
     * @throws NotExistRequiredException
     */
    private function getCertOptions(): array
    {
        if ($this->hasRequiredOnCert()) {
            return [
                $this->get('cert_file'),
                $this->get('cert_password')
            ];
        }
        throw new NotExistRequiredException('kintone.empty_cert');
    }

    /**
     * @return array
     */
    public function toGuzzleConfig(): array
    {
        $config = [
            'handler' => $this->get('handler'),
            'base_uri' => $this->get('base_uri'),
            'headers' => $this->get('headers'),
            'debug' => $this->get('debug') ? fopen($this->get('logfile'), 'ab') : false,

It seems like $this->get('logfile') can also be of type boolean; however, parameter $filename of fopen() does only seem to accept string, maybe add an additional type check?

            'concurrency' => $this->get('concurrency'),
            'timeout' => $this->get('timeout')
        ];
        if ($this->get('auth')) {
            $config['auth'] = $this->get('auth');
        }
        $config['verify'] = $this->get('verify');
        if ($this->get('cert')) {
            $config['cert'] = $this->get('cert');
        }

        return $config;
    }

    /**
     * @param $key
     * @return string|bool
     */
    public function get($key)
    {
        return $this->config[$key] ?? false;
    }

    /**
     * @return array
     */
    public function getConfig(): array
    {
        return $this->config;
    }

    /**
     * @return bool
     */
    public function hasRequired(): bool
    {
        foreach (self::$required as $r) {
            if (!array_key_exists($r, $this->config)) {
                return false;
            }
        }

        return $this->hasRequiredOnAuth()
                && $this->hasRequiredOnBasicAuth()
                && $this->hasRequiredOnCert();
    }

    /**
     * @return bool
     */
    private function hasRequiredOnAuth(): bool
    {
        if ($this->get('use_api_token')) {
            return !empty($this->get('token'));
        }

        return $this->get('login') && $this->get('password');
    }

    /**
     * @return bool
     */
    private function hasRequiredOnBasicAuth(): bool
    {
        return $this->hasKeysByUse('use_basic', ['basic_login', 'basic_password']);
    }

    /**
     * @return bool
     */
    private function hasRequiredOnCert(): bool
    {
        return $this->hasKeysByUse('use_client_cert', ['cert_file', 'cert_password']);
    }

    /**
     * @param string $use
     * @param string[] $keys
     * @return bool
     */
    private function hasKeysByUse($use, array $keys): bool
    {
        if (!$this->get($use)) {
            return true;
        }

        foreach ($keys as $key) {
            if (!$this->get($key)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return string
     */
    public function getBaseUri(): string
    {
        $subdomain = $this->get('subdomain');
        $uri = 'https://'. $subdomain;

        if (strpos($subdomain, '.') === false) {

It seems like $subdomain can also be of type boolean; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

            if ($this->get('use_client_cert')) {
                $uri .= '.s';
            }

            $uri .= '.'. $this->get('domain');
        }

        return $uri;
    }
}