GenericConsumer::shouldAddSpace() - Code Metrics - Inspection of "Cleanup/fix scrutinizer complaints" - zbateson/mail-mime-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c7cf7f...702f4a )

by Zaahid

created 2016-02-29 04:16 UTC

GenericConsumer::shouldAddSpace() A

↳ Parent: GenericConsumer

Complexity

Conditions	3
Paths	3

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	4
rs	10
cc	3
eloc	2
nc	3
nop	2

<?php
/**
 * This file is part of the ZBateson\MailMimeParser project.
 *
 * @license http://opensource.org/licenses/bsd-license.php BSD
 */
namespace ZBateson\MailMimeParser\Header\Consumer;

use ZBateson\MailMimeParser\Header\Part\HeaderPart;
use ZBateson\MailMimeParser\Header\Part\Token;

/**
 * A minimal implementation of AbstractConsumer defining a CommentConsumer and
 * QuotedStringConsumer as sub-consumers, and splitting tokens by whitespace.
 *
 * Note that GenericConsumer should be instantiated with a
 * MimeLiteralPartFactory instead of a HeaderPartFactory.  Sub-classes may not
 * need MimeLiteralPartFactory instances though.
 * 
 * @author Zaahid Bateson
 */
class GenericConsumer extends AbstractConsumer
{
    /**
     * Returns \ZBateson\MailMimeParser\Header\Consumer\CommentConsumer and
     * \ZBateson\MailMimeParser\Header\Consumer\QuotedStringConsumer as
     * sub-consumers.
     * 
     * @return AbstractConsumer[] the sub-consumers
     */
    protected function getSubConsumers()
    {
        return [
            $this->consumerService->getCommentConsumer(),
            $this->consumerService->getQuotedStringConsumer(),
        ];
    }
    
    /**
     * Returns the regex '\s+' (whitespace) pattern matcher as a token marker so
     * the header value is split along whitespace characters.  GenericConsumer
     * filters out whitespace-only tokens from getPartForToken.
     * 
     * The whitespace character delimits mime-encoded parts for decoding.
     * 
     * @return string[] an array of regex pattern matchers
     */
    protected function getTokenSeparators()
    {
        return ['\s+'];
    }
    
    /**
     * GenericConsumer doesn't have start/end tokens, and so always returns
     * false.
     * 
     * @param string $token
     * @return boolean false
     */
    protected function isEndToken($token)
    {
        return false;
    }
    
    /**
     * GenericConsumer doesn't have start/end tokens, and so always returns
     * false.
     * 
     * @param string $token
     * @return boolean false
     */
    protected function isStartToken($token)
    {
        return false;
    }
    
    /**
     * Returns true if a space should be added based on the passed last and next
     * parts.
     * 
     * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $lastPart
     * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $nextPart
     * @return bool
     */
    private function shouldAddSpace(HeaderPart $lastPart, HeaderPart $nextPart)
    {
        return ($lastPart !== null && (!$lastPart->ignoreSpacesAfter() || !$nextPart->ignoreSpacesBefore()));
    }
    
    /**
     * Checks if the passed space part should be added to the returned parts and
     * adds it.
     * 
     * Never adds a space if it's the first part, otherwise only add it if
     * either part isn't set to ignore the space
     * 
     * @param array $parts
     * @param array $retParts
     * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $spacePart
     * @param int $curIndex
     */
    private function addSpaces(array $parts, array &$retParts, &$spacePart, $curIndex)
    {
        if ($spacePart === null || $parts[$curIndex]->getValue() === '') {
            return;
        }
        $lastPart = end($retParts);
        $count = count($parts);
        for ($j = $curIndex; $j < $count; ++$j) {
            $nextPart = $parts[$j];
            if ($this->shouldAddSpace($lastPart, $nextPart)) {
                $retParts[] = $spacePart;
                $spacePart = null;
                break;
            }
        }
    }
    
    /**
     * 
     * @param HeaderPart $part
     * @return type
     */
    private function isSpaceToken(HeaderPart $part)
    {
        return ($part instanceof Token && $part->isSpace());
    }
    
    /**
     * Filters out ignorable spaces between parts in the passed array.
     * 
     * Spaces with parts on either side of it that specify they can be ignored
     * are filtered out.  filterIgnoredSpaces is called from within
     * processParts, and if needed by an implementing class that overrides
     * processParts, must be specifically called.
     * 
     * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
     * @return \ZBateson\MailMimeParser\Header\Part\HeaderPart[]
     */
    protected function filterIgnoredSpaces(array $parts)
    {
        $retParts = [];
        $spacePart = null;
        $count = count($parts);
        for ($i = 0; $i < $count; ++$i) {
            $part = $parts[$i];
            if ($this->isSpaceToken($part)) {
                $spacePart = $part;
                continue;
            }
            $this->addSpaces($parts, $retParts, $spacePart, $i);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $retParts[] = $part;
        }
        // ignore trailing spaces
        return $retParts;
    }
    
    /**
     * Overridden to combine all part values into a single string and return it
     * as an array with a single element.
     * 
     * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
     * @return \ZBateson\MailMimeParser\Header\Part\LiteralPart[]|array
     */
    protected function processParts(array $parts)
    {
        $strValue = '';
        $filtered = $this->filterIgnoredSpaces($parts);
        foreach ($filtered as $part) {
            $strValue .= $part->getValue();
        }
        return [$this->partFactory->newLiteralPart($strValue)];
    }
}


