Sunrise\Http\Message\Message

Complexity

Total Complexity

37

Size/Duplication

Total Lines	291
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	setHeaders()	0	4	2
A	setProtocolVersion()	0	5	1
A	withProtocolVersion()	0	6	1
A	setBody()	0	3	1
A	validateHeaderValue()	0	17	6
A	withHeader()	0	6	1
A	withBody()	0	6	1
A	getHeaderLine()	0	9	2
A	getHeaders()	0	3	1
A	validateHeaderName()	0	12	4
A	validateProtocolVersion()	0	12	4
A	setHeader()	0	18	4
A	withoutHeader()	0	6	1
A	getHeader()	0	9	2
A	withAddedHeader()	0	6	1
A	deleteHeader()	0	7	2
A	getProtocolVersion()	0	3	1
A	getBody()	0	3	1
A	hasHeader()	0	5	1

<?php declare(strict_types=1);

/**
 * It's free open-source software released under the MIT License.
 *
 * @author Anatoly Nekhay <afenric@gmail.com>
 * @copyright Copyright (c) 2018, Anatoly Nekhay
 * @license https://github.com/sunrise-php/http-message/blob/master/LICENSE
 * @link https://github.com/sunrise-php/http-message
 */

namespace Sunrise\Http\Message;

use Psr\Http\Message\MessageInterface;
use Psr\Http\Message\StreamInterface;
use Sunrise\Http\Message\Exception\InvalidArgumentException;
use Sunrise\Http\Message\Stream\PhpTempStream;

use function implode;
use function is_array;
use function is_string;
use function preg_match;
use function strtolower;

abstract class Message implements MessageInterface
{
    /**
     * @deprecated 3.2.0
     */
    public const ALLOWED_HTTP_VERSIONS = ['1.0', '1.1', '2.0', '2'];

    public const HTTP_VERSION_REGEX = '/^[0-9](?:[.][0-9])?$/';
    public const DEFAULT_HTTP_VERSION = '1.1';

    private string $protocolVersion = self::DEFAULT_HTTP_VERSION;

    /**
     * @var array<string, list<string>>

The doc comment array<string, list<string>> at position 4 could not be parsed: Expected '>' at position 4, but found 'list'.

     */
    private array $headers = [];

    /**
     * @var array<string, string>
     */
    private array $headerNames = [];

    private ?StreamInterface $body = null;

    /**
     * @inheritDoc
     */
    public function getProtocolVersion(): string
    {
        return $this->protocolVersion;
    }

    /**
     * @inheritDoc
     *
     * @throws InvalidArgumentException
     */
    public function withProtocolVersion($version): MessageInterface
    {
        $clone = clone $this;
        $clone->setProtocolVersion($version);

        return $clone;
    }

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

    /**
     * @inheritDoc
     */
    public function hasHeader($name): bool
    {
        $key = strtolower($name);

        return isset($this->headerNames[$key]);
    }

    /**
     * @inheritDoc
     */
    public function getHeader($name): array
    {
        $key = strtolower($name);

        if (!isset($this->headerNames[$key])) {
            return [];
        }

        return $this->headers[$this->headerNames[$key]];
    }

    /**
     * @inheritDoc
     */
    public function getHeaderLine($name): string
    {
        $key = strtolower($name);

        if (!isset($this->headerNames[$key])) {
            return '';
        }

        return implode(',', $this->headers[$this->headerNames[$key]]);
    }

    /**
     * @inheritDoc
     */
    public function withHeader($name, $value): MessageInterface
    {
        $clone = clone $this;
        $clone->setHeader($name, $value, true);

        return $clone;
    }

    /**
     * @inheritDoc
     */
    public function withAddedHeader($name, $value): MessageInterface
    {
        $clone = clone $this;
        $clone->setHeader($name, $value, false);

        return $clone;
    }

    /**
     * @inheritDoc
     */
    public function withoutHeader($name): MessageInterface
    {
        $clone = clone $this;
        $clone->deleteHeader($name);

        return $clone;
    }

