Email - Code Metrics - Inspection of "Fix broken build" - BurningFlipside/CommonCode - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9eba1a...d953ee )

by Patrick

created 2016-07-07 19:03 UTC

Email B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	382
Duplicated Lines	3.14 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	3
Bugs	3	Features	0

Metric	Value
dl	12
loc	382
rs	8.3396
c	3
b	3
f	0
wmc	44
lcom	1
cbo	1

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getFromAddress()	0	8	2
A	getToAddresses()	0	4	1
A	getCCAddresses()	0	4	1
A	getBCCAddresses()	0	4	1
A	getReplyTo()	0	8	2
A	getSubject()	0	4	1
A	getHTMLBody()	0	4	1
A	getTextBody()	0	4	1
A	constructEmailAddressString()	0	8	2
A	setFromAddress()	0	4	1
A	addToAddress()	0	4	1
A	addCCAddress()	0	4	1
A	addBCCAddress()	0	4	1
A	addAddress()	0	4	1
A	setReplyTo()	0	4	1
A	setSubject()	0	4	1
A	setHTMLBody()	0	4	1
A	setTextBody()	0	4	1
A	appendToHTMLBody()	0	4	1
A	appendToTextBody()	0	4	1
A	addAttachmentFromBuffer()	0	4	1
B	addAttachmentFromFile()	0	17	6
A	hasAttachments()	0	4	1
C	getRawMessage()	12	49	9
A	encodeRecipients()	0	12	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Email often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Email, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Email class
 *
 * This file describes the Email class
 *
 * PHP version 5 and 7
 *
 * @author Patrick Boyd / [email protected]
 * @copyright Copyright (c) 2015, Austin Artistic Reconstruction
 * @license http://www.apache.org/licenses/ Apache 2.0 License
 */

namespace Email;

/**
 * An class to represent an email
 */
class Email extends \SerializableObject
{
    /** The email's sender */
    protected $sender;
    /** An array of receipients */
    protected $to;
    /** An array of CC receipients */
    protected $cc;
    /** An array of BCC receipients */
    protected $bcc;
    /** The email's reply to address */
    protected $replyTo;
    /** The subject of the email */
    protected $subject;
    /** The email's HTML body */
    protected $htmlBody;
    /** The email's plain text body */
    protected $textBody;
    /** An array of attachements for the email */
    protected $attachments;

    /**
     * Initialize a new email
     */
    public function __construct()
    {
        $this->sender = false;
        $this->to = array();
        $this->cc = array();
        $this->bcc = array();
        $this->replyTo = false;
        $this->subject = false;
        $this->htmlBody = '';
        $this->textBody = '';
        $this->attachments = array();
    }

    /**
     * Who is this email going to be sent from
     *
     * This will return a string either in the format of 'email@address' or 'name <email@address>'
     *
     * @return string The sender of the email
     */
    public function getFromAddress()
    {
        if($this->sender === false)
        {
            return 'Burning Flipside <[email protected]>';
        }
        return $this->sender;
    }

    /**
     * Who is this email going to
     *
     * @return array The recipients of the email
     */
    public function getToAddresses()
    {
        return $this->to;
    }

    /**
     * Who is this email going to (CC)
     *
     * @return array The recipients of the email
     */
    public function getCCAddresses()
    {
        return $this->cc;
    }

    /**
     * Who is this email going to (BCC)
     *
     * @return array The recipients of the email
     */
    public function getBCCAddresses()
    {
        return $this->bcc;
    }

    /**
     * Who should a recipient reply to?
     *
     * @return string The reply to address of the email
     */
    public function getReplyTo()
    {
        if($this->replyTo === false)
        {
            return $this->getFromAddress();
        }
        return $this->replyTo;
    }

    /**
     * What is the email's subject?
     *
     * @return string The email's subject
     */
    public function getSubject()
    {
        return $this->subject;
    }

    /**
     * What should a user with an HTML capable email client see?
     *
     * @return string The email in HTML form
     */
    public function getHTMLBody()
    {
        return $this->htmlBody;
    }

