Parser - Code Metrics - Inspection of "fixed valid email with space" - egulias/EmailValidator - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#267)

unknown

created 2020-09-28 16:45 UTC

Parser B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	228
Duplicated Lines	7.02 %

Coupling/Cohesion

Components	1
Dependencies	16

Test Coverage

Coverage

83.02%

Importance

Changes

Metric	Value
wmc	49
lcom	1
cbo	16
dl	16
loc	228
ccs	88
cts	106
cp	0.8302
rs	8.48
c	0
b	0
f	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getWarnings()	0	4	1
	parse()	0	1	?
A	getOpenedParenthesis()	0	4	1
A	validateQuotedPair()	4	10	3
A	parseComments()	0	22	5
A	isUnclosedComment()	0	9	2
A	checkConsecutiveDots()	3	6	3
A	escaped()	0	13	4
A	warnEscaping()	0	19	4
B	checkDQUOTE()	3	23	6
A	checkCRLFInFWS()	0	14	4
B	parseFWS()	6	24	8
B	isFWS()	0	17	7

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

<?php

namespace Egulias\EmailValidator\Parser;

use Egulias\EmailValidator\EmailLexer;
use Egulias\EmailValidator\Exception\AtextAfterCFWS;
use Egulias\EmailValidator\Exception\ConsecutiveDot;
use Egulias\EmailValidator\Exception\CRLFAtTheEnd;
use Egulias\EmailValidator\Exception\CRLFX2;
use Egulias\EmailValidator\Exception\CRNoLF;
use Egulias\EmailValidator\Exception\ExpectingQPair;
use Egulias\EmailValidator\Exception\ExpectingATEXT;
use Egulias\EmailValidator\Exception\ExpectingCTEXT;
use Egulias\EmailValidator\Exception\UnclosedComment;
use Egulias\EmailValidator\Exception\UnclosedQuotedString;
use Egulias\EmailValidator\Warning\CFWSNearAt;
use Egulias\EmailValidator\Warning\CFWSWithFWS;
use Egulias\EmailValidator\Warning\Comment;
use Egulias\EmailValidator\Warning\QuotedPart;
use Egulias\EmailValidator\Warning\QuotedString;

abstract class Parser
{
    /**
     * @var array
     */
    protected $warnings = [];

    /**
     * @var EmailLexer
     */
    protected $lexer;

    /**
     * @var int
     */
    protected $openedParenthesis = 0;

    public function __construct(EmailLexer $lexer)
    {
        $this->lexer = $lexer;
    }

    /**
     * @return \Egulias\EmailValidator\Warning\Warning[]
     */
    public function getWarnings()
    {
        return $this->warnings;
    }

    /**
     * @param string $str
     */
    abstract public function parse($str);

    /** @return int */
    public function getOpenedParenthesis()
    {
        return $this->openedParenthesis;
    }

    /**
     * validateQuotedPair
     */
    protected function validateQuotedPair()
    {
        if (!($this->lexer->token['type'] === EmailLexer::INVALID

            || $this->lexer->token['type'] === EmailLexer::C_DEL)) {
            throw new ExpectingQPair();
        }

        $this->warnings[QuotedPart::CODE] =
            new QuotedPart($this->lexer->getPrevious()['type'], $this->lexer->token['type']);
    }

    protected function parseComments()
    {
        $this->openedParenthesis = 1;
        $this->isUnclosedComment();
        $this->warnings[Comment::CODE] = new Comment();
        while (!$this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
            if ($this->lexer->isNextToken(EmailLexer::S_OPENPARENTHESIS)) {
                $this->openedParenthesis++;
            }
            $this->warnEscaping();
            $this->lexer->moveNext();
        }

        $this->lexer->moveNext();
        if ($this->lexer->isNextTokenAny(array(EmailLexer::GENERIC, EmailLexer::S_EMPTY))) {
            throw new ExpectingATEXT();
        }

        if ($this->lexer->isNextToken(EmailLexer::S_AT)) {
            $this->warnings[CFWSNearAt::CODE] = new CFWSNearAt();
        }
    }

