Egulias\EmailValidator\Parser\LocalPart

Complexity

Total Complexity

27

Size/Duplication

Total Lines	123
Duplicated Lines	28.46 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	parse()	11	63	17
A	parseLocalFWS()	0	11	3
A	hasDotAtStart()	0	4	2
A	parseDoubleQuote()	11	11	2
A	parseComments()	13	13	3

<?php

namespace Egulias\EmailValidator\Parser;

use Egulias\EmailValidator\EmailLexer;
use Egulias\EmailValidator\Result\Result;
use Egulias\EmailValidator\Result\ValidEmail;
use Egulias\EmailValidator\Result\InvalidEmail;
use Egulias\EmailValidator\Warning\LocalTooLong;
use Egulias\EmailValidator\Result\Reason\ConsecutiveDot;
use Egulias\EmailValidator\Result\Reason\DotAtEnd;
use Egulias\EmailValidator\Result\Reason\DotAtStart;
use Egulias\EmailValidator\Result\Reason\ExpectingATEXT as ReasonExpectingATEXT;

class LocalPart extends Parser
{

    private $invalidTokens = array(
            EmailLexer::S_COMMA => EmailLexer::S_COMMA,
            EmailLexer::S_CLOSEBRACKET => EmailLexer::S_CLOSEBRACKET,
            EmailLexer::S_OPENBRACKET => EmailLexer::S_OPENBRACKET,
            EmailLexer::S_GREATERTHAN => EmailLexer::S_GREATERTHAN,
            EmailLexer::S_LOWERTHAN => EmailLexer::S_LOWERTHAN,
            EmailLexer::S_COLON => EmailLexer::S_COLON,
            EmailLexer::S_SEMICOLON => EmailLexer::S_SEMICOLON,
            EmailLexer::INVALID => EmailLexer::INVALID
        );

    private $foldingWS;

    public function parse($localPart) : Result
    {
        $totalLength = 0;
        $this->foldingWS = new FoldingWhiteSpace($this->lexer);

        while ($this->lexer->token['type'] !== EmailLexer::S_AT && null !== $this->lexer->token['type']) {
            if ($this->hasDotAtStart()) {
                return new InvalidEmail(new DotAtStart(), $this->lexer->token['value']);
            }

            if ($this->lexer->token['type'] === EmailLexer::S_DQUOTE) {
                $dquoteParsingResult = $this->parseDoubleQuote();

                //Invalid double quote parsing
                if($dquoteParsingResult->isInvalid()) {
                    return $dquoteParsingResult;
                }
            }

            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS || 
                $this->lexer->token['type'] === EmailLexer::S_CLOSEPARENTHESIS ) {
                $commentsResult = $this->parseComments();

                //Invalid comment parsing
                if($commentsResult->isInvalid()) {
                    return $commentsResult;
                }
            }

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

This code seems to be duplicated across your project.

                return new InvalidEmail(new ConsecutiveDot(), $this->lexer->token['value']);
            }

            if ($this->lexer->token['type'] === EmailLexer::S_DOT &&

This code seems to be duplicated across your project.

                $this->lexer->isNextToken(EmailLexer::S_AT)
            ) {
                return new InvalidEmail(new DotAtEnd(), $this->lexer->token['value']);
            }

            $resultEscaping = $this->validateEscaping();
            if ($resultEscaping->isInvalid()) {
                return $resultEscaping;
            }

            if (isset($this->invalidTokens[$this->lexer->token['type']])) {

This code seems to be duplicated across your project.

                return new InvalidEmail(new ReasonExpectingATEXT('Invalid token found'), $this->lexer->token['value']);
            }

            $resultFWS = $this->parseLocalFWS();
            if($resultFWS->isInvalid()) {
                return $resultFWS;
            }

            $totalLength += strlen($this->lexer->token['value']);
            $this->lexer->moveNext();
        }

        if ($totalLength > LocalTooLong::LOCAL_PART_LENGTH) {
            $this->warnings[LocalTooLong::CODE] = new LocalTooLong();
        }

        return new ValidEmail();
    }

    protected function parseLocalFWS() : Result 
    {
        $resultFWS = $this->foldingWS->parse('remove');
        if ($resultFWS->isValid()) {
            $warns = $this->foldingWS->getWarnings();
            foreach ($warns as $code => $dWarning) {
                $this->warnings[$code] = $dWarning;
            }
        }
        return $resultFWS;
    }

    protected function hasDotAtStart() : bool
    {
            return $this->lexer->token['type'] === EmailLexer::S_DOT && null === $this->lexer->getPrevious()['type'];
    }

    protected function parseDoubleQuote() : Result

This method seems to be duplicated in your project.

    {
        $dquoteParser = new DoubleQuote($this->lexer);
        $parseAgain = $dquoteParser->parse("remove useless arg");
        $warns = $dquoteParser->getWarnings();
        foreach ($warns as $code => $dWarning) {
            $this->warnings[$code] = $dWarning;
        }

        return $parseAgain;
    }

    protected function parseComments()

This method seems to be duplicated in your project.

    {
        $commentParser = new Comment($this->lexer);
        $result = $commentParser->parse('remove');
        if($result->isInvalid()) {
            return $result;
        }
        $warns = $commentParser->getWarnings();
        foreach ($warns as $code => $dWarning) {
            $this->warnings[$code] = $dWarning;
        }
        return $result;
    }
}