MimeMessage::addMimeHeaders() - Code Metrics - slickframework/mail - Measure and Improve Code Quality continuously with Scrutinizer

MimeMessage::addMimeHeaders() A
last analyzed 2016-08-04 18:35 UTC

↳ Parent: MimeMessage

Complexity

Conditions	3
Paths	2

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
ccs	9
cts	9
cp	1
rs	9.4285
cc	3
eloc	7
nc	2
nop	0
crap	3

<?php

/**
 * This file is part of slick/mail package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Mail\Mime;

use Slick\Mail\Header\GenericHeader;
use Slick\Mail\Header\HeaderInterface;
use Slick\Mail\Message;
use Zend\Mime\Mime;

/**
 * Message
 *
 * @package Slick\Mail\Mime
 * @author  Filipe Silva <[email protected]>
 */
class MimeMessage extends Message
{

    /** MIME version */
    const VERSION = '1.0';

    /**
     * @var Mime
     */
    protected $mime;

    /**
     * @var MimeParts|Part[]
     */
    protected $parts;

    /**
     * Mime Message
     */
    public function __construct()
    {
        $this->parts = new MimeParts();
    }

    /**
     * Check if this message is a multi-part MIME message
     *
     * @return bool
     */
    public function isMultiPart()
    {
        return $this->parts->count() > 1;
    }

    /**
     * Gets the Mime
     *
     * @return Mime
     */
    public function getMime()
    {
        if (null == $this->mime) {
            $this->setMime(New Mime());
        }
        return $this->mime;
    }

    /**
     * Sets the Mime
     *
     * @param Mime $mime
     *
     * @return MimeMessage|$this|self
     */
    public function setMime(Mime $mime)
    {
        $this->mime = $mime;
        return $this;
    }

    /**
     * Get message parts
     *
     * @return MimeParts|Part[]
     */
    public function parts()
    {
        return $this->parts;
    }

    /**
     * Access headers collection
     *
     * Lazy-loads if not already attached.
     *
     * @return HeaderInterface[]
     */
    public function getHeaders()
    {
        $this->generateHeaders();
        return $this->headers;
    }

    /**
     * Add the headers for MIME type message
     *
     * @return MimeMessage
     */
    protected function generateHeaders()
    {
        $this->headers['MIME-Version'] = New GenericHeader('MIME-Version', self::VERSION);
        $this->headers['Date'] = New GenericHeader('Date', date('r'));

        if ($this->isMultiPart()) {
            return $this->addMultiPartHeaders();
        }
        return $this->addMimeHeaders();
    }

    /**
     * Add headers for multipart MIME type message
     *
     * @return $this
     */
    protected function addMultiPartHeaders()
    {
        $boundary = $this->getMime()->boundary();
        $this->headers['Content-Type'] = new GenericHeader(
            'Content-Type',
            "multipart/mixed; boundary={$boundary}"
        );
        return $this;
    }

    /**
     * Add the headers for mime type message
     *
     * @return $this
     */
    protected function addMimeHeaders()
    {
        if (!$this->parts->isEmpty()) {
            $part = $this->parts[0];
            foreach ($part->getHeadersArray(HeaderInterface::EOL) as $header) {
                list($name, $value) = $header;
                $this->headers[$name] = new GenericHeader($name, $value);
            }
        }

        return $this;
    }

    /**
     * Get the string-serialized message body text
     *
     * @return string
     */
    public function getBodyText()
    {
        return ($this->isMultiPart())
            ? $this->generateMultiPartMime()
            : $this->generateMime();
    }

    /**
     * Generate single part MIME message
     * @return string
     */
    protected function generateMime()
    {
        if ($this->parts->isEmpty()) {
            return '';
        }

        /** @var Part $part */
        $part = $this->parts[0];
        return $part->getContent();
    }

    /**
     * Generate multi-part message content
     *
     * @return string
     */
    protected function generateMultiPartMime()
    {
        $eol = Mime::LINEEND;
        $boundaryLine = $this->getMime()->boundaryLine($eol);
        $body = 'This is a message in Mime Format.  If you see this, '
            . "your mail reader does{$eol}not support this format." . $eol;

        foreach ($this->parts as $part) {
            $body .= $boundaryLine
                   . $part->getHeaders($eol)
                   . $eol
                   . $part->getContent($eol);
        }

        $body .= $this->getMime()->mimeEnd($eol);
        return trim($body);
    }

}