    /**
     * @return bool
     */
    protected function isUnclosedComment()
    {
        try {
            $this->lexer->find(EmailLexer::S_CLOSEPARENTHESIS);
            return true;
        } catch (\RuntimeException $e) {
            throw new UnclosedComment();
        }
    }

    protected function parseFWS()
    {
        $previous = $this->lexer->getPrevious();

        $this->checkCRLFInFWS();

        if ($this->lexer->token['type'] === EmailLexer::S_CR) {
            throw new CRNoLF();
        }

        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type']  !== EmailLexer::S_AT) {

            throw new AtextAfterCFWS();
        }

        if ($this->lexer->token['type'] === EmailLexer::S_LF || $this->lexer->token['type'] === EmailLexer::C_NUL) {

            throw new ExpectingCTEXT();
        }

        if ($this->lexer->isNextToken(EmailLexer::S_AT) || $previous['type']  === EmailLexer::S_AT) {
            $this->warnings[CFWSNearAt::CODE] = new CFWSNearAt();
        } else {
            $this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
        }
    }

    protected function checkConsecutiveDots()
    {
        if ($this->lexer->token['type'] === EmailLexer::S_DOT && $this->lexer->isNextToken(EmailLexer::S_DOT)) {

            throw new ConsecutiveDot();
        }
    }

    /**
     * @return bool
     */
    protected function isFWS()
    {
        if ($this->escaped()) {
            return false;
        }

        if ($this->lexer->token['type'] === EmailLexer::S_SP ||
            $this->lexer->token['type'] === EmailLexer::S_HTAB ||
            $this->lexer->token['type'] === EmailLexer::S_CR ||
            $this->lexer->token['type'] === EmailLexer::S_LF ||
            $this->lexer->token['type'] === EmailLexer::CRLF
        ) {
            return true;
        }

        return false;
    }

    /**
     * @return bool
     */
    protected function escaped()
    {
        $previous = $this->lexer->getPrevious();

        if ($previous && $previous['type'] === EmailLexer::S_BACKSLASH

            &&
            $this->lexer->token['type'] !== EmailLexer::GENERIC
        ) {
            return true;
        }

        return false;
    }

    /**
     * @return bool
     */
    protected function warnEscaping()
    {
        if ($this->lexer->token['type'] !== EmailLexer::S_BACKSLASH) {
            return false;
        }

        if ($this->lexer->isNextToken(EmailLexer::GENERIC)) {
            throw new ExpectingATEXT();
        }

        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB, EmailLexer::C_DEL))) {
            return false;
        }

        $this->warnings[QuotedPart::CODE] =
            new QuotedPart($this->lexer->getPrevious()['type'], $this->lexer->token['type']);
        return true;

    }

    /**
     * @param bool $hasClosingQuote
     *
     * @return bool
     */
    protected function checkDQUOTE($hasClosingQuote)
    {
        if ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE) {
            return $hasClosingQuote;
        }
        if ($hasClosingQuote) {
            return $hasClosingQuote;
        }
        $previous = $this->lexer->getPrevious();
        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type'] === EmailLexer::GENERIC) {

            throw new ExpectingATEXT();
        }

        try {
            $this->lexer->find(EmailLexer::S_DQUOTE);
            $hasClosingQuote = true;
        } catch (\Exception $e) {
            throw new UnclosedQuotedString();
        }
        $this->warnings[QuotedString::CODE] = new QuotedString($previous['value'], $this->lexer->token['value']);

        return $hasClosingQuote;
    }

    protected function checkCRLFInFWS()
    {
        if ($this->lexer->token['type'] !== EmailLexer::CRLF) {
            return;
        }

        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
            throw new CRLFX2();
        }

        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
            throw new CRLFAtTheEnd();
        }
    }
}


