Genkgo\Mail\AddressList

Complexity

Total Complexity

18

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

98.31%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	withAddress()	0	6	1
A	withoutAddress()	0	12	3
A	count()	0	4	1
A	__toString()	0	12	1
B	fromString()	0	56	9

<?php
declare(strict_types=1);

namespace Genkgo\Mail;

/**
 * Class AddressList
 * @package Genkgo\Mail
 */
final class AddressList implements \Countable
{
    /**
     *
     */
    private CONST PARSE_START = 1;
    /**
     *
     */
    private CONST PARSE_QUOTE = 2;

    /**
     * @var array|Address[]
     */
    private $addresses = [];

    /**
     * To constructor.
     * @param array|Address[] $recipients
     */
    public function __construct(array $recipients = [])
    {
        foreach ($recipients as $recipient) {
            if ($recipient instanceof Address === false) {
                throw new \InvalidArgumentException('Recipient must be EmailAddressAndName object');
            }

            $this->addresses[] = $recipient;
        }
    }

    /**
     * @param Address $address
     * @return AddressList
     */
    public function withAddress(Address $address): AddressList
    {
        $clone = clone $this;
        $clone->addresses[] = $address;
        return $clone;
    }

    /**
     * @param Address $address
     * @return AddressList
     */
    public function withoutAddress(Address $address): AddressList
    {
        $clone = clone $this;

        foreach ($this->addresses as $key => $mayRemoveAddress) {
            if ($mayRemoveAddress->equals($address)) {
                unset($clone->addresses[$key]);
            }
        }

        return $clone;
    }

    /**
     * @return int
     */
    public function count(): int
    {
        return count($this->addresses);
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return implode(
            ',',
            array_map(
                function (Address $addressAndName) {
                    return (string) $addressAndName;
                },
                $this->addresses
            )
        );
    }

    /**
     * @param string $addressListAsString
     * @return AddressList
     */
    public static function fromString(string $addressListAsString)
    {
        $addressListAsString = trim($addressListAsString);
        if ($addressListAsString === '') {
            return new self([]);
        }

        $addresses = [];
        $length = strlen($addressListAsString) - 1;
        $n = -1;
        $state = self::PARSE_START;
        $escapeNext = false;
        $sequence = '';

        while ($n < $length) {
            $n++;

            $char = $addressListAsString[$n];

            $sequence .= $char;

            if ($char === '\\') {
                $escapeNext = true;
                continue;
            }

            if ($escapeNext) {
                $escapeNext = false;
                continue;
            }

            switch ($state) {
                case self::PARSE_QUOTE:
                    if ($char === '"') {
                        $state = self::PARSE_START;
                    }

                    break;
                default:
                    if ($char === '"') {
                        $state = self::PARSE_QUOTE;
                    }

                    if ($char === ',') {
                        $addresses[] = Address::fromString(substr($sequence, 0, -1));
                        $sequence = '';
                        $state = self::PARSE_START;
                    }
                    break;
            }
        }

        $addresses[] = Address::fromString($sequence);

        return new self($addresses);
    }
}