Part - Code Metrics - pedrosoares/imap - Measure and Improve Code Quality continuously with Scrutinizer

Part C
last analyzed 2016-03-24 14:15 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	356
Duplicated Lines	3.93 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	26
Bugs	9	Features	3

Metric	Value
wmc	63
c	26
b	9
f	3
lcom	1
cbo	4
dl	14
loc	356
rs	5.8893

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getCharset()	0	4	1
A	getType()	0	4	1
A	getSubtype()	0	4	1
A	getEncoding()	0	4	1
A	getBytes()	0	4	1
A	getLines()	0	4	1
A	getParameters()	0	4	1
A	getContent()	0	8	2
D	getDecodedContent()	0	33	9
A	getStructure()	0	4	1
A	fetchStructure()	0	12	3
F	parseStructure()	0	49	15
A	getParts()	0	4	1
A	current()	0	4	1
A	getChildren()	0	4	1
A	hasChildren()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	getDisposition()	0	4	1
A	doGetContent()	0	9	3
C	isAttachment()	14	34	13

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 Part 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 Part, and based on these observations, apply Extract Interface, too.

<?php

namespace Ddeboer\Imap\Message;

use Ddeboer\Imap\Parameters;
use Ddeboer\Transcoder\Transcoder;

/**
 * A message part
 */
class Part implements \RecursiveIterator
{
    const TYPE_TEXT = 'text';
    const TYPE_MULTIPART = 'multipart';
    const TYPE_MESSAGE = 'message';
    const TYPE_APPLICATION = 'application';
    const TYPE_AUDIO = 'audio';
    const TYPE_IMAGE = 'image';
    const TYPE_VIDEO = 'video';
    const TYPE_OTHER = 'other';
    const TYPE_UNKNOWN = 'unknown';

    const ENCODING_7BIT = '7bit';
    const ENCODING_8BIT = '8bit';
    const ENCODING_BINARY = 'binary';
    const ENCODING_BASE64 = 'base64';
    const ENCODING_QUOTED_PRINTABLE = 'quoted-printable';
    const ENCODING_UNKNOWN = 'unknown';

    const SUBTYPE_TEXT = 'TEXT';
    const SUBTYPE_HTML = 'HTML';

    protected $typesMap = array(
        0 => self::TYPE_TEXT,
        1 => self::TYPE_MULTIPART,
        2 => self::TYPE_MESSAGE,
        3 => self::TYPE_APPLICATION,
        4 => self::TYPE_AUDIO,
        5 => self::TYPE_IMAGE,
        6 => self::TYPE_VIDEO,
        7 => self::TYPE_OTHER
    );

    protected $encodingsMap = array(
        0 => self::ENCODING_7BIT,
        1 => self::ENCODING_8BIT,
        2 => self::ENCODING_BINARY,
        3 => self::ENCODING_BASE64,
        4 => self::ENCODING_QUOTED_PRINTABLE,
        5 => self::ENCODING_UNKNOWN
    );

    protected $type;

    protected $subtype;

    protected $encoding;

    protected $bytes;

    protected $lines;

    /**
     * @var Parameters
     */
    protected $parameters;

    protected $stream;

    protected $messageNumber;

    protected $partNumber;

    protected $structure;

    protected $content;

    protected $decodedContent;

    protected $parts = array();

    protected $key = 0;

    protected $disposition;

    /**
     * Constructor
     *
     * @param resource  $stream        IMAP stream
     * @param int       $messageNumber Message number
     * @param int       $partNumber    Part number (optional)
     * @param \stdClass $structure     Part structure
     */
    public function __construct(
        $stream,
        $messageNumber,
        $partNumber = null,
        \stdClass $structure = null
    ) {
        $this->stream = $stream;
        $this->messageNumber = $messageNumber;
        $this->partNumber = $partNumber;
        $this->structure = $structure;
        $this->parseStructure($structure);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
    }

    public function getCharset()
    {
        return $this->parameters->get('charset');
    }

    public function getType()
    {
        return $this->type;
    }

    public function getSubtype()
    {
        return $this->subtype;
    }