    /**
     * What should a user with a plain text only email client see?
     *
     * @return string The email in ASCII form
     */
    public function getTextBody()
    {
        return $this->textBody;
    }

    /**
     * Create the address string given an email address and if specified a name
     *
     * @param string $email The email address
     * @param string $name  The name to associate with the address
     *
     * @return string The email address and name format
     */
    protected function constructEmailAddressString($email, $name = false)
    {
        if($name === false)
        {
            return $email;
        }
        return $name.' <'.$email.'>';
    }

    /**
     * Set the address the email should be sent from
     *
     * @param string $email The email address to send from
     * @param string $name  The name to associate with the from address
     */
    public function setFromAddress($email, $name = false)
    {
        $this->sender = $this->constructEmailAddressString($email, $name);
    }

    /**
     * Add a new address to the To: line
     *
     * @param string $email The email address to send to
     * @param string $name  The name to associate with the address
     */
    public function addToAddress($email, $name = false)
    {
        $this->addAddress($this->to, $email, $name);
    }

    /**
     * Add a new address to the CC: line
     *
     * @param string $email The email address to send to
     * @param string $name  The name to associate with the address
     */
    public function addCCAddress($email, $name = false)
    {
        $this->addAddress($this->cc, $email, $name);
    }

    /**
     * Add a new address to the BCC: line
     *
     * @param string $email The email address to send to
     * @param string $name  The name to associate with the address
     */
    public function addBCCAddress($email, $name = false)
    {
        $this->addAddress($this->bcc, $email, $name);
    }

    /**
     * Add an address to the inidicated list
     *
     * @param array  $list  The list to add the address to
     * @param string $email The email address to send to
     * @param string $name  The name to associate with the address
     */
    protected function addAddress(&$list, $email, $name = false)
    {
        array_push($list, $this->constructEmailAddressString($email, $name));
    }

    /**
     * Set the address a recipient should reply to
     *
     * @param string $email The email address to reply to
     * @param string $name  The name to associate with the from address
     */
    public function setReplyTo($email, $name = false)
    {
        $this->replyTo = $this->constructEmailAddressString($email, $name);
    }

    /**
     * Set the subject line for the email
     *
     * @param string $subject The email's new subject line
     */
    public function setSubject($subject)
    {
        $this->subject = $subject;
    }

    /**
     * Set the HTML body for the email
     *
     * @param string $body The email's new HTML body
     */
    public function setHTMLBody($body)
    {
        $this->htmlBody = $body;
    }

    /**
     * Set the plain text for the email
     *
     * @param string $body The email's new plain text body
     */
    public function setTextBody($body)
    {
        $this->textBody = $body;
    }

    /**
     * Append a string to the HTML Body
     *
     * @param string $body The string to append to the HTML body
     */
    public function appendToHTMLBody($body)
    {
        $this->htmlBody .= $body;
    }

    /**
     * Append a string to the Plain Text Body
     *
     * @param string $body The string to append to the plain text body
     */
    public function appendToTextBody($body)
    {
        $this->textBody .= $body;
    }

    /**
     * Add an attachment from a memory buffer
     *
     * @param string $name The file name for the attachment to be sent as
     * @param string $buffer The attachment as a binary string
     * @param string $mimeType The MIME type to send the attachment as
     */
    public function addAttachmentFromBuffer($name, $buffer, $mimeType = 'application/octet-stream')
    {
        array_push($this->attachments, array('name'=>$name, 'data'=>$buffer, 'mimeType'=>$mimeType));
    }

    /**
     * Add an attachment from a file on the local disk
     *
     * @param string $filename The file name and path on the local disk
     * @param string $name The file name for the attachment to be sent as
     */
    public function addAttachmentFromFile($filename, $name = false)
    {
        if($name === false)
        {
            $name = basename($filename);
        }
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $mimeType = finfo_file($finfo, $filename);
        if($mimeType === false)
        {
            $mimeType = 'application/octet-stream';
        }
        if(file_exists($filename) && is_file($filename) && is_readable($filename))
        {
            $this->addAttachmentFromBuffer($name, file_get_contents($filename), $mimeType);
        }
    }