    /**
     * @inheritDoc
     */
    public function getBody(): StreamInterface
    {
        return $this->body ??= new PhpTempStream();
    }

    /**
     * @inheritDoc
     */
    public function withBody(StreamInterface $body): MessageInterface
    {
        $clone = clone $this;
        $clone->setBody($body);

        return $clone;
    }

    /**
     * Sets the given HTTP version to the message
     *
     * @param string $protocolVersion
     *
     * @throws InvalidArgumentException
     */
    final protected function setProtocolVersion($protocolVersion): void
    {
        $this->validateProtocolVersion($protocolVersion);

        $this->protocolVersion = $protocolVersion;
    }

    /**
     * Sets a new header to the message with the given name and value(s)
     *
     * @param string $name
     * @param string|string[] $value
     *
     * @throws InvalidArgumentException
     */
    final protected function setHeader($name, $value, bool $replace = true): void
    {
        if (!is_array($value)) {
            $value = [$value];
        }

        $this->validateHeaderName($name);
        $this->validateHeaderValue($name, $value);

        $replace and $this->deleteHeader($name);

        $key = strtolower($name);

        $this->headerNames[$key] ??= $name;
        $this->headers[$this->headerNames[$key]] ??= [];

        foreach ($value as $item) {
            $this->headers[$this->headerNames[$key]][] = $item;
        }
    }

    /**
     * Sets the given headers to the message
     *
     * @param array<string, string|string[]> $headers
     *
     * @throws InvalidArgumentException
     */
    final protected function setHeaders(array $headers): void
    {
        foreach ($headers as $name => $value) {
            $this->setHeader($name, $value, false);
        }
    }

    /**
     * Deletes a header from the message by the given name
     *
     * @param string $name
     */
    final protected function deleteHeader($name): void
    {
        $key = strtolower($name);

        if (isset($this->headerNames[$key])) {
            unset($this->headers[$this->headerNames[$key]]);
            unset($this->headerNames[$key]);
        }
    }

    /**
     * Sets the given body to the message
     */
    final protected function setBody(StreamInterface $body): void
    {
        $this->body = $body;
    }

    /**
     * Validates the given HTTP version
     *
     * @param mixed $protocolVersion
     *
     * @throws InvalidArgumentException
     */
    private function validateProtocolVersion($protocolVersion): void
    {
        if ($protocolVersion === '') {
            throw new InvalidArgumentException('HTTP version cannot be an empty');
        }

        if (!is_string($protocolVersion)) {
            throw new InvalidArgumentException('HTTP version must be a string');
        }

        if (!preg_match(self::HTTP_VERSION_REGEX, $protocolVersion)) {
            throw new InvalidArgumentException('HTTP version is invalid');
        }
    }

    /**
     * Validates the given header name
     *
     * @param mixed $name
     *
     * @throws InvalidArgumentException
     */
    private function validateHeaderName($name): void
    {
        if ($name === '') {
            throw new InvalidArgumentException('HTTP header name cannot be an empty');
        }

        if (!is_string($name)) {
            throw new InvalidArgumentException('HTTP header name must be a string');
        }

        if (!preg_match(HeaderInterface::RFC7230_TOKEN_REGEX, $name)) {
            throw new InvalidArgumentException('HTTP header name is invalid');
        }
    }

    /**
     * Validates the given header value
     *
     * @param array<array-key, mixed> $value

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

     *
     * @throws InvalidArgumentException
     */
    private function validateHeaderValue(string $name, array $value): void
    {
        if ($value === []) {
            throw new InvalidArgumentException("The value of the HTTP header $name cannot be an empty array");
        }

        foreach ($value as $key => $item) {
            if ($item === '') {
                continue;
            }

            if (!is_string($item)) {
                throw new InvalidArgumentException("The value of the HTTP header $name:$key must be a string");
            }

            if (!preg_match(HeaderInterface::RFC7230_FIELD_VALUE_REGEX, $item)) {
                throw new InvalidArgumentException("The value of the HTTP header $name:$key is invalid");
            }
        }
    }
}