    public function getEncoding()
    {
        return $this->encoding;
    }

    public function getBytes()
    {
        return $this->bytes;
    }

    public function getLines()
    {
        return $this->lines;
    }

    public function getParameters()
    {
        return $this->parameters;
    }

    /**
     * Get raw part content
     *
     * @return string
     */
    public function getContent($keepUnseen = false)
    {
        if (null === $this->content) {
            $this->content = $this->doGetContent($keepUnseen);
        }

        return $this->content;
    }

    /**
     * Get decoded part content
     *
     * @return string
     */
    public function getDecodedContent($keepUnseen = false)
    {
        if (null === $this->decodedContent) {
            switch ($this->getEncoding()) {
                case self::ENCODING_BASE64:
                    $this->decodedContent = base64_decode($this->getContent($keepUnseen));
                    break;
                case self::ENCODING_QUOTED_PRINTABLE:
                    $this->decodedContent =  quoted_printable_decode($this->getContent($keepUnseen));
                    break;
                case self::ENCODING_7BIT:
                case self::ENCODING_8BIT:
                case self::ENCODING_BINARY:
                    $this->decodedContent = $this->getContent($keepUnseen);
                    break;
                default:
                    throw new \UnexpectedValueException('Cannot decode ' . $this->getEncoding());
            }

            // If this part is a text part, try to convert its encoding to UTF-8.
            // We don't want to convert an attachment's encoding.
            if ($this->getType() === self::TYPE_TEXT
                && strtolower($this->getCharset()) != 'utf-8'
            ) {
                $this->decodedContent = Transcoder::create()->transcode(
                    $this->decodedContent,
                    $this->getCharset()
                );
            }
        }

        return $this->decodedContent;
    }

    public function getStructure()
    {
        return $this->structure;
    }