1		<?php
2
3		/**
4		* This file is part of slick/mail package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Mail\Mime;
11
12		use Slick\Mail\Header\GenericHeader;
13		use Slick\Mail\Header\HeaderInterface;
14		use Slick\Mail\Message;
15		use Zend\Mime\Mime;
16
17		/**
18		* Message
19		*
20		* @package Slick\Mail\Mime
21		* @author Filipe Silva <[email protected]>
22		*/
23		class MimeMessage extends Message
24		{
25
26		/** MIME version */
27		const VERSION = '1.0';
28
29		/**
30		* @var Mime
31		*/
32		protected $mime;
33
34		/**
35		* @var MimeParts\|Part[]
36		*/
37		protected $parts;
38
39		/**
40		* Mime Message
41		*/
42	6	public function __construct()
43		{
44	6	$this->parts = new MimeParts();
45	6	}
46
47		/**
48		* Check if this message is a multi-part MIME message
49		*
50		* @return bool
51		*/
52	12	public function isMultiPart()
53		{
54	12	return $this->parts->count() > 1;
55		}
56
57		/**
58		* Gets the Mime
59		*
60		* @return Mime
61		*/
62	6	public function getMime()
63		{
64	6	if (null == $this->mime) {
65	4	$this->setMime(New Mime());
66	2	}
67	6	return $this->mime;
68		}
69
70		/**
71		* Sets the Mime
72		*
73		* @param Mime $mime
74		*
75		* @return MimeMessage\|$this\|self
76		*/
77	4	public function setMime(Mime $mime)
78		{
79	4	$this->mime = $mime;
80	4	return $this;
81		}
82
83		/**
84		* Get message parts
85		*
86		* @return MimeParts\|Part[]
87		*/
88	4	public function parts()
89		{
90	4	return $this->parts;
91		}
92
93		/**
94		* Access headers collection
95		*
96		* Lazy-loads if not already attached.
97		*
98		* @return HeaderInterface[]
99		*/
100	4	public function getHeaders()
101		{
102	4	$this->generateHeaders();
103	4	return $this->headers;
104		}
105
106		/**
107		* Add the headers for MIME type message
108		*
109		* @return MimeMessage
110		*/
111	4	protected function generateHeaders()
112		{
113	4	$this->headers['MIME-Version'] = New GenericHeader('MIME-Version', self::VERSION);
114	4	$this->headers['Date'] = New GenericHeader('Date', date('r'));
115
116	4	if ($this->isMultiPart()) {
117	2	return $this->addMultiPartHeaders();
118		}
119	2	return $this->addMimeHeaders();
120		}
121
122		/**
123		* Add headers for multipart MIME type message
124		*
125		* @return $this
126		*/
127	2	protected function addMultiPartHeaders()
128		{
129	2	$boundary = $this->getMime()->boundary();
130	2	$this->headers['Content-Type'] = new GenericHeader(
131	2	'Content-Type',
132	2	"multipart/mixed; boundary={$boundary}"
133	1	);
134	2	return $this;
135		}
136
137		/**
138		* Add the headers for mime type message
139		*
140		* @return $this
141		*/
142	2	protected function addMimeHeaders()
143		{
144	2	if (!$this->parts->isEmpty()) {
145	2	$part = $this->parts[0];
146	2	foreach ($part->getHeadersArray(HeaderInterface::EOL) as $header) {
147	2	list($name, $value) = $header;
148	2	$this->headers[$name] = new GenericHeader($name, $value);
149	1	}
150	1	}
151
152	2	return $this;
153		}
154
155		/**
156		* Get the string-serialized message body text
157		*
158		* @return string
159		*/
160	6	public function getBodyText()
161		{
162	6	return ($this->isMultiPart())
163	4	? $this->generateMultiPartMime()
164	6	: $this->generateMime();
165		}
166
167		/**
168		* Generate single part MIME message
169		* @return string
170		*/
171	4	protected function generateMime()
172		{
173	4	if ($this->parts->isEmpty()) {
174	2	return '';
175		}
176
177		/** @var Part $part */
178	2	$part = $this->parts[0];
179	2	return $part->getContent();
180		}
181
182		/**
183		* Generate multi-part message content
184		*
185		* @return string
186		*/
187	2	protected function generateMultiPartMime()
188		{
189	2	$eol = Mime::LINEEND;
190	2	$boundaryLine = $this->getMime()->boundaryLine($eol);
191		$body = 'This is a message in Mime Format. If you see this, '
192	2	. "your mail reader does{$eol}not support this format." . $eol;
193
194	2	foreach ($this->parts as $part) {
195		$body .= $boundaryLine
196	2	. $part->getHeaders($eol)
197	2	. $eol
198	2	. $part->getContent($eol);
199	1	}
200
201	2	$body .= $this->getMime()->mimeEnd($eol);
202	2	return trim($body);
203		}
204
205		}

slickframework / mail

MimeMessage::addMimeHeaders() A last analyzed 2016-08-04 18:35 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

MimeMessage::addMimeHeaders() A
last analyzed 2016-08-04 18:35 UTC