EmailAttachment::getFilename() - Code Metrics - Inspection of "Email Service Provider" - XOOPS/XoopsCore - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#578)

by Richard

created 2018-03-25 13:37 UTC

EmailAttachment::getFilename() A

↳ Parent: EmailAttachment

Complexity

Conditions	3
Paths	4

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3

Importance

Changes

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

<?php
/*
 You may not change or alter any portion of this comment or credits of supporting
 developers from this source code or any supporting source code which is considered
 copyrighted (c) material of the original  comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/

namespace Xoops\Core\Service\Data;

use Xmf\Assert;

/**
 * The EmailAddress data object is a email address with optional display name
 *
 * This is an Immutable data object. That means any changes to the data (state)
 * return a new object, while the internal state of the original object is preserved.
 *
 * All data is validated for type and value, and an exception is generated when
 * data on any operation for a property when it is not valid.
 *
 * The EmailAttachment data object is used for mailer services
 *
 * @category  Xoops\Core\Service\Data
 * @package   Xoops\Core
 * @author    Richard Griffith <[email protected]>
 * @copyright 2018 XOOPS Project (https://xoops.org)
 * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 * @link      https://xoops.org
 */
class EmailAttachment
{
    /** @var string $filename fully qualified file name of file to be attached */
    protected $filename;

    /** @var string $mimeType mime-type of attached content */
    protected $mimeType;

    /** @var string $stringBody content to be attached, if not from file */
    protected $stringBody;

    /** @var string $name name or content id of this attachment */
    protected $name;

    /** @var bool $inline treat attachment as inline if true, as download if false (default) */
    protected $inline = false;

    /* assert messages */
    protected const MESSAGE_FILE   = 'File is invalid';
    protected const MESSAGE_MIME   = 'Mime Type is invalid';
    protected const MESSAGE_NAME   = 'Name is invalid';
    protected const MESSAGE_BODY   = 'Body string is invalid';
    protected const MESSAGE_INLINE = 'Inline flag is invalid';

    protected const MIME_REGEX = '/^[a-z0-9\-+.]+\/[a-z0-9\-+.]+$/';