    protected function fetchStructure($partNumber = null)
    {
        if (null === $this->structure) {
            $this->loadStructure();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        if ($partNumber) {
            return $this->structure->parts[$partNumber];
        }

        return $this->structure;
    }

    protected function parseStructure(\stdClass $structure) {

        if (isset($structure->type) && isset($this->typesMap[$structure->type])) {
            $this->type = $this->typesMap[$structure->type];
        } else {
            $this->type = self::TYPE_UNKNOWN;
        }

        if(isset($structure->encoding))
        $this->encoding = $this->encodingsMap[$structure->encoding];
        if(isset($structure->subtype))
        $this->subtype = $structure->subtype;

        if (isset($structure->bytes)) {
            $this->bytes = $structure->bytes;
        }

        foreach (array('disposition', 'bytes', 'description') as $optional) {
            if (isset($structure->$optional)) {
                $this->$optional = $structure->$optional;
            }
        }

        $this->parameters = new Parameters();
        if(isset($structure->parameters))
        if (is_array($structure->parameters)) {
            $this->parameters->add($structure->parameters);
        }

        if (isset($structure->dparameters)) {
            $this->parameters->add($structure->dparameters);
        }

        if (isset($structure->parts)) {
            foreach ($structure->parts as $key => $partStructure) {
                if (null === $this->partNumber) {
                    $partNumber = ($key + 1);
                } else {
                    $partNumber = (string) ($this->partNumber . '.' . ($key+1));
                }

                if ($this->isAttachment($partStructure)) {
                    $this->parts[] = new Attachment($this->stream, $this->messageNumber, $partNumber, $partStructure);
                } else {
                    $this->parts[] = new Part($this->stream, $this->messageNumber, $partNumber, $partStructure);
                }
            }
        }
    }

    /**
     * Get an array of all parts for this message
     *
     * @return self[]
     */
    public function getParts()
    {
        return $this->parts;
    }

    public function current()
    {
        return $this->parts[$this->key];
    }

    public function getChildren()
    {
        return $this->current();
    }

    public function hasChildren()
    {
        return count($this->parts) > 0;
    }

    public function key()
    {
        return $this->key;
    }

    public function next()
    {
        ++$this->key;
    }

    public function rewind()
    {
        $this->key = 0;
    }

    public function valid()
    {
        return isset($this->parts[$this->key]);
    }

    public function getDisposition()
    {
        return $this->disposition;
    }

    /**
     * Get raw message content
     *
     * @param bool $keepUnseen Whether to keep the message unseen.
     *                         Default behaviour is set set the seen flag when
     *                         getting content.
     *
     * @return string
     */
    protected function doGetContent($keepUnseen = false)
    {
        return imap_fetchbody(
            $this->stream,
            $this->messageNumber,
            $this->partNumber ?: 1,
            \FT_UID | ($keepUnseen ? \FT_PEEK : null)
        );
    }

    private function isAttachment($part) {

        // Attachment with correct Content-Disposition header
        if (isset($part->disposition)) {
            if (('attachment' === strtolower($part->disposition)
                || 'inline' === strtolower($part->disposition))
            && strtoupper($part->subtype) != "PLAIN"
            ) {
                return true;
            }
        }

        // Attachment without Content-Disposition header
        if (isset($part->parameters)) {
            foreach ($part->parameters as $parameter) {

                if ('name' === strtolower($parameter->attribute)
                    || 'filename' === strtolower($parameter->attribute)
                ) {
                    return true;
                }
            }

            if(isset($part->dparameters))
            foreach ($part->dparameters as $parameter) {

                if ('name' === strtolower($parameter->attribute)
                    || 'filename' === strtolower($parameter->attribute)
                ) {
                    return true;
                }
            }
        }

        return false;
    }
}


1		<?php
2
3		namespace Ddeboer\Imap\Message;
4
5		use Ddeboer\Imap\Parameters;
6		use Ddeboer\Transcoder\Transcoder;
7
8		/**
9		* A message part
10		*/
11		class Part implements \RecursiveIterator
12		{
13		const TYPE_TEXT = 'text';
14		const TYPE_MULTIPART = 'multipart';
15		const TYPE_MESSAGE = 'message';
16		const TYPE_APPLICATION = 'application';
17		const TYPE_AUDIO = 'audio';
18		const TYPE_IMAGE = 'image';
19		const TYPE_VIDEO = 'video';
20		const TYPE_OTHER = 'other';
21		const TYPE_UNKNOWN = 'unknown';
22
23		const ENCODING_7BIT = '7bit';
24		const ENCODING_8BIT = '8bit';
25		const ENCODING_BINARY = 'binary';
26		const ENCODING_BASE64 = 'base64';
27		const ENCODING_QUOTED_PRINTABLE = 'quoted-printable';
28		const ENCODING_UNKNOWN = 'unknown';
29
30		const SUBTYPE_TEXT = 'TEXT';
31		const SUBTYPE_HTML = 'HTML';
32
33		protected $typesMap = array(
34		0 => self::TYPE_TEXT,
35		1 => self::TYPE_MULTIPART,
36		2 => self::TYPE_MESSAGE,
37		3 => self::TYPE_APPLICATION,
38		4 => self::TYPE_AUDIO,
39		5 => self::TYPE_IMAGE,
40		6 => self::TYPE_VIDEO,
41		7 => self::TYPE_OTHER
42		);
43
44		protected $encodingsMap = array(
45		0 => self::ENCODING_7BIT,
46		1 => self::ENCODING_8BIT,
47		2 => self::ENCODING_BINARY,
48		3 => self::ENCODING_BASE64,
49		4 => self::ENCODING_QUOTED_PRINTABLE,
50		5 => self::ENCODING_UNKNOWN
51		);
52
53		protected $type;
54
55		protected $subtype;
56
57		protected $encoding;
58
59		protected $bytes;
60
61		protected $lines;
62
63		/**
64		* @var Parameters
65		*/
66		protected $parameters;
67
68		protected $stream;
69
70		protected $messageNumber;
71
72		protected $partNumber;
73
74		protected $structure;
75
76		protected $content;
77
78		protected $decodedContent;
79
80		protected $parts = array();
81
82		protected $key = 0;
83
84		protected $disposition;
85
86		/**
87		* Constructor
88		*
89		* @param resource $stream IMAP stream
90		* @param int $messageNumber Message number
91		* @param int $partNumber Part number (optional)
92		* @param \stdClass $structure Part structure
93		*/
94		public function __construct(
95		$stream,
96		$messageNumber,
97		$partNumber = null,
98		\stdClass $structure = null
99		) {
100		$this->stream = $stream;
101		$this->messageNumber = $messageNumber;
102		$this->partNumber = $partNumber;
103		$this->structure = $structure;
104		$this->parseStructure($structure);
		0 ignored issues – show Bug introduced 2016-03-24 14:15 UTC by Report Bug Copy Issue Report It seems like `$structure` defined by parameter `$structure` on line `98` can be `null`; however, `Ddeboer\Imap\Message\Part::parseStructure()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
105		}
106
107		public function getCharset()
108		{
109		return $this->parameters->get('charset');
110		}
111
112		public function getType()
113		{
114		return $this->type;
115		}
116
117		public function getSubtype()
118		{
119		return $this->subtype;
120		}
121
122		public function getEncoding()
123		{
124		return $this->encoding;
125		}
126
127		public function getBytes()
128		{
129		return $this->bytes;
130		}
131
132		public function getLines()
133		{
134		return $this->lines;
135		}
136
137		public function getParameters()
138		{
139		return $this->parameters;
140		}
141
142		/**
143		* Get raw part content
144		*
145		* @return string
146		*/
147		public function getContent($keepUnseen = false)
148		{
149		if (null === $this->content) {
150		$this->content = $this->doGetContent($keepUnseen);
151		}
152
153		return $this->content;
154		}
155
156		/**
157		* Get decoded part content
158		*
159		* @return string
160		*/
161		public function getDecodedContent($keepUnseen = false)
162		{
163		if (null === $this->decodedContent) {
164		switch ($this->getEncoding()) {
165		case self::ENCODING_BASE64:
166		$this->decodedContent = base64_decode($this->getContent($keepUnseen));
167		break;
168		case self::ENCODING_QUOTED_PRINTABLE:
169		$this->decodedContent = quoted_printable_decode($this->getContent($keepUnseen));
170		break;
171		case self::ENCODING_7BIT:
172		case self::ENCODING_8BIT:
173		case self::ENCODING_BINARY:
174		$this->decodedContent = $this->getContent($keepUnseen);
175		break;
176		default:
177		throw new \UnexpectedValueException('Cannot decode ' . $this->getEncoding());
178		}
179
180		// If this part is a text part, try to convert its encoding to UTF-8.
181		// We don't want to convert an attachment's encoding.
182		if ($this->getType() === self::TYPE_TEXT
183		&& strtolower($this->getCharset()) != 'utf-8'
184		) {
185		$this->decodedContent = Transcoder::create()->transcode(
186		$this->decodedContent,
187		$this->getCharset()
188		);
189		}
190		}
191
192		return $this->decodedContent;
193		}
194
195		public function getStructure()
196		{
197		return $this->structure;
198		}
199
200		protected function fetchStructure($partNumber = null)
201		{
202		if (null === $this->structure) {
203		$this->loadStructure();
		0 ignored issues – show Bug introduced 2016-03-24 14:15 UTC by Report Bug Copy Issue Report It seems like you code against a specific sub-type and not the parent class `Ddeboer\Imap\Message\Part` as the method `loadStructure()` does only exist in the following sub-classes of `Ddeboer\Imap\Message\Part`: `Ddeboer\Imap\Message`. Maybe you want to `instanceof` check for one of these explicitly? Let’s take a look at an example: abstract class User { /** @return string / abstract public function getPassword(); } class MyUser extends User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different sub-classes of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the parent class: abstract class User { /** @return string / abstract public function getPassword(); /* @return string */ abstract public function getDisplayName(); } Loading history...
204		}
205
206		if ($partNumber) {
207		return $this->structure->parts[$partNumber];
208		}
209
210		return $this->structure;
211		}
212
213		protected function parseStructure(\stdClass $structure) {
214
215		if (isset($structure->type) && isset($this->typesMap[$structure->type])) {
216		$this->type = $this->typesMap[$structure->type];
217		} else {
218		$this->type = self::TYPE_UNKNOWN;
219		}
220
221		if(isset($structure->encoding))
222		$this->encoding = $this->encodingsMap[$structure->encoding];
223		if(isset($structure->subtype))
224		$this->subtype = $structure->subtype;
225
226		if (isset($structure->bytes)) {
227		$this->bytes = $structure->bytes;
228		}
229
230		foreach (array('disposition', 'bytes', 'description') as $optional) {
231		if (isset($structure->$optional)) {
232		$this->$optional = $structure->$optional;
233		}
234		}
235
236		$this->parameters = new Parameters();
237		if(isset($structure->parameters))
238		if (is_array($structure->parameters)) {
239		$this->parameters->add($structure->parameters);
240		}
241
242		if (isset($structure->dparameters)) {
243		$this->parameters->add($structure->dparameters);
244		}
245
246		if (isset($structure->parts)) {
247		foreach ($structure->parts as $key => $partStructure) {
248		if (null === $this->partNumber) {
249		$partNumber = ($key + 1);
250		} else {
251		$partNumber = (string) ($this->partNumber . '.' . ($key+1));
252		}
253
254		if ($this->isAttachment($partStructure)) {
255		$this->parts[] = new Attachment($this->stream, $this->messageNumber, $partNumber, $partStructure);
256		} else {
257		$this->parts[] = new Part($this->stream, $this->messageNumber, $partNumber, $partStructure);
258		}
259		}
260		}
261		}
262
263		/**
264		* Get an array of all parts for this message
265		*
266		* @return self[]
267		*/
268		public function getParts()
269		{
270		return $this->parts;
271		}
272
273		public function current()
274		{
275		return $this->parts[$this->key];
276		}
277
278		public function getChildren()
279		{
280		return $this->current();
281		}
282
283		public function hasChildren()
284		{
285		return count($this->parts) > 0;
286		}
287
288		public function key()
289		{
290		return $this->key;
291		}
292
293		public function next()
294		{
295		++$this->key;
296		}
297
298		public function rewind()
299		{
300		$this->key = 0;
301		}
302
303		public function valid()
304		{
305		return isset($this->parts[$this->key]);
306		}
307
308		public function getDisposition()
309		{
310		return $this->disposition;
311		}
312
313		/**
314		* Get raw message content
315		*
316		* @param bool $keepUnseen Whether to keep the message unseen.
317		* Default behaviour is set set the seen flag when
318		* getting content.
319		*
320		* @return string
321		*/
322		protected function doGetContent($keepUnseen = false)
323		{
324		return imap_fetchbody(
325		$this->stream,
326		$this->messageNumber,
327		$this->partNumber ?: 1,
328		\FT_UID \| ($keepUnseen ? \FT_PEEK : null)
329		);
330		}
331
332		private function isAttachment($part) {
333
334		// Attachment with correct Content-Disposition header
335		if (isset($part->disposition)) {
336		if (('attachment' === strtolower($part->disposition)
337		\|\| 'inline' === strtolower($part->disposition))
338		&& strtoupper($part->subtype) != "PLAIN"
339		) {
340		return true;
341		}
342		}
343
344		// Attachment without Content-Disposition header
345		if (isset($part->parameters)) {
346	View Code Duplication	foreach ($part->parameters as $parameter) {
		0 ignored issues – show Duplication introduced 2016-03-24 14:15 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...
347		if ('name' === strtolower($parameter->attribute)
348		\|\| 'filename' === strtolower($parameter->attribute)
349		) {
350		return true;
351		}
352		}
353
354		if(isset($part->dparameters))
355	View Code Duplication	foreach ($part->dparameters as $parameter) {
		0 ignored issues – show Duplication introduced 2016-03-24 14:15 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		if ('name' === strtolower($parameter->attribute)
357		\|\| 'filename' === strtolower($parameter->attribute)
358		) {
359		return true;
360		}
361		}
362		}
363
364		return false;
365		}
366		}
367

pedrosoares / imap

Part C last analyzed 2016-03-24 14:15 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

24 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Duplication Side-by-Side

Filter issues like

Part C
last analyzed 2016-03-24 14:15 UTC