Email::constructEmailAddressString() - Code Metrics - Inspection of "Consolidate more duplicate code in Email class" - BurningFlipside/CommonCode - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d953ee...412f75 )

by Patrick

created 2016-07-07 19:14 UTC

Email::constructEmailAddressString() A

↳ Parent: Email

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	2
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0

<?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;
    }

    protected function addBodyIfPresent($body, $encoding)
    {
        $rawMessage = '';
        if($body !== false && strlen($body) > 0)
        {
            $rawMessage .= "\n--alt-{$boundary}\n";

            $rawMessage .= "Content-Type: $encoding\n\n";
            $rawMessage .= $body."\n";
        }
        return $rawMessage;
    }

    /**
     * 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";
        $rawMessage .= $this->addBodyIfPresent($this->getTextBody(), 'text/plain');
        $rawMessage .= $this->addBodyIfPresent($this->getHTMLBody(), 'text/html; charset="UTF-8"');
        $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			protected function addBodyIfPresent($body, $encoding)
327			{
328			$rawMessage = '';
329			if($body !== false && strlen($body) > 0)
330			{
331			$rawMessage .= "\n--alt-{$boundary}\n";
			0 ignored issues – show Bug introduced 2016-07-07 19:17 UTC by Report Bug Copy Issue Report The variable `$boundary` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
332			$rawMessage .= "Content-Type: $encoding\n\n";
333			$rawMessage .= $body."\n";
334			}
335			return $rawMessage;
336			}
337
338			/**
339			* Serialize the message to a raw MIME encoded format suitable for sending over SMTP
340			*
341			* @return string A text version of the message suitable for sending over SMTP
342			*/
343			public function getRawMessage()
344			{
345			$boundary = uniqid(rand(), true);
346			$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...
347			$from = $this->getFromAddress();
348			if($from === false)
349			{
350			throw new \Exception('Message must have a from address');
351			}
352			$rawMessage .= 'From: '.$this->encodeRecipients($from)."\n";
353			if(!empty($this->cc))
354			{
355			$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...
356			}
357			if(!empty($this->bcc))
358			{
359			$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...
360			}
361			$rawMessage .= 'Subject: '.$this->getSubject()."\n";
362			$rawMessage .= 'MIME-Version: 1.0'."\n";
363			$rawMessage .= 'Content-type: Multipart/Mixed; boundary="'.$boundary.'"'."\n";
364			$rawMessage .= "\n--{$boundary}\n";
365			$rawMessage .= 'Content-type: Multipart/Alternative; boundary="alt-'.$boundary.'"'."\n";
366			$rawMessage .= $this->addBodyIfPresent($this->getTextBody(), 'text/plain');
367			$rawMessage .= $this->addBodyIfPresent($this->getHTMLBody(), 'text/html; charset="UTF-8"');
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

Push — master ( d953ee...412f75 )

Email::constructEmailAddressString() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like