    /**
     * EmailAttachment constructor.
     *
     * If an argument is null, the corresponding value will not be set. Values can be set
     * later with the with*() methods, but each will result in a new object.
     *
     * @param null|string $filename fully qualified filename of file to attach
     * @param null|string $mimeType mime-type of file
     *
     * @throws \InvalidArgumentException
     */
    public function __construct(?string $filename = null, ?string $mimeType = null)
    {
        if (null!==$filename) {
            Assert::fileExists($filename, static::MESSAGE_FILE);
            $this->filename = $filename;
        }
        if (null!==$mimeType) {
            Assert::regex($mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
            $this->mimeType = $mimeType;
        }
    }

    /**
     * withFilename
     *
     * @param string $filename fully qualified filename
     *
     * @return EmailAttachment
     *
     * @throws \InvalidArgumentException
     */
    public function withFilename(string $filename) : EmailAttachment
    {
        Assert::fileExists($filename, static::MESSAGE_FILE);
        $new = clone $this;
        $new->filename = $filename;
        return $new;
    }

    /**
     * withMimeType
     *
     * @param string $mimeType mime type of the filename contents or stringBody
     *
     * @return EmailAttachment
     *
     * @throws \InvalidArgumentException
     */
    public function withMimeType(string $mimeType)  : EmailAttachment
    {
        Assert::regex($mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
        $new = clone $this;
        $new->mimeType = $mimeType;
        return $new;
    }

    /**
     * withName
     *
     * @param string $name name or content id for attachment
     *
     * @return EmailAttachment
     *
     * @throws \InvalidArgumentException
     */
    public function withName(string $name) : EmailAttachment
    {
        Assert::stringNotEmpty($name, static::MESSAGE_NAME);
        $new = clone $this;
        $new->name = $name;
        return $new;
    }

    /**
     * withStringBody
     *
     * @param string $stringBody alternate body used instead of file contents
     *
     * @return EmailAttachment
     *
     * @throws \InvalidArgumentException
     */
    public function withStringBody(string $stringBody) : EmailAttachment
    {
        Assert::stringNotEmpty($stringBody, static::MESSAGE_BODY);
        $new = clone $this;
        $new->stringBody = $stringBody;
        return $new;
    }

    /**
     * withInlineAttribute
     *
     * @param bool $inline true to treat attachment as inline, false for download
     *
     * @return EmailAttachment
     *
     * @throws \InvalidArgumentException
     */
    public function withInlineAttribute(bool $inline = true) : EmailAttachment
    {
        Assert::boolean($inline, static::MESSAGE_INLINE);
        $new = clone $this;
        $new->inline = $inline;
        return $new;
    }

    /**
     * getFilename
     *
     * @return string an file name
     *
     * @throws \LogicException (property was not properly set before used)
     */
    public function getFilename() : ?string
    {
        if (null === $this->stringBody) {
            try {
                Assert::notNull($this->filename, static::MESSAGE_FILE);
                Assert::fileExists($this->filename, static::MESSAGE_FILE);
            } catch (\InvalidArgumentException $e) {
                throw new \LogicException($e->getMessage(), $e->getCode(), $e);
            }
        }
        return $this->filename;
    }

    /**
     * getMimeType
     *
     * @return string|null mime type of filename contents or stringBody
     *
     * @throws \LogicException (property was not properly set before used)
     */
    public function getMimeType() : ?string
    {
        try {
            Assert::nullOrRegex($this->mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
        } catch (\InvalidArgumentException $e) {
            throw new \LogicException($e->getMessage(), $e->getCode(), $e);
        }
        return $this->mimeType;
    }

    /**
     * getName
     *
     * @return string|null name or content id for attachment
     *
     * @throws \LogicException (property was not properly set before used)
     */
    public function getName() : ?string
    {
        try {
            Assert::nullOrStringNotEmpty($this->name, static::MESSAGE_NAME);
        } catch (\InvalidArgumentException $e) {
            throw new \LogicException($e->getMessage(), $e->getCode(), $e);
        }
        return $this->name;
    }

    /**
     * getStringBody
     *
     * @return string|null string body attachment contents
     *
     * @throws \LogicException (property was not properly set before used)
     */
    public function getStringBody() : ?string
    {
        if (null === $this->filename) {
            try {
                Assert::stringNotEmpty($this->stringBody, static::MESSAGE_BODY);
            } catch (\InvalidArgumentException $e) {
                throw new \LogicException($e->getMessage(), $e->getCode(), $e);
            }
        }
        return $this->stringBody;
    }

    /**
     * getInlineAttribute
     *
     * @return bool attachment inline attribute, true for inline, false for download
     */
    public function getInlineAttribute() : bool
    {
        return (bool) $this->inline;
    }
}


1		<?php
2		/*
3		You may not change or alter any portion of this comment or credits of supporting
4		developers from this source code or any supporting source code which is considered
5		copyrighted (c) material of the original comment or credit authors.
6
7		This program is distributed in the hope that it will be useful,
8		but WITHOUT ANY WARRANTY; without even the implied warranty of
9		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10		*/
11
12		namespace Xoops\Core\Service\Data;
13
14		use Xmf\Assert;
15
16		/**
17		* The EmailAddress data object is a email address with optional display name
18		*
19		* This is an Immutable data object. That means any changes to the data (state)
20		* return a new object, while the internal state of the original object is preserved.
21		*
22		* All data is validated for type and value, and an exception is generated when
23		* data on any operation for a property when it is not valid.
24		*
25		* The EmailAttachment data object is used for mailer services
26		*
27		* @category Xoops\Core\Service\Data
28		* @package Xoops\Core
29		* @author Richard Griffith <[email protected]>
30		* @copyright 2018 XOOPS Project (https://xoops.org)
31		* @license GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
32		* @link https://xoops.org
33		*/
34		class EmailAttachment
35		{
36		/** @var string $filename fully qualified file name of file to be attached */
37		protected $filename;
38
39		/** @var string $mimeType mime-type of attached content */
40		protected $mimeType;
41
42		/** @var string $stringBody content to be attached, if not from file */
43		protected $stringBody;
44
45		/** @var string $name name or content id of this attachment */
46		protected $name;
47
48		/** @var bool $inline treat attachment as inline if true, as download if false (default) */
49		protected $inline = false;
50
51		/* assert messages */
52		protected const MESSAGE_FILE = 'File is invalid';
53		protected const MESSAGE_MIME = 'Mime Type is invalid';
54		protected const MESSAGE_NAME = 'Name is invalid';
55		protected const MESSAGE_BODY = 'Body string is invalid';
56		protected const MESSAGE_INLINE = 'Inline flag is invalid';
57
58		protected const MIME_REGEX = '/^[a-z0-9\-+.]+\/[a-z0-9\-+.]+$/';
59
60		/**
61		* EmailAttachment constructor.
62		*
63		* If an argument is null, the corresponding value will not be set. Values can be set
64		* later with the with*() methods, but each will result in a new object.
65		*
66		* @param null\|string $filename fully qualified filename of file to attach
67		* @param null\|string $mimeType mime-type of file
68		*
69		* @throws \InvalidArgumentException
70		*/
71	18	public function __construct(?string $filename = null, ?string $mimeType = null)
72		{
73	18	if (null!==$filename) {
74	6	Assert::fileExists($filename, static::MESSAGE_FILE);
75	5	$this->filename = $filename;
76		}
77	18	if (null!==$mimeType) {
78	1	Assert::regex($mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
79	1	$this->mimeType = $mimeType;
80		}
81	18	}
82
83		/**
84		* withFilename
85		*
86		* @param string $filename fully qualified filename
87		*
88		* @return EmailAttachment
89		*
90		* @throws \InvalidArgumentException
91		*/
92	1	public function withFilename(string $filename) : EmailAttachment
93		{
94	1	Assert::fileExists($filename, static::MESSAGE_FILE);
95	1	$new = clone $this;
96	1	$new->filename = $filename;
97	1	return $new;
98		}
99
100		/**
101		* withMimeType
102		*
103		* @param string $mimeType mime type of the filename contents or stringBody
104		*
105		* @return EmailAttachment
106		*
107		* @throws \InvalidArgumentException
108		*/
109	1	public function withMimeType(string $mimeType) : EmailAttachment
110		{
111	1	Assert::regex($mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
112	1	$new = clone $this;
113	1	$new->mimeType = $mimeType;
114	1	return $new;
115		}
116
117		/**
118		* withName
119		*
120		* @param string $name name or content id for attachment
121		*
122		* @return EmailAttachment
123		*
124		* @throws \InvalidArgumentException
125		*/
126	1	public function withName(string $name) : EmailAttachment
127		{
128	1	Assert::stringNotEmpty($name, static::MESSAGE_NAME);
129	1	$new = clone $this;
130	1	$new->name = $name;
131	1	return $new;
132		}
133
134		/**
135		* withStringBody
136		*
137		* @param string $stringBody alternate body used instead of file contents
138		*
139		* @return EmailAttachment
140		*
141		* @throws \InvalidArgumentException
142		*/
143	3	public function withStringBody(string $stringBody) : EmailAttachment
144		{
145	3	Assert::stringNotEmpty($stringBody, static::MESSAGE_BODY);
146	3	$new = clone $this;
147	3	$new->stringBody = $stringBody;
148	3	return $new;
149		}
150
151		/**
152		* withInlineAttribute
153		*
154		* @param bool $inline true to treat attachment as inline, false for download
155		*
156		* @return EmailAttachment
157		*
158		* @throws \InvalidArgumentException
159		*/
160	1	public function withInlineAttribute(bool $inline = true) : EmailAttachment
161		{
162	1	Assert::boolean($inline, static::MESSAGE_INLINE);
163	1	$new = clone $this;
164	1	$new->inline = $inline;
165	1	return $new;
166		}
167
168		/**
169		* getFilename
170		*
171		* @return string an file name
172		*
173		* @throws \LogicException (property was not properly set before used)
174		*/
175	10	public function getFilename() : ?string
176		{
177	10	if (null === $this->stringBody) {
178		try {
179	9	Assert::notNull($this->filename, static::MESSAGE_FILE);
180	6	Assert::fileExists($this->filename, static::MESSAGE_FILE);
181	3	} catch (\InvalidArgumentException $e) {
182	3	throw new \LogicException($e->getMessage(), $e->getCode(), $e);
183		}
184		}
185	7	return $this->filename;
186		}
187
188		/**
189		* getMimeType
190		*
191		* @return string\|null mime type of filename contents or stringBody
192		*
193		* @throws \LogicException (property was not properly set before used)
194		*/
195	3	public function getMimeType() : ?string
196		{
197		try {
198	3	Assert::nullOrRegex($this->mimeType, static::MIME_REGEX, static::MESSAGE_MIME);
199	1	} catch (\InvalidArgumentException $e) {
200	1	throw new \LogicException($e->getMessage(), $e->getCode(), $e);
201		}
202	2	return $this->mimeType;
203		}
204
205		/**
206		* getName
207		*
208		* @return string\|null name or content id for attachment
209		*
210		* @throws \LogicException (property was not properly set before used)
211		*/
212	2	public function getName() : ?string
213		{
214		try {
215	2	Assert::nullOrStringNotEmpty($this->name, static::MESSAGE_NAME);
216	1	} catch (\InvalidArgumentException $e) {
217	1	throw new \LogicException($e->getMessage(), $e->getCode(), $e);
218		}
219	1	return $this->name;
220		}
221
222		/**
223		* getStringBody
224		*
225		* @return string\|null string body attachment contents
226		*
227		* @throws \LogicException (property was not properly set before used)
228		*/
229	6	public function getStringBody() : ?string
230		{
231	6	if (null === $this->filename) {
232		try {
233	4	Assert::stringNotEmpty($this->stringBody, static::MESSAGE_BODY);
234	1	} catch (\InvalidArgumentException $e) {
235	1	throw new \LogicException($e->getMessage(), $e->getCode(), $e);
236		}
237		}
238	5	return $this->stringBody;
239		}
240
241		/**
242		* getInlineAttribute
243		*
244		* @return bool attachment inline attribute, true for inline, false for download
245		*/
246	1	public function getInlineAttribute() : bool
247		{
248	1	return (bool) $this->inline;
249		}
250		}
251

XOOPS / XoopsCore

Pull Request — master (#578)

EmailAttachment::getFilename() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like