CrazyGoat\Octophpus\Validator\OptionsValidator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	validate()	0	11	3
A	validateRequestOptions()	0	4	1
A	validateCachePrefix()	0	4	1
A	validateConcurrency()	0	4	1
A	validateTimeout()	0	4	1
A	validateCachePool()	0	4	1
A	validateLogger()	0	4	1
A	validateBaseUri()	0	4	1
A	validateOnReject()	0	14	3
A	validateOnTimeout()	0	10	2

<?php

namespace CrazyGoat\Octophpus\Validator;

use CrazyGoat\Octophpus\Exception\InvalidOptionValueException;
use CrazyGoat\Octophpus\EsiTentacles;
use Nunzion\Expect;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Log\LoggerInterface;

class OptionsValidator implements ValidatorInterface
{
    use Camelize;
    /**
     * @var array
     */
    private $config;

    public function __construct(array $config)
    {
        $this->config = $config;
    }

    /**
     * @return bool
     * @throws InvalidOptionValueException
     * @uses validateConcurrency
     * @uses validateTimeout
     * @uses validateCachePool
     * @uses validateLogger
     * @uses validateBaseUri
     * @uses validateOnReject
     * @uses validateOnTimeout
     * @uses validateCachePrefix
     * @uses validateRequestOptions
     */
    public function validate(): bool
    {
        foreach ($this->config as $key => $value) {
            $function = 'validate'.$this->camlize($key);
            if (method_exists($this, $function)) {
                $this->$function($value);
            }
        }

        return true;
    }

    private function validateRequestOptions(array $value)
    {
        Expect::that($value)->isArray();
    }

    private function validateCachePrefix(string $value)
    {
        Expect::that($value)->isString();
    }

    private function validateConcurrency(int $value) : void
    {
        Expect::that($value)->isInt()->isGreaterThan(1);
    }

    private function validateTimeout(float $value) : void
    {
        Expect::that($value)->isFloat()->isGreaterThan(0);
    }

    private function validateCachePool(?CacheItemPoolInterface $value) : void
    {
        Expect::that($value)->isNullOrInstanceOf('Psr\Cache\CacheItemPoolInterface');
    }

    private function validateLogger(?LoggerInterface $value) : void
    {
        Expect::that($value)->isNullOrInstanceOf('sr\Log\LoggerInterface');
    }

    private function validateBaseUri(string $value) : void
    {
        Expect::that($value)->isString();
    }

    private function validateOnReject($value) : void
    {
        if (is_string($this->config['on_reject']) && !in_array($this->config['on_reject'], [
                EsiTentacles::ON_REJECT_EXCEPTION,
                EsiTentacles::ON_REJECT_EMPTY
            ])) {
            throw new InvalidOptionValueException(
                'Invalid on_reject option, valid values: '.
                EsiTentacles::ON_REJECT_EXCEPTION.', '.EsiTentacles::ON_REJECT_EMPTY.' or Closure'
            );
        } else {
            Expect::that($value)->isInstanceOf('Closure');
        }
    }

    private function validateOnTimeout(string $value) : void
    {
        Expect::that($value)->isString()->isNotEmpty();
        if (!in_array($value, [EsiTentacles::ON_TIMEOUT_EXCEPTION, EsiTentacles::ON_TIMEOUT_H_INCLUDE])) {
            throw new InvalidOptionValueException(
                'Invalid on_reject option, valid values: '.
                EsiTentacles::ON_TIMEOUT_EXCEPTION.', '.EsiTentacles::ON_TIMEOUT_H_INCLUDE
            );
        }
    }
}