Coduo\TuTu\Config\Element\Request

Complexity

Total Complexity

21

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	fromArray()	0	14	1
A	setAllowedMethods()	0	6	1
A	getAllowedMethods()	0	4	1
A	getPath()	0	4	1
A	hasBodyParameters()	0	4	1
A	setBodyParameters()	0	4	1
A	getBodyParameters()	0	4	1
A	hasQueryParameters()	0	4	1
A	setQueryParameters()	0	4	1
A	getQueryParameters()	0	4	1
A	hasHeaders()	0	4	1
A	setHeaders()	0	4	1
A	getHeaders()	0	4	1
A	hasBody()	0	4	1
A	setBody()	0	4	1
A	getBody()	0	4	1
A	validatePath()	0	10	3
A	createArrayConfigResolver()	0	20	1

<?php

namespace Coduo\TuTu\Config\Element;

use Symfony\Component\OptionsResolver\OptionsResolver;

class Request
{
    /**
     * @var string
     */
    private $path;

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

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

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

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

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

    /**
     * @param $path
     */
    public function __construct($path)
    {
        $this->validatePath($path);
        $this->path = $path;
        $this->allowedMethods = [];
        $this->request = [];
        $this->query = [];
        $this->headers = [];
        $this->body = '';
    }

    public static function fromArray(array $arrayConfig)
    {
        $configResolver = self::createArrayConfigResolver();
        $config = $configResolver->resolve($arrayConfig);
        $responseConfig = new Request($config['path']);

        $responseConfig->setAllowedMethods($config['methods']);
        $responseConfig->setBodyParameters($config['request']);
        $responseConfig->setQueryParameters($config['query']);
        $responseConfig->setHeaders($config['headers']);
        $responseConfig->setBody($config['body']);

        return $responseConfig;
    }

    /**
     * @param $methods
     */
    public function setAllowedMethods($methods)
    {
        $this->allowedMethods = array_map(function ($method) {
            return strtoupper($method);
        }, $methods);
    }

    /**
     * @return array
     */
    public function getAllowedMethods()
    {
        return $this->allowedMethods;
    }

    /**
     * @return string
     */
    public function getPath()
    {
        return '/' . ltrim($this->path, '/');
    }

    /**
     * @return bool
     */
    public function hasBodyParameters()
    {
        return (boolean) count($this->request);
    }

    /**
     * @param $parameters
     */
    public function setBodyParameters($parameters)
    {
        $this->request = $parameters;
    }

    /**
     * @return array
     */
    public function getBodyParameters()
    {
        return $this->request;
    }

    /**
     * @return bool
     */
    public function hasQueryParameters()
    {
        return (boolean) count($this->query);
    }

    /**
     * @param $parameters
     */
    public function setQueryParameters($parameters)
    {
        $this->query = $parameters;
    }

    /**
     * @return array
     */
    public function getQueryParameters()
    {
        return $this->query;
    }

    /**
     * @return boolean
     */
    public function hasHeaders()
    {
        return (boolean) count($this->headers);
    }

    /**
     * @param array $headers
     */
    public function setHeaders($headers)
    {
        $this->headers = $headers;
    }

    /**
     * @return array
     */
    public function getHeaders()
    {
        return $this->headers;
    }

    /**
     * @return bool
     */
    public function hasBody()
    {
        return !empty($this->body);
    }

    /**
     * @param string $body
     */
    public function setBody($body)
    {
        $this->body = $body;
    }

    /**
     * @return string
     */
    public function getBody()
    {
        return $this->body;
    }

    /**
     * @param $path
     * @throws \InvalidArgumentException
     */
    private function validatePath($path)
    {
        if (!is_string($path)) {
            throw new \InvalidArgumentException("Path must be a valid string.");
        }

        if (empty($path)) {
            throw new \InvalidArgumentException("Path can't be empty.");
        }
    }

    /**
     * @return OptionsResolver
     */
    private static function createArrayConfigResolver()
    {
        $configResolver = new OptionsResolver();
        $configResolver->setRequired(['path']);
        $configResolver->setDefaults([
            'methods' => [],
            'request' => [],
            'query' => [],
            'headers' => [],
            'body' => ''
        ]);
        $configResolver->setAllowedTypes('path', 'string');
        $configResolver->setAllowedTypes('methods', 'array');
        $configResolver->setAllowedTypes('request', 'array');
        $configResolver->setAllowedTypes('query', 'array');
        $configResolver->setAllowedTypes('headers', 'array');
        $configResolver->setAllowedTypes('body', 'string');

        return $configResolver;
    }
}