Kodus\Mail\MIMEWriter

Complexity

Total Complexity

35

Size/Duplication

Total Lines	334
Duplicated Lines	2.4 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

98.75%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
B	writeMessage()	0	25	3
B	writeMessageHeaders()	0	33	4
B	writeMessageWithAttachments()	0	27	3
B	writeMessageBody()	0	26	4
A	writeTextPart()	0	8	1
A	writeHTMLPart()	0	8	1
A	writeAttachmentPart()	0	19	2
A	writeMultipartBoundary()	0	4	1
A	writeMultipartBoundaryEnd()	0	4	1
A	writeHeader()	0	6	1
A	writeAddressHeader()	8	22	3
A	writeContentTypeHeader()	0	4	1
A	writeMixedContentTypeHeader()	0	4	1
A	writeAlternativeContentTypeHeader()	0	4	1
A	writeRelatedContentTypeHeader()	0	4	1
A	writeQuotedPrintableEncodingHeader()	0	4	1
A	writeBase64EncodingHeader()	0	4	1
A	writeContentEncodingHeader()	0	4	1
A	escapeHeaderValue()	0	6	2
A	adjustLineBreaks()	0	4	1
A	createMultipartBoundaryName()	0	6	1

<?php

namespace Kodus\Mail;

class MIMEWriter extends Writer
{
    public function writeMessage(Message $message)
    {
        $this->writeMessageHeaders($message);

        $inline_attachments = $message->getInlineAttachments();

        if (count($inline_attachments)) {
            $boundary = $this->createMultipartBoundaryName("related");

            $this->writeRelatedContentTypeHeader($boundary);
            $this->writeLine();

            $this->writeMultipartBoundary($boundary);
            $this->writeMessageWithAttachments($message);

            foreach ($inline_attachments as $inline) {
                $this->writeMultipartBoundary($boundary);
                $this->writeAttachmentPart($inline->getAttachment(), $inline->getContentID());
            }

            $this->writeMultipartBoundaryEnd($boundary);
        } else {
            $this->writeMessageWithAttachments($message);
        }
    }

    /**
     * @param Message $message
     */
    public function writeMessageHeaders(Message $message)
    {
        $this->writeHeader("Date", date("r", $message->getDate()));

        $this->writeAddressHeader("To", $message->getTo());

It seems like $message->getTo() targeting Kodus\Mail\Message::getTo() can also be of type object<Kodus\Mail\Address>; however, Kodus\Mail\MIMEWriter::writeAddressHeader() does only seem to accept array<integer,object<Kodus\Mail\Address>>, maybe add an additional type check?

        $this->writeAddressHeader("From", $message->getFrom());

It seems like $message->getFrom() targeting Kodus\Mail\Message::getFrom() can also be of type object<Kodus\Mail\Address>; however, Kodus\Mail\MIMEWriter::writeAddressHeader() does only seem to accept array<integer,object<Kodus\Mail\Address>>, maybe add an additional type check?

        $this->writeAddressHeader("Cc", $message->getCC());

It seems like $message->getCC() targeting Kodus\Mail\Message::getCC() can also be of type object<Kodus\Mail\Address>; however, Kodus\Mail\MIMEWriter::writeAddressHeader() does only seem to accept array<integer,object<Kodus\Mail\Address>>, maybe add an additional type check?

        $this->writeAddressHeader("Bcc", $message->getBCC());

It seems like $message->getBCC() targeting Kodus\Mail\Message::getBCC() can also be of type object<Kodus\Mail\Address>; however, Kodus\Mail\MIMEWriter::writeAddressHeader() does only seem to accept array<integer,object<Kodus\Mail\Address>>, maybe add an additional type check?

        $this->writeAddressHeader("Reply-To", $message->getReplyTo());

It seems like $message->getReplyTo() targeting Kodus\Mail\Message::getReplyTo() can also be of type object<Kodus\Mail\Address>; however, Kodus\Mail\MIMEWriter::writeAddressHeader() does only seem to accept array<integer,object<Kodus\Mail\Address>>, maybe add an additional type check?

        $sender = $message->getSender();

        if ($sender) {
            $this->writeAddressHeader("Sender", [$sender]);
        } else {
            $from = $message->getFrom();

            if (count($from) > 1) {
                $this->writeAddressHeader("Sender", [$from[0]]);
            } else {

This else statement is empty and can be removed.

                // The contents of this field would be completely redundant with the "From" field.
                // The "Sender" field need not be present, and its use is discouraged - it's therefore left out.
            }
        }

        $this->writeHeader("Subject", $message->getSubject());

        $this->writeHeader("MIME-Version", "1.0");

        foreach ($message->getHeaders() as $header) {
            $this->writeHeader($header->getName(), $header->getValue());
        }
    }