    /**
     * Does this email have an attachment?
     *
     * @return boolean True if the email has an attachment. False otherwise
     */
    public function hasAttachments()
    {
        return empty($this->attachments) !== true;
    }

    /**
     * Serialize the message to a raw MIME encoded format suitable for sending over SMTP
     *
     * @return string A text version of the message suitable for sending over SMTP
     */
    public function getRawMessage()
    {
        $boundary = uniqid(rand(), true);
        $rawMessage = 'To: '.$this->encodeRecipients($this->getToAddresses())."\n";
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $from = $this->getFromAddress();
        if($from === false)
        {
            throw new \Exception('Message must have a from address');
        }
        $rawMessage .= 'From: '.$this->encodeRecipients($from)."\n";
        if(!empty($this->cc))
        {
            $rawMessage .= 'CC: '.$this->encodeRecipients($this->getCCAddresses())."\n";
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if(!empty($this->bcc))
        {
            $rawMessage .= 'BCC: '.$this->encodeRecipients($this->getBCCAddresses())."\n";
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        $rawMessage .= 'Subject: '.$this->getSubject()."\n";
        $rawMessage .= 'MIME-Version: 1.0'."\n";
        $rawMessage .= 'Content-type: Multipart/Mixed; boundary="'.$boundary.'"'."\n";
        $rawMessage .= "\n--{$boundary}\n";
        $rawMessage .= 'Content-type: Multipart/Alternative; boundary="alt-'.$boundary.'"'."\n";
        $textBody    = $this->getTextBody();
        if($textBody !== false && strlen($textBody) > 0)

        {
            $rawMessage .= "\n--alt-{$boundary}\n";
            $rawMessage .= "Content-Type: text/plain\n\n";
            $rawMessage .= $textBody."\n";
        }
        $htmlBody = $this->getHTMLBody();
        if($htmlBody !== false && strlen($htmlBody) > 0)

        {
            $rawMessage .= "\n--alt-{$boundary}\n";
            $rawMessage .= 'Content-Type: text/html; charset="UTF-8"'."\n\n";
            $rawMessage .= $htmlBody."\n";
        }
        $rawMessage .= "\n--alt-{$boundary}--\n";
        foreach($this->attachments as $attachment)
        {
            $rawMessage .= "\n--{$boundary}\n";
            $rawMessage .= 'Content-Type: '.$attachment['mimeType'].'; name="'.$attachment['name']."\"\n";
            $rawMessage .= 'Content-Disposition: attachment'."\n";
            $rawMessage .= 'Content-Transfer-Encoding: base64'."\n\n";
            $rawMessage .= chunk_split(base64_encode($attachment['data']), 76, "\n")."\n";
        }
        $rawMessage .= "\n--{$boundary}--\n";
        return $rawMessage;
    }

    /**
     * Serialize a recipient so that it can be sent over SMTP
     *
     * @param string $recipient The recipient in the format 'name <email@address>'
     *
     * @return string A text version of the recipient name and address suitable for sending over SMTP
     */
    public function encodeRecipients($recipient)
    {
        if(is_array($recipient))
        {
            return join(', ', array_map(array($this, 'encodeRecipients'), $recipient));
        }
        if(preg_match("/(.*)<(.*)>/", $recipient, $regs))
        {
            $recipient = '=?UTF-8?B?'.base64_encode($regs[1]).'?= <'.$regs[2].'>';
        }
        return $recipient;
    }
}
/* vim: set tabstop=4 shiftwidth=4 expandtab: */


1		<?php
2		/**
3		* Email class
4		*
5		* This file describes the Email class
6		*
7		* PHP version 5 and 7
8		*
9		* @author Patrick Boyd / [email protected]
10		* @copyright Copyright (c) 2015, Austin Artistic Reconstruction
11		* @license http://www.apache.org/licenses/ Apache 2.0 License
12		*/
13
14		namespace Email;
15
16		/**
17		* An class to represent an email
18		*/
19		class Email extends \SerializableObject
20		{
21		/** The email's sender */
22		protected $sender;
23		/** An array of receipients */
24		protected $to;
25		/** An array of CC receipients */
26		protected $cc;
27		/** An array of BCC receipients */
28		protected $bcc;
29		/** The email's reply to address */
30		protected $replyTo;
31		/** The subject of the email */
32		protected $subject;
33		/** The email's HTML body */
34		protected $htmlBody;
35		/** The email's plain text body */
36		protected $textBody;
37		/** An array of attachements for the email */
38		protected $attachments;
39
40		/**
41		* Initialize a new email
42		*/
43		public function __construct()
44		{
45		$this->sender = false;
46		$this->to = array();
47		$this->cc = array();
48		$this->bcc = array();
49		$this->replyTo = false;
50		$this->subject = false;
51		$this->htmlBody = '';
52		$this->textBody = '';
53		$this->attachments = array();
54		}
55
56		/**
57		* Who is this email going to be sent from
58		*
59		* This will return a string either in the format of 'email@address' or 'name <email@address>'
60		*
61		* @return string The sender of the email
62		*/
63		public function getFromAddress()
64		{
65		if($this->sender === false)
66		{
67		return 'Burning Flipside <[email protected]>';
68		}
69		return $this->sender;
70		}
71
72		/**
73		* Who is this email going to
74		*
75		* @return array The recipients of the email
76		*/
77		public function getToAddresses()
78		{
79		return $this->to;
80		}
81
82		/**
83		* Who is this email going to (CC)
84		*
85		* @return array The recipients of the email
86		*/
87		public function getCCAddresses()
88		{
89		return $this->cc;
90		}
91
92		/**
93		* Who is this email going to (BCC)
94		*
95		* @return array The recipients of the email
96		*/
97		public function getBCCAddresses()
98		{
99		return $this->bcc;
100		}
101
102		/**
103		* Who should a recipient reply to?
104		*
105		* @return string The reply to address of the email
106		*/
107		public function getReplyTo()
108		{
109		if($this->replyTo === false)
110		{
111		return $this->getFromAddress();
112		}
113		return $this->replyTo;
114		}
115
116		/**
117		* What is the email's subject?
118		*
119		* @return string The email's subject
120		*/
121		public function getSubject()
122		{
123		return $this->subject;
124		}
125
126		/**
127		* What should a user with an HTML capable email client see?
128		*
129		* @return string The email in HTML form
130		*/
131		public function getHTMLBody()
132		{
133		return $this->htmlBody;
134		}
135
136		/**
137		* What should a user with a plain text only email client see?
138		*
139		* @return string The email in ASCII form
140		*/
141		public function getTextBody()
142		{
143		return $this->textBody;
144		}
145
146		/**
147		* Create the address string given an email address and if specified a name
148		*
149		* @param string $email The email address
150		* @param string $name The name to associate with the address
151		*
152		* @return string The email address and name format
153		*/
154		protected function constructEmailAddressString($email, $name = false)
155		{
156		if($name === false)
157		{
158		return $email;
159		}
160		return $name.' <'.$email.'>';
161		}
162
163		/**
164		* Set the address the email should be sent from
165		*
166		* @param string $email The email address to send from
167		* @param string $name The name to associate with the from address
168		*/
169		public function setFromAddress($email, $name = false)
170		{
171		$this->sender = $this->constructEmailAddressString($email, $name);
172		}
173
174		/**
175		* Add a new address to the To: line
176		*
177		* @param string $email The email address to send to
178		* @param string $name The name to associate with the address
179		*/
180		public function addToAddress($email, $name = false)
181		{
182		$this->addAddress($this->to, $email, $name);
183		}
184
185		/**
186		* Add a new address to the CC: line
187		*
188		* @param string $email The email address to send to
189		* @param string $name The name to associate with the address
190		*/
191		public function addCCAddress($email, $name = false)
192		{
193		$this->addAddress($this->cc, $email, $name);
194		}
195
196		/**
197		* Add a new address to the BCC: line
198		*
199		* @param string $email The email address to send to
200		* @param string $name The name to associate with the address
201		*/
202		public function addBCCAddress($email, $name = false)
203		{
204		$this->addAddress($this->bcc, $email, $name);
205		}
206
207		/**
208		* Add an address to the inidicated list
209		*
210		* @param array $list The list to add the address to
211		* @param string $email The email address to send to
212		* @param string $name The name to associate with the address
213		*/
214		protected function addAddress(&$list, $email, $name = false)
215		{
216		array_push($list, $this->constructEmailAddressString($email, $name));
217		}
218
219		/**
220		* Set the address a recipient should reply to
221		*
222		* @param string $email The email address to reply to
223		* @param string $name The name to associate with the from address
224		*/
225		public function setReplyTo($email, $name = false)
226		{
227		$this->replyTo = $this->constructEmailAddressString($email, $name);
228		}
229
230		/**
231		* Set the subject line for the email
232		*
233		* @param string $subject The email's new subject line
234		*/
235		public function setSubject($subject)
236		{
237		$this->subject = $subject;
238		}
239
240		/**
241		* Set the HTML body for the email
242		*
243		* @param string $body The email's new HTML body
244		*/
245		public function setHTMLBody($body)
246		{
247		$this->htmlBody = $body;
248		}
249
250		/**
251		* Set the plain text for the email
252		*
253		* @param string $body The email's new plain text body
254		*/
255		public function setTextBody($body)
256		{
257		$this->textBody = $body;
258		}
259
260		/**
261		* Append a string to the HTML Body
262		*
263		* @param string $body The string to append to the HTML body
264		*/
265		public function appendToHTMLBody($body)
266		{
267		$this->htmlBody .= $body;
268		}
269
270		/**
271		* Append a string to the Plain Text Body
272		*
273		* @param string $body The string to append to the plain text body
274		*/
275		public function appendToTextBody($body)
276		{
277		$this->textBody .= $body;
278		}
279
280		/**
281		* Add an attachment from a memory buffer
282		*
283		* @param string $name The file name for the attachment to be sent as
284		* @param string $buffer The attachment as a binary string
285		* @param string $mimeType The MIME type to send the attachment as
286		*/
287		public function addAttachmentFromBuffer($name, $buffer, $mimeType = 'application/octet-stream')
288		{
289		array_push($this->attachments, array('name'=>$name, 'data'=>$buffer, 'mimeType'=>$mimeType));
290		}
291
292		/**
293		* Add an attachment from a file on the local disk
294		*
295		* @param string $filename The file name and path on the local disk
296		* @param string $name The file name for the attachment to be sent as
297		*/
298		public function addAttachmentFromFile($filename, $name = false)
299		{
300		if($name === false)
301		{
302		$name = basename($filename);
303		}
304		$finfo = finfo_open(FILEINFO_MIME_TYPE);
305		$mimeType = finfo_file($finfo, $filename);
306		if($mimeType === false)
307		{
308		$mimeType = 'application/octet-stream';
309		}
310		if(file_exists($filename) && is_file($filename) && is_readable($filename))
311		{
312		$this->addAttachmentFromBuffer($name, file_get_contents($filename), $mimeType);
313		}
314		}
315
316		/**
317		* Does this email have an attachment?
318		*
319		* @return boolean True if the email has an attachment. False otherwise
320		*/
321		public function hasAttachments()
322		{
323		return empty($this->attachments) !== true;
324		}
325
326		/**
327		* Serialize the message to a raw MIME encoded format suitable for sending over SMTP
328		*
329		* @return string A text version of the message suitable for sending over SMTP
330		*/
331		public function getRawMessage()
332		{
333		$boundary = uniqid(rand(), true);
334		$rawMessage = 'To: '.$this->encodeRecipients($this->getToAddresses())."\n";
		0 ignored issues – show Documentation introduced 2016-05-13 18:20 UTC by Report Bug Copy Issue Report `$this->getToAddresses()` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
335		$from = $this->getFromAddress();
336		if($from === false)
337		{
338		throw new \Exception('Message must have a from address');
339		}
340		$rawMessage .= 'From: '.$this->encodeRecipients($from)."\n";
341		if(!empty($this->cc))
342		{
343		$rawMessage .= 'CC: '.$this->encodeRecipients($this->getCCAddresses())."\n";
		0 ignored issues – show Documentation introduced 2016-05-13 18:20 UTC by Report Bug Copy Issue Report `$this->getCCAddresses()` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
344		}
345		if(!empty($this->bcc))
346		{
347		$rawMessage .= 'BCC: '.$this->encodeRecipients($this->getBCCAddresses())."\n";
		0 ignored issues – show Documentation introduced 2016-05-13 18:20 UTC by Report Bug Copy Issue Report `$this->getBCCAddresses()` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
348		}
349		$rawMessage .= 'Subject: '.$this->getSubject()."\n";
350		$rawMessage .= 'MIME-Version: 1.0'."\n";
351		$rawMessage .= 'Content-type: Multipart/Mixed; boundary="'.$boundary.'"'."\n";
352		$rawMessage .= "\n--{$boundary}\n";
353		$rawMessage .= 'Content-type: Multipart/Alternative; boundary="alt-'.$boundary.'"'."\n";
354		$textBody = $this->getTextBody();
355	View Code Duplication	if($textBody !== false && strlen($textBody) > 0)
		0 ignored issues – show Duplication introduced 2016-05-13 18:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
356		{
357		$rawMessage .= "\n--alt-{$boundary}\n";
358		$rawMessage .= "Content-Type: text/plain\n\n";
359		$rawMessage .= $textBody."\n";
360		}
361		$htmlBody = $this->getHTMLBody();
362	View Code Duplication	if($htmlBody !== false && strlen($htmlBody) > 0)
		0 ignored issues – show Duplication introduced 2016-05-13 18:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
363		{
364		$rawMessage .= "\n--alt-{$boundary}\n";
365		$rawMessage .= 'Content-Type: text/html; charset="UTF-8"'."\n\n";
366		$rawMessage .= $htmlBody."\n";
367		}
368		$rawMessage .= "\n--alt-{$boundary}--\n";
369		foreach($this->attachments as $attachment)
370		{
371		$rawMessage .= "\n--{$boundary}\n";
372		$rawMessage .= 'Content-Type: '.$attachment['mimeType'].'; name="'.$attachment['name']."\"\n";
373		$rawMessage .= 'Content-Disposition: attachment'."\n";
374		$rawMessage .= 'Content-Transfer-Encoding: base64'."\n\n";
375		$rawMessage .= chunk_split(base64_encode($attachment['data']), 76, "\n")."\n";
376		}
377		$rawMessage .= "\n--{$boundary}--\n";
378		return $rawMessage;
379		}
380
381		/**
382		* Serialize a recipient so that it can be sent over SMTP
383		*
384		* @param string $recipient The recipient in the format 'name <email@address>'
385		*
386		* @return string A text version of the recipient name and address suitable for sending over SMTP
387		*/
388		public function encodeRecipients($recipient)
389		{
390		if(is_array($recipient))
391		{
392		return join(', ', array_map(array($this, 'encodeRecipients'), $recipient));
393		}
394		if(preg_match("/(.)<(.)>/", $recipient, $regs))
395		{
396		$recipient = '=?UTF-8?B?'.base64_encode($regs[1]).'?= <'.$regs[2].'>';
397		}
398		return $recipient;
399		}
400		}
401		/* vim: set tabstop=4 shiftwidth=4 expandtab: */
402

BurningFlipside / CommonCode