1			<?php
2
3			namespace Egulias\EmailValidator\Parser;
4
5			use Egulias\EmailValidator\EmailLexer;
6			use Egulias\EmailValidator\Exception\AtextAfterCFWS;
7			use Egulias\EmailValidator\Exception\ConsecutiveDot;
8			use Egulias\EmailValidator\Exception\CRLFAtTheEnd;
9			use Egulias\EmailValidator\Exception\CRLFX2;
10			use Egulias\EmailValidator\Exception\CRNoLF;
11			use Egulias\EmailValidator\Exception\ExpectingQPair;
12			use Egulias\EmailValidator\Exception\ExpectingATEXT;
13			use Egulias\EmailValidator\Exception\ExpectingCTEXT;
14			use Egulias\EmailValidator\Exception\UnclosedComment;
15			use Egulias\EmailValidator\Exception\UnclosedQuotedString;
16			use Egulias\EmailValidator\Warning\CFWSNearAt;
17			use Egulias\EmailValidator\Warning\CFWSWithFWS;
18			use Egulias\EmailValidator\Warning\Comment;
19			use Egulias\EmailValidator\Warning\QuotedPart;
20			use Egulias\EmailValidator\Warning\QuotedString;
21
22			abstract class Parser
23			{
24			/**
25			* @var array
26			*/
27			protected $warnings = [];
28
29			/**
30			* @var EmailLexer
31			*/
32			protected $lexer;
33
34			/**
35			* @var int
36			*/
37			protected $openedParenthesis = 0;
38
39	132		public function __construct(EmailLexer $lexer)
40			{
41	132		$this->lexer = $lexer;
42	132		}
43
44			/**
45			* @return \Egulias\EmailValidator\Warning\Warning[]
46			*/
47	51		public function getWarnings()
48			{
49	51		return $this->warnings;
50			}
51
52			/**
53			* @param string $str
54			*/
55			abstract public function parse($str);
56
57			/** @return int */
58	6		public function getOpenedParenthesis()
59			{
60	6		return $this->openedParenthesis;
61			}
62
63			/**
64			* validateQuotedPair
65			*/
66			protected function validateQuotedPair()
67			{
68		View Code Duplication	if (!($this->lexer->token['type'] === EmailLexer::INVALID
			0 ignored issues – show Duplication introduced 2016-05-07 13:54 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...
69			\|\| $this->lexer->token['type'] === EmailLexer::C_DEL)) {
70			throw new ExpectingQPair();
71			}
72
73			$this->warnings[QuotedPart::CODE] =
74			new QuotedPart($this->lexer->getPrevious()['type'], $this->lexer->token['type']);
75			}
76
77	10		protected function parseComments()
78			{
79	10		$this->openedParenthesis = 1;
80	10		$this->isUnclosedComment();
81	6		$this->warnings[Comment::CODE] = new Comment();
82	6		while (!$this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
83	6		if ($this->lexer->isNextToken(EmailLexer::S_OPENPARENTHESIS)) {
84	1		$this->openedParenthesis++;
85	1		}
86	6		$this->warnEscaping();
87	6		$this->lexer->moveNext();
88	6		}
89
90	6		$this->lexer->moveNext();
91	6		if ($this->lexer->isNextTokenAny(array(EmailLexer::GENERIC, EmailLexer::S_EMPTY))) {
92			throw new ExpectingATEXT();
93			}
94
95	6		if ($this->lexer->isNextToken(EmailLexer::S_AT)) {
96	1		$this->warnings[CFWSNearAt::CODE] = new CFWSNearAt();
97	1		}
98	6		}
99
100			/**
101			* @return bool
102			*/
103	13		protected function isUnclosedComment()
104			{
105			try {
106	13		$this->lexer->find(EmailLexer::S_CLOSEPARENTHESIS);
107	7		return true;
108	6		} catch (\RuntimeException $e) {
109	6		throw new UnclosedComment();
110			}
111			}
112
113	6		protected function parseFWS()
114			{
115	6		$previous = $this->lexer->getPrevious();
116
117	6		$this->checkCRLFInFWS();
118
119	6		if ($this->lexer->token['type'] === EmailLexer::S_CR) {
120	2		throw new CRNoLF();
121			}
122
123	4	View Code Duplication	if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type'] !== EmailLexer::S_AT) {
			0 ignored issues – show Duplication introduced 2016-04-28 23:00 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...
124	2		throw new AtextAfterCFWS();
125			}
126
127	2	View Code Duplication	if ($this->lexer->token['type'] === EmailLexer::S_LF \|\| $this->lexer->token['type'] === EmailLexer::C_NUL) {
			0 ignored issues – show Duplication introduced 2016-04-28 23:00 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...
128			throw new ExpectingCTEXT();
129			}
130
131	2		if ($this->lexer->isNextToken(EmailLexer::S_AT) \|\| $previous['type'] === EmailLexer::S_AT) {
132	2		$this->warnings[CFWSNearAt::CODE] = new CFWSNearAt();
133	2		} else {
134			$this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
135			}
136	2		}
137
138	117		protected function checkConsecutiveDots()
139			{
140	117	View Code Duplication	if ($this->lexer->token['type'] === EmailLexer::S_DOT && $this->lexer->isNextToken(EmailLexer::S_DOT)) {
			0 ignored issues – show Duplication introduced 2016-05-07 13:54 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...
141	3		throw new ConsecutiveDot();
142			}
143	117		}
144
145			/**
146			* @return bool
147			*/
148	111		protected function isFWS()
149			{
150	111		if ($this->escaped()) {
151			return false;
152			}
153
154	111		if ($this->lexer->token['type'] === EmailLexer::S_SP \|\|
155	111		$this->lexer->token['type'] === EmailLexer::S_HTAB \|\|
156	111		$this->lexer->token['type'] === EmailLexer::S_CR \|\|
157	111		$this->lexer->token['type'] === EmailLexer::S_LF \|\|
158	111		$this->lexer->token['type'] === EmailLexer::CRLF
159	111		) {
160	6		return true;
161			}
162
163	111		return false;
164			}
165
166			/**
167			* @return bool
168			*/
169	118		protected function escaped()
170			{
171	118		$previous = $this->lexer->getPrevious();
172
173	118		if ($previous && $previous['type'] === EmailLexer::S_BACKSLASH
			0 ignored issues – show Bug Best Practice introduced 2020-02-12 22:30 UTC by Report Bug Copy Issue Report The expression `$previous` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
174	118		&&
175	2		$this->lexer->token['type'] !== EmailLexer::GENERIC
176	118		) {
177	1		return true;
178			}
179
180	118		return false;
181			}
182
183			/**
184			* @return bool
185			*/
186	117		protected function warnEscaping()
187			{
188	117		if ($this->lexer->token['type'] !== EmailLexer::S_BACKSLASH) {
189	112		return false;
190			}
191
192	7		if ($this->lexer->isNextToken(EmailLexer::GENERIC)) {
193	6		throw new ExpectingATEXT();
194			}
195
196	1		if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB, EmailLexer::C_DEL))) {
197			return false;
198			}
199
200	1		$this->warnings[QuotedPart::CODE] =
201	1		new QuotedPart($this->lexer->getPrevious()['type'], $this->lexer->token['type']);
202	1		return true;
203
204			}
205
206			/**
207			* @param bool $hasClosingQuote
208			*
209			* @return bool
210			*/
211	129		protected function checkDQUOTE($hasClosingQuote)
212			{
213	129		if ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE) {
214	108		return $hasClosingQuote;
215			}
216	22		if ($hasClosingQuote) {
217			return $hasClosingQuote;
218			}
219	22		$previous = $this->lexer->getPrevious();
220	22	View Code Duplication	if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type'] === EmailLexer::GENERIC) {
			0 ignored issues – show Duplication introduced 2016-04-28 23:00 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...
221	1		throw new ExpectingATEXT();
222			}
223
224			try {
225	21		$this->lexer->find(EmailLexer::S_DQUOTE);
226	20		$hasClosingQuote = true;
227	21		} catch (\Exception $e) {
228	1		throw new UnclosedQuotedString();
229			}
230	20		$this->warnings[QuotedString::CODE] = new QuotedString($previous['value'], $this->lexer->token['value']);
231
232	20		return $hasClosingQuote;
233			}
234
235	6		protected function checkCRLFInFWS()
236			{
237	6		if ($this->lexer->token['type'] !== EmailLexer::CRLF) {
238	6		return;
239			}
240
241			if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
242			throw new CRLFX2();
243			}
244
245			if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
246			throw new CRLFAtTheEnd();
247			}
248			}
249			}
250

egulias / EmailValidator