    /**
     * Write a multipart Message with Attachments
     *
     * @param Message $message
     */
    public function writeMessageWithAttachments(Message $message)
    {
        if (empty($message->getAttachments())) {
            $this->writeMessageBody($message);

            return;
        }

        $boundary = $this->createMultipartBoundaryName("mixed");

        $this->writeMixedContentTypeHeader($boundary);

        $this->writeLine();
        $this->writeLine("This is a multipart message in MIME format.");
        $this->writeLine();

        $this->writeMultipartBoundary($boundary);

        $this->writeMessageBody($message);

        foreach ($message->getAttachments() as $attachment) {
            $this->writeMultipartBoundary($boundary);
            $this->writeAttachmentPart($attachment);
        }

        $this->writeMultipartBoundaryEnd($boundary);
    }

    /**
     * Write the text and/or HTML message body parts
     *
     * @param Message $message
     */
    public function writeMessageBody(Message $message)
    {
        $text = $message->getText();
        $html = $message->getHTML();

        if (! empty($text)) {
            if (! empty($html)) {
                $boundary = $this->createMultipartBoundaryName("alternative");

                $this->writeAlternativeContentTypeHeader($boundary);
                $this->writeLine();

                $this->writeMultipartBoundary($boundary);
                $this->writeTextPart($text);

                $this->writeMultipartBoundary($boundary);
                $this->writeHTMLPart($html);

                $this->writeMultipartBoundaryEnd($boundary);
            } else {
                $this->writeTextPart($text);
            }
        } elseif (! empty($html)) {
            $this->writeHTMLPart($html);
        }
    }

    /**
     * Write the "Content-Type" header and the plain-text body in quoted-printable format
     *
     * @param string $content
     */
    public function writeTextPart($content)
    {
        $this->writeContentTypeHeader("text/plain; charset=UTF-8");
        $this->writeQuotedPrintableEncodingHeader();
        $this->writeLine();
        $this->writeQuotedPrintable($this->adjustLineBreaks($content));
        $this->writeLine();
    }

    /**
     * Write the "Content-Type" header and the plain-text body in quoted-printable format
     *
     * @param string $content
     */
    public function writeHTMLPart($content)
    {
        $this->writeContentTypeHeader("text/html; charset=UTF-8");
        $this->writeQuotedPrintableEncodingHeader();
        $this->writeLine();
        $this->writeQuotedPrintable($this->adjustLineBreaks($content));
        $this->writeLine();
    }

    /**
     * Write the "Content-Type" header and the Attachment Content in base-64 encoded format
     *
     * @param Attachment  $attachment
     * @param string|null Content ID (for inline Attachments)
     */
    public function writeAttachmentPart(Attachment $attachment, $content_id = null)
    {
        $filename = $attachment->getFilename();

        $this->writeContentTypeHeader($attachment->getMIMEType());
        $this->writeBase64EncodingHeader();

        if ($content_id === null) {
            $this->writeHeader("Content-Disposition", "attachment; filename=\"{$filename}\"");
        } else {
            // inline Attachment with Content ID:
            $this->writeHeader("Content-Disposition", "inline; filename=\"{$filename}\"");
            $this->writeHeader("Content-ID", "<{$content_id}>");
        }

        $this->writeLine();
        $this->writeBase64($attachment->getContent());
        $this->writeLine();
    }

