Genkgo\Mail\Transport\EnvelopeFactory

Complexity

Total Complexity

13

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	withFallback()	0	6	1
A	make()	0	12	3
A	extractHeader()	0	13	4
A	extractFromAddressListHeader()	0	6	1
A	useExtractedHeader()	0	6	1
A	useFixed()	0	8	1
A	useCallback()	0	6	1

<?php
declare(strict_types=1);

namespace Genkgo\Mail\Transport;

use Genkgo\Mail\AddressList;
use Genkgo\Mail\EmailAddress;
use Genkgo\Mail\MessageInterface;

/**
 * Class EnvelopOptions
 * @package Genkgo\Mail\Transport
 */
final class EnvelopeFactory
{
    /**
     * @var \Closure
     */
    private $callback;
    /**
     * @var EmailAddress
     */
    private $fallback;

    /**
     * EnvelopOptions constructor.
     */
    private function __construct()
    {
    }

    /**
     * @param EmailAddress $emailAddress
     * @return EnvelopeFactory
     */
    public function withFallback(EmailAddress $emailAddress): EnvelopeFactory
    {
        $clone = clone $this;
        $clone->fallback = $emailAddress;
        return $clone;
    }

    /**
     * @param MessageInterface $message
     * @return EmailAddress
     */
    public function make(MessageInterface $message): EmailAddress
    {
        try {
            return $this->callback->call($this, $message);
        } catch (\RuntimeException $e) {
            if ($this->fallback === null) {
                throw $e;
            }
        }

        return $this->fallback;
    }

    /**
     * @param MessageInterface $message
     * @return EmailAddress
     */
    private function extractHeader(MessageInterface $message): EmailAddress
    {
        foreach (['sender', 'from'] as $header) {
            if ($message->hasHeader($header)) {
                try {
                    return $this->extractFromAddressListHeader($message, $header);
                } catch (\OutOfRangeException $e) {

Consider adding a comment why this CATCH block is empty.

                }
            }
        }

        throw new \RuntimeException('Cannot extract envelope from headers');
    }

    /**
     * @param MessageInterface $message
     * @param string $headerName
     * @return EmailAddress
     */
    private function extractFromAddressListHeader (MessageInterface $message, string $headerName): EmailAddress
    {
        return AddressList::fromString(
            (string)$message->getHeader($headerName)[0]->getValue()->getRaw()
        )->first()->getAddress();
    }

    /**
     * @return EnvelopeFactory
     */
    public static function useExtractedHeader()
    {
        $options = new self();
        $options->callback = \Closure::fromCallable([$options, 'extractHeader']);
        return $options;
    }

    /**
     * @param EmailAddress $fixedAddress
     * @return EnvelopeFactory
     */
    public static function useFixed(EmailAddress $fixedAddress)
    {
        $options = new self();
        $options->callback = function () use ($fixedAddress) {
            return $fixedAddress;
        };
        return $options;
    }

    /**
     * @param \Closure $callback
     * @return EnvelopeFactory
     */
    public static function useCallback(\Closure $callback)
    {
        $options = new self();
        $options->callback = $callback;
        return $options;
    }

}