Genkgo\Mail\GenericMessage

Complexity

Total Complexity

18

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getHeaders()	0	4	1
A	hasHeader()	0	5	2
A	getHeader()	0	10	2
A	withHeader()	0	6	1
A	withAddedHeader()	0	6	1
A	withoutHeader()	0	6	1
A	withBody()	0	6	1
A	getBody()	0	4	1
A	__toString()	0	23	1
B	fromString()	0	30	6

<?php
declare(strict_types=1);

namespace Genkgo\Mail;

use Genkgo\Mail\Header\HeaderLine;
use Genkgo\Mail\Header\MimeVersion;
use Genkgo\Mail\Stream\EmptyStream;
use Genkgo\Mail\Stream\BitEncodedStream;

/**
 * Class ImmutableMessage
 * @package Genkgo\Mail
 */
final class GenericMessage implements MessageInterface
{
    /**
     * @var array
     */
    private $headers = [
        'return-path' => [],
        'received' => [],
        'dkim-signature' => [],
        'domainkey-signature' => [],
        'sender' => [],
        'message-id' => [],
        'date' => [],
        'subject' => [],
        'from' => [],
        'reply-to' => [],
        'to' => [],
        'cc' => [],
        'bcc' => [],
        'mime-version' => [],
        'content-type' => [],
        'content-transfer-encoding' => [],
    ];
    /**
     * @var StreamInterface
     */
    private $body;

    /**
     * ImmutableMessage constructor.
     */
    public function __construct()
    {
        $this->body = new EmptyStream();
        $this->headers['mime-version'] = [new MimeVersion()];
    }

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

The return type of return $this->headers; (array) is incompatible with the return type declared by the interface Genkgo\Mail\MessageInterface::getHeaders of type Genkgo\Mail\iterable.

    }

    /**
     * @param string $name
     * @return bool
     */
    public function hasHeader(string $name): bool
    {
        $name = strtolower($name);
        return isset($this->headers[$name]) && $this->headers[$name];
    }

    /**
     * @param string $name
     * @return HeaderInterface[]|iterable
     */
    public function getHeader(string $name): iterable
    {
        $name = strtolower($name);

        if (!isset($this->headers[$name])) {
            return [];

The return type of return array(); (array) is incompatible with the return type declared by the interface Genkgo\Mail\MessageInterface::getHeader of type Genkgo\Mail\iterable|Genkgo\Mail\HeaderInterface[].

        }

        return $this->headers[$name];
    }

    /**
     * @param HeaderInterface $header
     * @return MessageInterface
     */
    public function withHeader(HeaderInterface $header): MessageInterface
    {
        $clone = clone $this;
        $clone->headers[strtolower((string)$header->getName())] = [$header];
        return $clone;
    }

    /**
     * @param HeaderInterface $header
     * @return MessageInterface
     */
    public function withAddedHeader(HeaderInterface $header): MessageInterface
    {
        $clone = clone $this;
        $clone->headers[strtolower((string)$header->getName())][] = $header;
        return $clone;
    }

    /**
     * @param string $name
     * @return MessageInterface
     */
    public function withoutHeader(string $name): MessageInterface
    {
        $clone = clone $this;
        unset($clone->headers[(string)strtolower($name)]);
        return $clone;
    }

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

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

    /**
     * @return string
     */
    public function __toString(): string
    {
        $headerString = array_values(
            array_filter(
                array_map(
                    function (array $headers) {
                        return implode(
                            "\r\n",
                            array_map(
                                function (HeaderInterface $header) {
                                    return (string) (new HeaderLine($header));
                                },
                                $headers
                            )
                        );
                    },
                    $this->headers
                )
            )
        );

        return implode("\r\n", array_merge($headerString, ['', (string)$this->body]));
    }

    /**
     * @param string $messageString
     * @return MessageInterface
     */
    public static function fromString(string $messageString): MessageInterface
    {
        $message = new self();

        $lines = preg_split('/\r\n/', $messageString);
        for ($n = 0, $length = count($lines); $n < $length; $n++) {
            $line = $lines[$n];

            if ($line === '') {
                $message = $message->withBody(
                    new BitEncodedStream(
                        implode(
                            "\r\n",
                            array_slice($lines, $n + 1)
                        )
                    )
                );
                break;
            }

            while (isset($lines[$n + 1]) && $lines[$n + 1] !== '' && $lines[$n + 1][0] === ' ') {
                $line .= $lines[$n + 1];
                $n++;
            }

            $message = $message->withHeader(HeaderLine::fromString($line)->getHeader());
        }

        return $message;
    }
}