    /**
     * @param string $boundary
     */
    public function writeMultipartBoundary($boundary)
    {
        $this->writeLine("--{$boundary}");
    }

    /**
     * @param string $boundary
     */
    public function writeMultipartBoundaryEnd($boundary)
    {
        $this->writeLine("--{$boundary}--");
    }

    /**
     * @param string $name
     * @param string $value
     */
    public function writeHeader($name, $value)
    {
        $value = $this->escapeHeaderValue($value);

        $this->writeLine("{$name}: {$value}");
    }

    /**
     * @param string    $name      header name
     * @param Address[] $addresses list of Address objects
     */
    public function writeAddressHeader($name, $addresses)
    {
        if (count($addresses)) {
            $this->writeHeader(
                $name,
                implode(
                    ", ",
                    array_map(
                        function (Address $address) {

This code seems to be duplicated across your project.

                            $email = $address->getEmail();
                            $name = $address->getName();

                            return empty($name)
                                ? $email
                                : $this->escapeHeaderValue($name) . " <{$email}>";
                        },
                        $addresses
                    )
                )
            );
        }
    }

    /**
     * @param string $type
     */
    public function writeContentTypeHeader($type)
    {
        $this->writeHeader("Content-Type", $type);
    }

    /**
     * @param string $boundary
     */
    public function writeMixedContentTypeHeader($boundary)
    {
        $this->writeContentTypeHeader("multipart/mixed; boundary=\"{$boundary}\"");
    }

    /**
     * @param string $boundary
     */
    public function writeAlternativeContentTypeHeader($boundary)
    {
        $this->writeContentTypeHeader("multipart/alternative; boundary=\"{$boundary}\"");
    }

    /**
     * @param string $boundary
     */
    public function writeRelatedContentTypeHeader($boundary)
    {
        $this->writeContentTypeHeader("multipart/related; boundary=\"{$boundary}\"");
    }

    /**
     * Writes the "Content-Transfer-Encoding" header with value "quoted-printable"
     */
    public function writeQuotedPrintableEncodingHeader()
    {
        $this->writeContentEncodingHeader("quoted-printable");
    }

    /**
     * Writes the "Content-Transfer-Encoding" header with value "base64"
     */
    public function writeBase64EncodingHeader()
    {
        $this->writeContentEncodingHeader("base64");
    }

    /**
     * @param string $encoding encoding (e.g. "quoted-printable", "base64" or "8bit")
     */
    protected function writeContentEncodingHeader($encoding)
    {
        $this->writeHeader("Content-Transfer-Encoding", $encoding);
    }

    /**
     * Generates a unique MIME boundary name
     *
     * @param string $prefix static prefix (helps developers diagnose the output)
     *
     * @return string
     */
    protected function createMultipartBoundaryName($prefix)
    {
        static $boundary_index = 1;

        return "++++{$prefix}-" . sha1(microtime(true) . $boundary_index++) . "++++";
    }

    /**
     * Escape UTF-8 string (if necessary) for use in a header-value
     *
     * @param string $value
     *
     * @return string
     */
    protected function escapeHeaderValue($value)
    {
        return preg_match('/[\x80-\xFF]/', $value) === 1
            ? "=?UTF-8?Q?" . quoted_printable_encode($value) . "?="
            : $value; // as-is
    }

    /**
     * Adjusts line-breaks, correcting CR or LF as CRLF, to improve quoted-printable encoding.
     *
     * @param string $value
     *
     * @return string
     */
    protected function adjustLineBreaks($value)
    {
        return preg_replace('/(?>\r\n|\n|\r)/u', "\r\n", $value);
    }
}