Genkgo\Mail\Protocol\Imap\Response\AggregateResponse

Complexity

Total Complexity

16

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	hasCompleted()	0	21	4
A	getIterator()	0	4	1
A	first()	0	8	2
A	last()	0	8	2
A	at()	0	8	2
B	withLine()	0	32	4

<?php
declare(strict_types=1);

namespace Genkgo\Mail\Protocol\Imap\Response;

use Genkgo\Mail\Exception\AssertionFailedException;
use Genkgo\Mail\Protocol\Imap\ResponseInterface;
use Genkgo\Mail\Protocol\Imap\Tag;

/**
 * Class Response
 * @package Genkgo\Mail\Protocol\Smtp
 */
final class AggregateResponse implements \IteratorAggregate
{
    /**
     * @var array|ResponseInterface[]
     */
    private $lines = [];

    /**
     * @var Tag
     */
    private $tag;

    /**
     * Reply constructor.
     * @param Tag $tag
     */
    public function __construct(Tag $tag)
    {
        $this->tag = $tag;
    }

    /**
     * @return \Iterator|ResponseInterface[]
     */
    public function getIterator(): \Iterator
    {
        return new \ArrayIterator($this->lines);
    }

    /**
     * @return ResponseInterface
     */
    public function first(): ResponseInterface
    {
        if (empty($this->lines)) {
            throw new \OutOfBoundsException('Cannot return item of empty response');
        }

        return reset($this->lines);
    }

    /**
     * @return ResponseInterface
     */
    public function last(): ResponseInterface
    {
        if (empty($this->lines)) {
            throw new \OutOfBoundsException('Cannot return item of empty response');
        }

        return end($this->lines);
    }

    /**
     * @param int $index
     * @return ResponseInterface
     */
    public function at(int $index): ResponseInterface
    {
        if (!isset($this->lines[$index])) {
            throw new \OutOfBoundsException('GenericItem not in response');
        }

        return $this->lines[$index];
    }

    /**
     * @return bool
     */
    public function hasCompleted(): bool
    {
        if (empty($this->lines)) {
            return false;
        }

        $lastCommand = end($this->lines);
        try {
            $lastCommand->assertTagged();
            return true;
        } catch (AssertionFailedException $e) {

Consider adding a comment why this CATCH block is empty.

        }

        try {
            $lastCommand->assertContinuation();
            return true;
        } catch (AssertionFailedException $e) {

Consider adding a comment why this CATCH block is empty.

        }

        return false;
    }

    /**
     * @param string $line
     * @return AggregateResponse
     */
    public function withLine(string $line): AggregateResponse
    {
        $clone = clone $this;

        switch (substr($line, 0, 2)) {
            case '+ ':
                $clone->lines[] = new CommandContinuationRequestResponse(
                    substr($line, 2)
                );
                break;
            case '* ':
                $clone->lines[] = new UntaggedResponse(
                    substr($line, 2)
                );
                break;
            default:
                try {
                    $clone->lines[] = new TaggedResponse(
                        $this->tag,
                        $this->tag->extractBodyFromLine($line)
                    );
                } catch (\InvalidArgumentException $e) {
                    $keys = array_keys($clone->lines);
                    $lastKey = end($keys);
                    $clone->lines[$lastKey] = $clone->lines[$lastKey]->withBody($line);
                }
                break;

        }

        return $clone;
    }
}