1			<?php
2			/**
3			* This file is part of the ZBateson\MailMimeParser project.
4			*
5			* @license http://opensource.org/licenses/bsd-license.php BSD
6			*/
7			namespace ZBateson\MailMimeParser\Header\Consumer;
8
9			use ZBateson\MailMimeParser\Header\Part\HeaderPart;
10			use ZBateson\MailMimeParser\Header\Part\Token;
11
12			/**
13			* A minimal implementation of AbstractConsumer defining a CommentConsumer and
14			* QuotedStringConsumer as sub-consumers, and splitting tokens by whitespace.
15			*
16			* Note that GenericConsumer should be instantiated with a
17			* MimeLiteralPartFactory instead of a HeaderPartFactory. Sub-classes may not
18			* need MimeLiteralPartFactory instances though.
19			*
20			* @author Zaahid Bateson
21			*/
22			class GenericConsumer extends AbstractConsumer
23			{
24			/**
25			* Returns \ZBateson\MailMimeParser\Header\Consumer\CommentConsumer and
26			* \ZBateson\MailMimeParser\Header\Consumer\QuotedStringConsumer as
27			* sub-consumers.
28			*
29			* @return AbstractConsumer[] the sub-consumers
30			*/
31			protected function getSubConsumers()
32			{
33			return [
34			$this->consumerService->getCommentConsumer(),
35			$this->consumerService->getQuotedStringConsumer(),
36			];
37			}
38
39			/**
40			* Returns the regex '\s+' (whitespace) pattern matcher as a token marker so
41			* the header value is split along whitespace characters. GenericConsumer
42			* filters out whitespace-only tokens from getPartForToken.
43			*
44			* The whitespace character delimits mime-encoded parts for decoding.
45			*
46			* @return string[] an array of regex pattern matchers
47			*/
48			protected function getTokenSeparators()
49			{
50			return ['\s+'];
51			}
52
53			/**
54			* GenericConsumer doesn't have start/end tokens, and so always returns
55			* false.
56			*
57			* @param string $token
58			* @return boolean false
59			*/
60			protected function isEndToken($token)
61			{
62			return false;
63			}
64
65			/**
66			* GenericConsumer doesn't have start/end tokens, and so always returns
67			* false.
68			*
69			* @param string $token
70			* @return boolean false
71			*/
72			protected function isStartToken($token)
73			{
74			return false;
75			}
76
77			/**
78			* Returns true if a space should be added based on the passed last and next
79			* parts.
80			*
81			* @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $lastPart
82			* @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $nextPart
83			* @return bool
84			*/
85			private function shouldAddSpace(HeaderPart $lastPart, HeaderPart $nextPart)
86			{
87			return ($lastPart !== null && (!$lastPart->ignoreSpacesAfter() \|\| !$nextPart->ignoreSpacesBefore()));
88			}
89
90			/**
91			* Checks if the passed space part should be added to the returned parts and
92			* adds it.
93			*
94			* Never adds a space if it's the first part, otherwise only add it if
95			* either part isn't set to ignore the space
96			*
97			* @param array $parts
98			* @param array $retParts
99			* @param \ZBateson\MailMimeParser\Header\Part\HeaderPart $spacePart
100			* @param int $curIndex
101			*/
102			private function addSpaces(array $parts, array &$retParts, &$spacePart, $curIndex)
103			{
104			if ($spacePart === null \|\| $parts[$curIndex]->getValue() === '') {
105			return;
106			}
107			$lastPart = end($retParts);
108			$count = count($parts);
109			for ($j = $curIndex; $j < $count; ++$j) {
110			$nextPart = $parts[$j];
111			if ($this->shouldAddSpace($lastPart, $nextPart)) {
112			$retParts[] = $spacePart;
113			$spacePart = null;
114			break;
115			}
116			}
117			}
118
119			/**
120			*
121			* @param HeaderPart $part
122			* @return type
123			*/
124			private function isSpaceToken(HeaderPart $part)
125			{
126			return ($part instanceof Token && $part->isSpace());
127			}
128
129			/**
130			* Filters out ignorable spaces between parts in the passed array.
131			*
132			* Spaces with parts on either side of it that specify they can be ignored
133			* are filtered out. filterIgnoredSpaces is called from within
134			* processParts, and if needed by an implementing class that overrides
135			* processParts, must be specifically called.
136			*
137			* @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
138			* @return \ZBateson\MailMimeParser\Header\Part\HeaderPart[]
139			*/
140			protected function filterIgnoredSpaces(array $parts)
141			{
142			$retParts = [];
143			$spacePart = null;
144			$count = count($parts);
145			for ($i = 0; $i < $count; ++$i) {
146			$part = $parts[$i];
147			if ($this->isSpaceToken($part)) {
148			$spacePart = $part;
149			continue;
150			}
151			$this->addSpaces($parts, $retParts, $spacePart, $i);
			0 ignored issues – show Bug introduced 2016-02-29 04:18 UTC by Report Bug Copy Issue Report It seems like `$spacePart` defined by `null` on line `143` can be `null`; however, `ZBateson\MailMimeParser\...icConsumer::addSpaces()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
152			$retParts[] = $part;
153			}
154			// ignore trailing spaces
155			return $retParts;
156			}
157
158			/**
159			* Overridden to combine all part values into a single string and return it
160			* as an array with a single element.
161			*
162			* @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
163			* @return \ZBateson\MailMimeParser\Header\Part\LiteralPart[]\|array
164			*/
165			protected function processParts(array $parts)
166			{
167			$strValue = '';
168			$filtered = $this->filterIgnoredSpaces($parts);
169			foreach ($filtered as $part) {
170			$strValue .= $part->getValue();
171			}
172			return [$this->partFactory->newLiteralPart($strValue)];
173			}
174			}
175

zbateson / mail-mime-parser

Push — master ( c7cf7f...702f4a )

GenericConsumer::shouldAddSpace() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like