package and depencies

vendor/egulias/email-validator/src/Parser/Comment.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Warning\QuotedPart;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Parser\CommentStrategy\CommentStrategy;
+use Egulias\EmailValidator\Result\Reason\UnclosedComment;
+use Egulias\EmailValidator\Result\Reason\UnOpenedComment;
+use Egulias\EmailValidator\Warning\Comment as WarningComment;
+
+class Comment extends PartParser
+{
+    /**
+     * @var int
+     */
+    private $openedParenthesis = 0;
+
+    /**
+     * @var CommentStrategy
+     */
+    private $commentStrategy;
+
+    public function __construct(EmailLexer $lexer, CommentStrategy $commentStrategy)
+    {
+        $this->lexer = $lexer;
+        $this->commentStrategy = $commentStrategy;
+    }
+
+    public function parse() : Result
+    {
+        if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
+            $this->openedParenthesis++;
+            if($this->noClosingParenthesis()) {
+                return new InvalidEmail(new UnclosedComment(), $this->lexer->token['value']);
+            }
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_CLOSEPARENTHESIS) {
+            return new InvalidEmail(new UnOpenedComment(), $this->lexer->token['value']);
+        }
+
+        $this->warnings[WarningComment::CODE] = new WarningComment();
+
+        $moreTokens = true;
+        while ($this->commentStrategy->exitCondition($this->lexer, $this->openedParenthesis) && $moreTokens){
+
+            if ($this->lexer->isNextToken(EmailLexer::S_OPENPARENTHESIS)) {
+                $this->openedParenthesis++;
+            }
+            $this->warnEscaping();
+            if($this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
+                $this->openedParenthesis--;
+            }
+            $moreTokens = $this->lexer->moveNext();
+        }
+
+        if($this->openedParenthesis >= 1) {
+            return new InvalidEmail(new UnclosedComment(), $this->lexer->token['value']);
+        }
+        if ($this->openedParenthesis < 0) {
+            return new InvalidEmail(new UnOpenedComment(), $this->lexer->token['value']);
+        }
+
+        $finalValidations = $this->commentStrategy->endOfLoopValidations($this->lexer);
+
+        $this->warnings = array_merge($this->warnings, $this->commentStrategy->getWarnings());
+
+        return $finalValidations;
+    }
+
+
+    /**
+     * @return bool
+     */
+    private function warnEscaping() : bool
+    {
+        //Backslash found
+        if ($this->lexer->token['type'] !== EmailLexer::S_BACKSLASH) {
+            return false;
+        }
+
+        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;
+
+    }
+
+    private function noClosingParenthesis() : bool 
+    {
+        try {
+            $this->lexer->find(EmailLexer::S_CLOSEPARENTHESIS);
+            return false;
+        } catch (\RuntimeException $e) {
+            return true;
+        }
+    }
+}

vendor/egulias/email-validator/src/Parser/CommentStrategy/CommentStrategy.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser\CommentStrategy;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\Result;
+
+interface CommentStrategy
+{
+    /**
+     * Return "true" to continue, "false" to exit
+     */
+    public function exitCondition(EmailLexer $lexer, int $openedParenthesis) : bool;
+
+    public function endOfLoopValidations(EmailLexer $lexer) : Result;
+
+    public function getWarnings() : array;
+}

vendor/egulias/email-validator/src/Parser/CommentStrategy/DomainComment.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser\CommentStrategy;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\ValidEmail;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\ExpectingATEXT;
+
+class DomainComment implements CommentStrategy
+{
+    public function exitCondition(EmailLexer $lexer, int $openedParenthesis) : bool
+    {
+        if (($openedParenthesis === 0 && $lexer->isNextToken(EmailLexer::S_DOT))){ // || !$internalLexer->moveNext()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function endOfLoopValidations(EmailLexer $lexer) : Result
+    {
+        //test for end of string
+        if (!$lexer->isNextToken(EmailLexer::S_DOT)) {
+            return new InvalidEmail(new ExpectingATEXT('DOT not found near CLOSEPARENTHESIS'), $lexer->token['value']);
+        }
+        //add warning
+        //Address is valid within the message but cannot be used unmodified for the envelope
+        return new ValidEmail();
+    }
+
+    public function getWarnings(): array
+    {
+        return [];
+    }
+}

vendor/egulias/email-validator/src/Parser/CommentStrategy/LocalComment.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser\CommentStrategy;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\ValidEmail;
+use Egulias\EmailValidator\Warning\CFWSNearAt;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\ExpectingATEXT;
+
+class LocalComment implements CommentStrategy
+{
+    /**
+     * @var array
+     */
+    private $warnings = [];
+
+    public function exitCondition(EmailLexer $lexer, int $openedParenthesis) : bool
+    {
+        return !$lexer->isNextToken(EmailLexer::S_AT);
+    }
+
+    public function endOfLoopValidations(EmailLexer $lexer) : Result
+    {
+        if (!$lexer->isNextToken(EmailLexer::S_AT)) {
+            return new InvalidEmail(new ExpectingATEXT('ATEX is not expected after closing comments'), $lexer->token['value']);
+        }
+        $this->warnings[CFWSNearAt::CODE] = new CFWSNearAt();
+        return new ValidEmail();
+    }
+
+    public function getWarnings(): array
+    {
+        return $this->warnings;
+    }
+}

vendor/egulias/email-validator/src/Parser/DomainLiteral.php

@@ -0,0 +1,211 @@
+<?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\CFWSWithFWS;
+use Egulias\EmailValidator\Warning\IPV6BadChar;
+use Egulias\EmailValidator\Result\Reason\CRNoLF;
+use Egulias\EmailValidator\Warning\IPV6ColonEnd;
+use Egulias\EmailValidator\Warning\IPV6MaxGroups;
+use Egulias\EmailValidator\Warning\ObsoleteDTEXT;
+use Egulias\EmailValidator\Warning\AddressLiteral;
+use Egulias\EmailValidator\Warning\IPV6ColonStart;
+use Egulias\EmailValidator\Warning\IPV6Deprecated;
+use Egulias\EmailValidator\Warning\IPV6GroupCount;
+use Egulias\EmailValidator\Warning\IPV6DoubleColon;
+use Egulias\EmailValidator\Result\Reason\ExpectingDTEXT;
+use Egulias\EmailValidator\Result\Reason\UnusualElements;
+use Egulias\EmailValidator\Warning\DomainLiteral as WarningDomainLiteral;
+
+class DomainLiteral extends PartParser
+{
+    public const IPV4_REGEX = '/\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/';
+
+    public const OBSOLETE_WARNINGS = [
+        EmailLexer::INVALID,
+        EmailLexer::C_DEL,
+        EmailLexer::S_LF,
+        EmailLexer::S_BACKSLASH
+    ];
+
+    public function parse() : Result
+    {
+        $this->addTagWarnings();
+
+        $IPv6TAG = false;
+        $addressLiteral = '';
+
+        do {
+            if ($this->lexer->token['type'] === EmailLexer::C_NUL) {
+                return new InvalidEmail(new ExpectingDTEXT(), $this->lexer->token['value']);
+            }
+
+            $this->addObsoleteWarnings();
+
+            if ($this->lexer->isNextTokenAny(array(EmailLexer::S_OPENBRACKET, EmailLexer::S_OPENBRACKET))) {
+                return new InvalidEmail(new ExpectingDTEXT(), $this->lexer->token['value']);
+            }
+
+            if ($this->lexer->isNextTokenAny(
+                array(EmailLexer::S_HTAB, EmailLexer::S_SP, EmailLexer::CRLF)
+            )) {
+                $this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
+                $this->parseFWS();
+            }
+
+            if ($this->lexer->isNextToken(EmailLexer::S_CR)) {
+                return new InvalidEmail(new CRNoLF(), $this->lexer->token['value']);
+            }
+
+            if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH) {
+                return new InvalidEmail(new UnusualElements($this->lexer->token['value']), $this->lexer->token['value']);
+            }
+            if ($this->lexer->token['type'] === EmailLexer::S_IPV6TAG) {
+                $IPv6TAG = true;
+            }
+
+            if ($this->lexer->token['type'] === EmailLexer::S_CLOSEBRACKET) {
+                break;
+            }
+
+            $addressLiteral .= $this->lexer->token['value'];
+
+        } while ($this->lexer->moveNext());
+
+
+        //Encapsulate
+        $addressLiteral = str_replace('[', '', $addressLiteral);
+        $isAddressLiteralIPv4 = $this->checkIPV4Tag($addressLiteral);
+
+        if (!$isAddressLiteralIPv4) {
+            return new ValidEmail();
+        } else {
+            $addressLiteral = $this->convertIPv4ToIPv6($addressLiteral);
+        }
+
+        if (!$IPv6TAG) {
+            $this->warnings[WarningDomainLiteral::CODE] = new WarningDomainLiteral();
+            return new ValidEmail();
+        }
+
+        $this->warnings[AddressLiteral::CODE] = new AddressLiteral();
+
+        $this->checkIPV6Tag($addressLiteral);
+
+        return new ValidEmail();
+    }
+
+    /**
+     * @param string $addressLiteral
+     * @param int $maxGroups
+     */
+    public function checkIPV6Tag($addressLiteral, $maxGroups = 8) : void
+    {
+        $prev = $this->lexer->getPrevious();
+        if ($prev['type'] === EmailLexer::S_COLON) {
+            $this->warnings[IPV6ColonEnd::CODE] = new IPV6ColonEnd();
+        }
+
+        $IPv6       = substr($addressLiteral, 5);
+        //Daniel Marschall's new IPv6 testing strategy
+        $matchesIP  = explode(':', $IPv6);
+        $groupCount = count($matchesIP);
+        $colons     = strpos($IPv6, '::');
+
+        if (count(preg_grep('/^[0-9A-Fa-f]{0,4}$/', $matchesIP, PREG_GREP_INVERT)) !== 0) {
+            $this->warnings[IPV6BadChar::CODE] = new IPV6BadChar();
+        }
+
+        if ($colons === false) {
+            // We need exactly the right number of groups
+            if ($groupCount !== $maxGroups) {
+                $this->warnings[IPV6GroupCount::CODE] = new IPV6GroupCount();
+            }
+            return;
+        }
+
+        if ($colons !== strrpos($IPv6, '::')) {
+            $this->warnings[IPV6DoubleColon::CODE] = new IPV6DoubleColon();
+            return;
+        }
+
+        if ($colons === 0 || $colons === (strlen($IPv6) - 2)) {
+            // RFC 4291 allows :: at the start or end of an address
+            //with 7 other groups in addition
+            ++$maxGroups;
+        }
+
+        if ($groupCount > $maxGroups) {
+            $this->warnings[IPV6MaxGroups::CODE] = new IPV6MaxGroups();
+        } elseif ($groupCount === $maxGroups) {
+            $this->warnings[IPV6Deprecated::CODE] = new IPV6Deprecated();
+        }
+    }
+    
+    public function convertIPv4ToIPv6(string $addressLiteralIPv4) : string
+    {
+        $matchesIP  = [];
+        $IPv4Match = preg_match(self::IPV4_REGEX, $addressLiteralIPv4, $matchesIP);
+
+        // Extract IPv4 part from the end of the address-literal (if there is one)
+        if ($IPv4Match > 0) {
+            $index = (int) strrpos($addressLiteralIPv4, $matchesIP[0]);
+            //There's a match but it is at the start
+            if ($index > 0) {
+                // Convert IPv4 part to IPv6 format for further testing
+                return substr($addressLiteralIPv4, 0, $index) . '0:0';
+            }
+        }
+
+        return $addressLiteralIPv4;
+    }
+
+    /**
+     * @param string $addressLiteral
+     *
+     * @return bool
+     */
+    protected function checkIPV4Tag($addressLiteral) : bool
+    {
+        $matchesIP  = [];
+        $IPv4Match = preg_match(self::IPV4_REGEX, $addressLiteral, $matchesIP);
+
+        // Extract IPv4 part from the end of the address-literal (if there is one)
+
+        if ($IPv4Match > 0) {
+            $index = strrpos($addressLiteral, $matchesIP[0]);
+            //There's a match but it is at the start
+            if ($index === 0) {
+                $this->warnings[AddressLiteral::CODE] = new AddressLiteral();
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private function addObsoleteWarnings() : void
+    {
+        if(in_array($this->lexer->token['type'], self::OBSOLETE_WARNINGS)) {
+            $this->warnings[ObsoleteDTEXT::CODE] = new ObsoleteDTEXT();
+        }
+    }
+
+    private function addTagWarnings() : void
+    {
+        if ($this->lexer->isNextToken(EmailLexer::S_COLON)) {
+            $this->warnings[IPV6ColonStart::CODE] = new IPV6ColonStart();
+        }
+        if ($this->lexer->isNextToken(EmailLexer::S_IPV6TAG)) {
+            $lexer = clone $this->lexer;
+            $lexer->moveNext();
+            if ($lexer->isNextToken(EmailLexer::S_DOUBLECOLON)) {
+                $this->warnings[IPV6ColonStart::CODE] = new IPV6ColonStart();
+            }
+        }
+    }
+
+}

vendor/egulias/email-validator/src/Parser/DomainPart.php

@@ -2,442 +2,315 @@
 
 namespace Egulias\EmailValidator\Parser;
 
+use Doctrine\Common\Lexer\Token;
 use Egulias\EmailValidator\EmailLexer;
-use Egulias\EmailValidator\Exception\CharNotAllowed;
-use Egulias\EmailValidator\Exception\CommaInDomain;
-use Egulias\EmailValidator\Exception\ConsecutiveAt;
-use Egulias\EmailValidator\Exception\CRLFAtTheEnd;
-use Egulias\EmailValidator\Exception\CRNoLF;
-use Egulias\EmailValidator\Exception\DomainHyphened;
-use Egulias\EmailValidator\Exception\DotAtEnd;
-use Egulias\EmailValidator\Exception\DotAtStart;
-use Egulias\EmailValidator\Exception\ExpectingATEXT;
-use Egulias\EmailValidator\Exception\ExpectingDomainLiteralClose;
-use Egulias\EmailValidator\Exception\ExpectingDTEXT;
-use Egulias\EmailValidator\Exception\NoDomainPart;
-use Egulias\EmailValidator\Exception\UnopenedComment;
-use Egulias\EmailValidator\Warning\AddressLiteral;
-use Egulias\EmailValidator\Warning\CFWSWithFWS;
-use Egulias\EmailValidator\Warning\DeprecatedComment;
-use Egulias\EmailValidator\Warning\DomainLiteral;
-use Egulias\EmailValidator\Warning\DomainTooLong;
-use Egulias\EmailValidator\Warning\IPV6BadChar;
-use Egulias\EmailValidator\Warning\IPV6ColonEnd;
-use Egulias\EmailValidator\Warning\IPV6ColonStart;
-use Egulias\EmailValidator\Warning\IPV6Deprecated;
-use Egulias\EmailValidator\Warning\IPV6DoubleColon;
-use Egulias\EmailValidator\Warning\IPV6GroupCount;
-use Egulias\EmailValidator\Warning\IPV6MaxGroups;
-use Egulias\EmailValidator\Warning\LabelTooLong;
-use Egulias\EmailValidator\Warning\ObsoleteDTEXT;
 use Egulias\EmailValidator\Warning\TLD;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\ValidEmail;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\DotAtEnd;
+use Egulias\EmailValidator\Result\Reason\DotAtStart;
+use Egulias\EmailValidator\Warning\DeprecatedComment;
+use Egulias\EmailValidator\Result\Reason\CRLFAtTheEnd;
+use Egulias\EmailValidator\Result\Reason\LabelTooLong;
+use Egulias\EmailValidator\Result\Reason\NoDomainPart;
+use Egulias\EmailValidator\Result\Reason\ConsecutiveAt;
+use Egulias\EmailValidator\Result\Reason\DomainTooLong;
+use Egulias\EmailValidator\Result\Reason\CharNotAllowed;
+use Egulias\EmailValidator\Result\Reason\DomainHyphened;
+use Egulias\EmailValidator\Result\Reason\ExpectingATEXT;
+use Egulias\EmailValidator\Parser\CommentStrategy\DomainComment;
+use Egulias\EmailValidator\Result\Reason\ExpectingDomainLiteralClose;
+use Egulias\EmailValidator\Parser\DomainLiteral as DomainLiteralParser;
 
-class DomainPart extends Parser
+class DomainPart extends PartParser
 {
-    const DOMAIN_MAX_LENGTH = 254;
-    const LABEL_MAX_LENGTH = 63;
+    public const DOMAIN_MAX_LENGTH = 253;
+    public const LABEL_MAX_LENGTH = 63;
 
     /**
      * @var string
      */
     protected $domainPart = '';
 
-    public function parse($domainPart)
+    /**
+     * @var string
+     */
+    protected $label = '';
+
+    public function parse() : Result
     {
+        $this->lexer->clearRecorded();
+        $this->lexer->startRecording();
+
         $this->lexer->moveNext();
 
-        $this->performDomainStartChecks();
-
-        $domain = $this->doParseDomainPart();
-
-        $prev = $this->lexer->getPrevious();
-        $length = strlen($domain);
-
-        if ($prev['type'] === EmailLexer::S_DOT) {
-            throw new DotAtEnd();
+        $domainChecks = $this->performDomainStartChecks();
+        if ($domainChecks->isInvalid()) {
+            return $domainChecks;
         }
-        if ($prev['type'] === EmailLexer::S_HYPHEN) {
-            throw new DomainHyphened();
+
+        if ($this->lexer->token['type'] === EmailLexer::S_AT) {
+            return new InvalidEmail(new ConsecutiveAt(), $this->lexer->token['value']);
         }
+
+        $result = $this->doParseDomainPart();
+        if ($result->isInvalid()) {
+            return $result;
+        }
+
+        $end = $this->checkEndOfDomain();
+        if ($end->isInvalid()) {
+            return $end;
+        }
+
+        $this->lexer->stopRecording();
+        $this->domainPart = $this->lexer->getAccumulatedValues();
+
+        $length = strlen($this->domainPart);
         if ($length > self::DOMAIN_MAX_LENGTH) {
-            $this->warnings[DomainTooLong::CODE] = new DomainTooLong();
+            return new InvalidEmail(new DomainTooLong(), $this->lexer->token['value']);
         }
-        if ($prev['type'] === EmailLexer::S_CR) {
-            throw new CRLFAtTheEnd();
-        }
-        $this->domainPart = $domain;
+
+        return new ValidEmail();
     }
 
-    private function performDomainStartChecks()
+    private function checkEndOfDomain() : Result
     {
-        $this->checkInvalidTokensAfterAT();
-        $this->checkEmptyDomain();
+        $prev = $this->lexer->getPrevious();
+        if ($prev['type'] === EmailLexer::S_DOT) {
+            return new InvalidEmail(new DotAtEnd(), $this->lexer->token['value']);
+        }
+        if ($prev['type'] === EmailLexer::S_HYPHEN) {
+            return new InvalidEmail(new DomainHyphened('Hypen found at the end of the domain'), $prev['value']);
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_SP) {
+            return new InvalidEmail(new CRLFAtTheEnd(), $prev['value']);
+        }
+        return new ValidEmail();
+
+    }
+
+    private function performDomainStartChecks() : Result
+    {
+        $invalidTokens = $this->checkInvalidTokensAfterAT();
+        if ($invalidTokens->isInvalid()) {
+            return $invalidTokens;
+        }
+        
+        $missingDomain = $this->checkEmptyDomain();
+        if ($missingDomain->isInvalid()) {
+            return $missingDomain;
+        }
 
         if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
             $this->warnings[DeprecatedComment::CODE] = new DeprecatedComment();
-            $this->parseDomainComments();
         }
+        return new ValidEmail();
     }
 
-    private function checkEmptyDomain()
+    private function checkEmptyDomain() : Result
     {
         $thereIsNoDomain = $this->lexer->token['type'] === EmailLexer::S_EMPTY ||
             ($this->lexer->token['type'] === EmailLexer::S_SP &&
             !$this->lexer->isNextToken(EmailLexer::GENERIC));
 
         if ($thereIsNoDomain) {
-            throw new NoDomainPart();
+            return new InvalidEmail(new NoDomainPart(), $this->lexer->token['value']);
         }
+
+        return new ValidEmail();
     }
 
-    private function checkInvalidTokensAfterAT()
+    private function checkInvalidTokensAfterAT() : Result
     {
         if ($this->lexer->token['type'] === EmailLexer::S_DOT) {
-            throw new DotAtStart();
+            return new InvalidEmail(new DotAtStart(), $this->lexer->token['value']);
         }
         if ($this->lexer->token['type'] === EmailLexer::S_HYPHEN) {
-            throw new DomainHyphened();
+            return new InvalidEmail(new DomainHyphened('After AT'), $this->lexer->token['value']);
         }
+        return new ValidEmail();
     }
 
-    /**
-     * @return string
-     */
-    public function getDomainPart()
+    protected function parseComments(): Result
     {
-        return $this->domainPart;
+        $commentParser = new Comment($this->lexer, new DomainComment());
+        $result = $commentParser->parse();
+        $this->warnings = array_merge($this->warnings, $commentParser->getWarnings());
+
+        return $result;
     }
 
-    /**
-     * @param string $addressLiteral
-     * @param int $maxGroups
-     */
-    public function checkIPV6Tag($addressLiteral, $maxGroups = 8)
-    {
-        $prev = $this->lexer->getPrevious();
-        if ($prev['type'] === EmailLexer::S_COLON) {
-            $this->warnings[IPV6ColonEnd::CODE] = new IPV6ColonEnd();
-        }
-
-        $IPv6       = substr($addressLiteral, 5);
-        //Daniel Marschall's new IPv6 testing strategy
-        $matchesIP  = explode(':', $IPv6);
-        $groupCount = count($matchesIP);
-        $colons     = strpos($IPv6, '::');
-
-        if (count(preg_grep('/^[0-9A-Fa-f]{0,4}$/', $matchesIP, PREG_GREP_INVERT)) !== 0) {
-            $this->warnings[IPV6BadChar::CODE] = new IPV6BadChar();
-        }
-
-        if ($colons === false) {
-            // We need exactly the right number of groups
-            if ($groupCount !== $maxGroups) {
-                $this->warnings[IPV6GroupCount::CODE] = new IPV6GroupCount();
-            }
-            return;
-        }
-
-        if ($colons !== strrpos($IPv6, '::')) {
-            $this->warnings[IPV6DoubleColon::CODE] = new IPV6DoubleColon();
-            return;
-        }
-
-        if ($colons === 0 || $colons === (strlen($IPv6) - 2)) {
-            // RFC 4291 allows :: at the start or end of an address
-            //with 7 other groups in addition
-            ++$maxGroups;
-        }
-
-        if ($groupCount > $maxGroups) {
-            $this->warnings[IPV6MaxGroups::CODE] = new IPV6MaxGroups();
-        } elseif ($groupCount === $maxGroups) {
-            $this->warnings[IPV6Deprecated::CODE] = new IPV6Deprecated();
-        }
-    }
-
-    /**
-     * @return string
-     */
-    protected function doParseDomainPart()
+    protected function doParseDomainPart() : Result
     {
+        $tldMissing = true;
+        $hasComments = false;
         $domain = '';
-        $label = '';
-        $openedParenthesis = 0;
         do {
             $prev = $this->lexer->getPrevious();
 
-            $this->checkNotAllowedChars($this->lexer->token);
-
-            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
-                $this->parseComments();
-                $openedParenthesis += $this->getOpenedParenthesis();
-                $this->lexer->moveNext();
-                $tmpPrev = $this->lexer->getPrevious();
-                if ($tmpPrev['type'] === EmailLexer::S_CLOSEPARENTHESIS) {
-                    $openedParenthesis--;
-                }
+            $notAllowedChars = $this->checkNotAllowedChars($this->lexer->token);
+            if ($notAllowedChars->isInvalid()) {
+                return $notAllowedChars;
             }
-            if ($this->lexer->token['type'] === EmailLexer::S_CLOSEPARENTHESIS) {
-                if ($openedParenthesis === 0) {
-                    throw new UnopenedComment();
-                } else {
-                    $openedParenthesis--;
+
+            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS || 
+                $this->lexer->token['type'] === EmailLexer::S_CLOSEPARENTHESIS ) {
+                $hasComments = true;
+                $commentsResult = $this->parseComments();
+
+                //Invalid comment parsing
+                if($commentsResult->isInvalid()) {
+                    return $commentsResult;
                 }
             }
 
-            $this->checkConsecutiveDots();
-            $this->checkDomainPartExceptions($prev);
-
-            if ($this->hasBrackets()) {
-                $this->parseDomainLiteral();
+            $dotsResult = $this->checkConsecutiveDots();
+            if ($dotsResult->isInvalid()) {
+                return $dotsResult;
             }
 
-            if ($this->lexer->token['type'] === EmailLexer::S_DOT) {
-                $this->checkLabelLength($label);
-                $label = '';
-            } else {
-                $label .= $this->lexer->token['value'];
+            if ($this->lexer->token['type'] === EmailLexer::S_OPENBRACKET) {
+                $literalResult = $this->parseDomainLiteral();
+
+                $this->addTLDWarnings($tldMissing);
+                return $literalResult;
             }
 
-            if ($this->isFWS()) {
-                $this->parseFWS();
+                $labelCheck = $this->checkLabelLength();
+                if ($labelCheck->isInvalid()) {
+                    return $labelCheck;
+                }
+
+            $FwsResult = $this->parseFWS();
+            if($FwsResult->isInvalid()) {
+                return $FwsResult;
             }
 
             $domain .= $this->lexer->token['value'];
-            $this->lexer->moveNext();
-            if ($this->lexer->token['type'] === EmailLexer::S_SP) {
-                throw new CharNotAllowed();
+
+            if ($this->lexer->token['type'] === EmailLexer::S_DOT && $this->lexer->isNextToken(EmailLexer::GENERIC)) {
+                $tldMissing = false;
             }
+
+            $exceptionsResult = $this->checkDomainPartExceptions($prev, $hasComments);
+            if ($exceptionsResult->isInvalid()) {
+                return $exceptionsResult;
+            }
+            $this->lexer->moveNext();
+
         } while (null !== $this->lexer->token['type']);
 
-        $this->checkLabelLength($label);
+        $labelCheck = $this->checkLabelLength(true);
+        if ($labelCheck->isInvalid()) {
+            return $labelCheck;
+        }
+        $this->addTLDWarnings($tldMissing);
 
-        return $domain;
+        $this->domainPart = $domain;
+        return new ValidEmail();
     }
 
-    private function checkNotAllowedChars(array $token)
+    /**
+     * @psalm-param array|Token<int, string> $token
+     */
+    private function checkNotAllowedChars($token) : Result
     {
         $notAllowed = [EmailLexer::S_BACKSLASH => true, EmailLexer::S_SLASH=> true];
         if (isset($notAllowed[$token['type']])) {
-            throw new CharNotAllowed();
+            return new InvalidEmail(new CharNotAllowed(), $token['value']);
         }
+        return new ValidEmail();
     }
 
     /**
-     * @return string|false
+     * @return Result
      */
-    protected function parseDomainLiteral()
+    protected function parseDomainLiteral() : Result
     {
-        if ($this->lexer->isNextToken(EmailLexer::S_COLON)) {
-            $this->warnings[IPV6ColonStart::CODE] = new IPV6ColonStart();
-        }
-        if ($this->lexer->isNextToken(EmailLexer::S_IPV6TAG)) {
-            $lexer = clone $this->lexer;
-            $lexer->moveNext();
-            if ($lexer->isNextToken(EmailLexer::S_DOUBLECOLON)) {
-                $this->warnings[IPV6ColonStart::CODE] = new IPV6ColonStart();
-            }
+        try {
+            $this->lexer->find(EmailLexer::S_CLOSEBRACKET);
+        } catch (\RuntimeException $e) {
+            return new InvalidEmail(new ExpectingDomainLiteralClose(), $this->lexer->token['value']);
         }
 
-        return $this->doParseDomainLiteral();
+        $domainLiteralParser = new DomainLiteralParser($this->lexer);
+        $result = $domainLiteralParser->parse();
+        $this->warnings = array_merge($this->warnings, $domainLiteralParser->getWarnings());
+        return $result;
     }
 
-    /**
-     * @return string|false
-     */
-    protected function doParseDomainLiteral()
+    protected function checkDomainPartExceptions(array $prev, bool $hasComments) : Result
     {
-        $IPv6TAG = false;
-        $addressLiteral = '';
-        do {
-            if ($this->lexer->token['type'] === EmailLexer::C_NUL) {
-                throw new ExpectingDTEXT();
-            }
-
-            if ($this->lexer->token['type'] === EmailLexer::INVALID ||
-                $this->lexer->token['type'] === EmailLexer::C_DEL   ||
-                $this->lexer->token['type'] === EmailLexer::S_LF
-            ) {
-                $this->warnings[ObsoleteDTEXT::CODE] = new ObsoleteDTEXT();
-            }
-
-            if ($this->lexer->isNextTokenAny(array(EmailLexer::S_OPENQBRACKET, EmailLexer::S_OPENBRACKET))) {
-                throw new ExpectingDTEXT();
-            }
-
-            if ($this->lexer->isNextTokenAny(
-                array(EmailLexer::S_HTAB, EmailLexer::S_SP, $this->lexer->token['type'] === EmailLexer::CRLF)
-            )) {
-                $this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
-                $this->parseFWS();
-            }
-
-            if ($this->lexer->isNextToken(EmailLexer::S_CR)) {
-                throw new CRNoLF();
-            }
-
-            if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH) {
-                $this->warnings[ObsoleteDTEXT::CODE] = new ObsoleteDTEXT();
-                $addressLiteral .= $this->lexer->token['value'];
-                $this->lexer->moveNext();
-                $this->validateQuotedPair();
-            }
-            if ($this->lexer->token['type'] === EmailLexer::S_IPV6TAG) {
-                $IPv6TAG = true;
-            }
-            if ($this->lexer->token['type'] === EmailLexer::S_CLOSEQBRACKET) {
-                break;
-            }
-
-            $addressLiteral .= $this->lexer->token['value'];
-
-        } while ($this->lexer->moveNext());
-
-        $addressLiteral = str_replace('[', '', $addressLiteral);
-        $addressLiteral = $this->checkIPV4Tag($addressLiteral);
-
-        if (false === $addressLiteral) {
-            return $addressLiteral;
-        }
-
-        if (!$IPv6TAG) {
-            $this->warnings[DomainLiteral::CODE] = new DomainLiteral();
-            return $addressLiteral;
-        }
-
-        $this->warnings[AddressLiteral::CODE] = new AddressLiteral();
-
-        $this->checkIPV6Tag($addressLiteral);
-
-        return $addressLiteral;
-    }
-
-    /**
-     * @param string $addressLiteral
-     *
-     * @return string|false
-     */
-    protected function checkIPV4Tag($addressLiteral)
-    {
-        $matchesIP  = array();
-
-        // Extract IPv4 part from the end of the address-literal (if there is one)
-        if (preg_match(
-            '/\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/',
-            $addressLiteral,
-            $matchesIP
-        ) > 0
-        ) {
-            $index = strrpos($addressLiteral, $matchesIP[0]);
-            if ($index === 0) {
-                $this->warnings[AddressLiteral::CODE] = new AddressLiteral();
-                return false;
-            }
-            // Convert IPv4 part to IPv6 format for further testing
-            $addressLiteral = substr($addressLiteral, 0, (int) $index) . '0:0';
-        }
-
-        return $addressLiteral;
-    }
-
-    protected function checkDomainPartExceptions(array $prev)
-    {
-        $invalidDomainTokens = array(
-            EmailLexer::S_DQUOTE => true,
-            EmailLexer::S_SQUOTE => true,
-            EmailLexer::S_BACKTICK => true,
-            EmailLexer::S_SEMICOLON => true,
-            EmailLexer::S_GREATERTHAN => true,
-            EmailLexer::S_LOWERTHAN => true,
-        );
-
-        if (isset($invalidDomainTokens[$this->lexer->token['type']])) {
-            throw new ExpectingATEXT();
-        }
-
-        if ($this->lexer->token['type'] === EmailLexer::S_COMMA) {
-            throw new CommaInDomain();
-        }
-
-        if ($this->lexer->token['type'] === EmailLexer::S_AT) {
-            throw new ConsecutiveAt();
-        }
-
-        if ($this->lexer->token['type'] === EmailLexer::S_OPENQBRACKET && $prev['type'] !== EmailLexer::S_AT) {
-            throw new ExpectingATEXT();
+        if ($this->lexer->token['type'] === EmailLexer::S_OPENBRACKET && $prev['type'] !== EmailLexer::S_AT) {
+            return new InvalidEmail(new ExpectingATEXT('OPENBRACKET not after AT'), $this->lexer->token['value']);
         }
 
         if ($this->lexer->token['type'] === EmailLexer::S_HYPHEN && $this->lexer->isNextToken(EmailLexer::S_DOT)) {
-            throw new DomainHyphened();
+            return new InvalidEmail(new DomainHyphened('Hypen found near DOT'), $this->lexer->token['value']);
         }
 
         if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH
             && $this->lexer->isNextToken(EmailLexer::GENERIC)) {
-            throw new ExpectingATEXT();
+            return new InvalidEmail(new ExpectingATEXT('Escaping following "ATOM"'), $this->lexer->token['value']);
         }
+
+        return $this->validateTokens($hasComments);
     }
 
-    /**
-     * @return bool
-     */
-    protected function hasBrackets()
+    protected function validateTokens(bool $hasComments) : Result
     {
-        if ($this->lexer->token['type'] !== EmailLexer::S_OPENBRACKET) {
-            return false;
+        $validDomainTokens = array(
+            EmailLexer::GENERIC => true,
+            EmailLexer::S_HYPHEN => true,
+            EmailLexer::S_DOT => true,
+        );
+
+        if ($hasComments) {
+            $validDomainTokens[EmailLexer::S_OPENPARENTHESIS] = true;
+            $validDomainTokens[EmailLexer::S_CLOSEPARENTHESIS] = true;
         }
 
-        try {
-            $this->lexer->find(EmailLexer::S_CLOSEBRACKET);
-        } catch (\RuntimeException $e) {
-            throw new ExpectingDomainLiteralClose();
+        if (!isset($validDomainTokens[$this->lexer->token['type']])) {
+            return new InvalidEmail(new ExpectingATEXT('Invalid token in domain: ' . $this->lexer->token['value']), $this->lexer->token['value']);
         }
 
-        return true;
+        return new ValidEmail();
     }
 
-    /**
-     * @param string $label
-     */
-    protected function checkLabelLength($label)
+    private function checkLabelLength(bool $isEndOfDomain = false) : Result
     {
-        if ($this->isLabelTooLong($label)) {
-            $this->warnings[LabelTooLong::CODE] = new LabelTooLong();
+        if ($this->lexer->token['type'] === EmailLexer::S_DOT || $isEndOfDomain) {
+            if ($this->isLabelTooLong($this->label)) {
+                return new InvalidEmail(new LabelTooLong(), $this->lexer->token['value']);
+            }
+            $this->label = '';
         }
+        $this->label .= $this->lexer->token['value'];
+        return new ValidEmail();
     }
 
-    /**
-     * @param string $label
-     * @return bool
-     */
-    private function isLabelTooLong($label)
+
+    private function isLabelTooLong(string $label) : bool
     {
         if (preg_match('/[^\x00-\x7F]/', $label)) {
             idn_to_ascii($label, IDNA_DEFAULT, INTL_IDNA_VARIANT_UTS46, $idnaInfo);
-
             return (bool) ($idnaInfo['errors'] & IDNA_ERROR_LABEL_TOO_LONG);
         }
-
         return strlen($label) > self::LABEL_MAX_LENGTH;
     }
 
-    protected function parseDomainComments()
+    private function addTLDWarnings(bool $isTLDMissing) : void
     {
-        $this->isUnclosedComment();
-        while (!$this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
-            $this->warnEscaping();
-            $this->lexer->moveNext();
-        }
-
-        $this->lexer->moveNext();
-        if ($this->lexer->isNextToken(EmailLexer::S_DOT)) {
-            throw new ExpectingATEXT();
-        }
-    }
-
-    protected function addTLDWarnings()
-    {
-        if ($this->warnings[DomainLiteral::CODE]) {
+        if ($isTLDMissing) {
             $this->warnings[TLD::CODE] = new TLD();
         }
     }
+
+    public function domainPart() : string
+    {
+        return $this->domainPart;
+    }
 }

vendor/egulias/email-validator/src/Parser/DoubleQuote.php

@@ -0,0 +1,87 @@
+<?php
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\ValidEmail;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Warning\CFWSWithFWS;
+use Egulias\EmailValidator\Warning\QuotedString;
+use Egulias\EmailValidator\Result\Reason\ExpectingATEXT;
+use Egulias\EmailValidator\Result\Reason\UnclosedQuotedString;
+use Egulias\EmailValidator\Result\Result;
+
+class DoubleQuote extends PartParser
+{
+    public function parse() : Result
+    {
+
+        $validQuotedString = $this->checkDQUOTE();
+        if($validQuotedString->isInvalid()) return $validQuotedString;
+
+        $special = [
+            EmailLexer::S_CR => true,
+            EmailLexer::S_HTAB => true,
+            EmailLexer::S_LF => true
+        ];
+
+        $invalid = [
+            EmailLexer::C_NUL => true,
+            EmailLexer::S_HTAB => true,
+            EmailLexer::S_CR => true,
+            EmailLexer::S_LF => true
+        ];
+        
+        $setSpecialsWarning = true;
+
+        $this->lexer->moveNext();
+
+        while ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE && null !== $this->lexer->token['type']) {
+            if (isset($special[$this->lexer->token['type']]) && $setSpecialsWarning) {
+                $this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
+                $setSpecialsWarning = false;
+            }
+            if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH && $this->lexer->isNextToken(EmailLexer::S_DQUOTE)) {
+                $this->lexer->moveNext();
+            }
+
+            $this->lexer->moveNext();
+
+            if (!$this->escaped() && isset($invalid[$this->lexer->token['type']])) {
+                return new InvalidEmail(new ExpectingATEXT("Expecting ATEXT between DQUOTE"), $this->lexer->token['value']);
+            }
+        }
+
+        $prev = $this->lexer->getPrevious();
+
+        if ($prev['type'] === EmailLexer::S_BACKSLASH) {
+            $validQuotedString = $this->checkDQUOTE();
+            if($validQuotedString->isInvalid()) return $validQuotedString;
+        }
+
+        if (!$this->lexer->isNextToken(EmailLexer::S_AT) && $prev['type'] !== EmailLexer::S_BACKSLASH) {
+            return new InvalidEmail(new ExpectingATEXT("Expecting ATEXT between DQUOTE"), $this->lexer->token['value']);
+        }
+
+        return new ValidEmail();
+    }
+
+    protected function checkDQUOTE() : Result
+    {
+        $previous = $this->lexer->getPrevious();
+
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type'] === EmailLexer::GENERIC) {
+            $description = 'https://tools.ietf.org/html/rfc5322#section-3.2.4 - quoted string should be a unit';
+            return new InvalidEmail(new ExpectingATEXT($description), $this->lexer->token['value']);
+        }
+
+        try {
+            $this->lexer->find(EmailLexer::S_DQUOTE);
+        } catch (\Exception $e) {
+            return new InvalidEmail(new UnclosedQuotedString(), $this->lexer->token['value']);
+        }
+        $this->warnings[QuotedString::CODE] = new QuotedString($previous['value'], $this->lexer->token['value']);
+
+        return new ValidEmail();
+    }
+
+}

vendor/egulias/email-validator/src/Parser/FoldingWhiteSpace.php

@@ -0,0 +1,86 @@
+<?php
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Warning\CFWSNearAt;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Warning\CFWSWithFWS;
+use Egulias\EmailValidator\Result\Reason\CRNoLF;
+use Egulias\EmailValidator\Result\Reason\AtextAfterCFWS;
+use Egulias\EmailValidator\Result\Reason\CRLFAtTheEnd;
+use Egulias\EmailValidator\Result\Reason\CRLFX2;
+use Egulias\EmailValidator\Result\Reason\ExpectingCTEXT;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\ValidEmail;
+
+class  FoldingWhiteSpace extends PartParser
+{
+    public const FWS_TYPES = [
+        EmailLexer::S_SP,
+        EmailLexer::S_HTAB,
+        EmailLexer::S_CR,
+        EmailLexer::S_LF,
+        EmailLexer::CRLF
+    ];
+
+    public function parse() : Result
+    {
+        if (!$this->isFWS()) {
+            return new ValidEmail();
+        }
+
+        $previous = $this->lexer->getPrevious();
+
+        $resultCRLF = $this->checkCRLFInFWS();
+        if ($resultCRLF->isInvalid()) {
+            return $resultCRLF;
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_CR) {
+            return new InvalidEmail(new CRNoLF(), $this->lexer->token['value']);
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type']  !== EmailLexer::S_AT) {
+            return new InvalidEmail(new AtextAfterCFWS(), $this->lexer->token['value']);
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_LF || $this->lexer->token['type'] === EmailLexer::C_NUL) {
+            return new InvalidEmail(new ExpectingCTEXT(), $this->lexer->token['value']);
+        }
+
+        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();
+        }
+
+        return new ValidEmail();
+    }
+
+    protected function checkCRLFInFWS() : Result
+    {
+        if ($this->lexer->token['type'] !== EmailLexer::CRLF) {
+            return new ValidEmail();
+        }
+
+        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
+            return new InvalidEmail(new CRLFX2(), $this->lexer->token['value']);
+        }
+
+        //this has no coverage. Condition is repeated from above one
+        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
+            return new InvalidEmail(new CRLFAtTheEnd(), $this->lexer->token['value']);
+        }
+
+        return new ValidEmail();
+    }
+     
+    protected function isFWS() : bool
+    {
+        if ($this->escaped()) {
+            return false;
+        }
+
+        return in_array($this->lexer->token['type'], self::FWS_TYPES);
+    }
+}

vendor/egulias/email-validator/src/Parser/IDLeftPart.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\CommentsInIDRight;
+
+class IDLeftPart extends LocalPart
+{
+    protected function parseComments(): Result
+    {
+       return new InvalidEmail(new CommentsInIDRight(), $this->lexer->token['value']);
+    }
+}

vendor/egulias/email-validator/src/Parser/IDRightPart.php

@@ -0,0 +1,29 @@
+<?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\Result\Reason\ExpectingATEXT;
+
+class IDRightPart extends DomainPart
+{
+    protected function validateTokens(bool $hasComments) : Result
+    {
+        $invalidDomainTokens = [
+            EmailLexer::S_DQUOTE => true,
+            EmailLexer::S_SQUOTE => true,
+            EmailLexer::S_BACKTICK => true,
+            EmailLexer::S_SEMICOLON => true,
+            EmailLexer::S_GREATERTHAN => true,
+            EmailLexer::S_LOWERTHAN => true,
+        ];
+    
+        if (isset($invalidDomainTokens[$this->lexer->token['type']])) {
+            return new InvalidEmail(new ExpectingATEXT('Invalid token in domain: ' . $this->lexer->token['value']), $this->lexer->token['value']);
+        }
+        return new ValidEmail();
+    }
+}

vendor/egulias/email-validator/src/Parser/LocalPart.php

@@ -2,144 +2,164 @@
 
 namespace Egulias\EmailValidator\Parser;
 
-use Egulias\EmailValidator\Exception\DotAtEnd;
-use Egulias\EmailValidator\Exception\DotAtStart;
 use Egulias\EmailValidator\EmailLexer;
-use Egulias\EmailValidator\Exception\ExpectingAT;
-use Egulias\EmailValidator\Exception\ExpectingATEXT;
-use Egulias\EmailValidator\Exception\UnclosedQuotedString;
-use Egulias\EmailValidator\Exception\UnopenedComment;
-use Egulias\EmailValidator\Warning\CFWSWithFWS;
+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\DotAtEnd;
+use Egulias\EmailValidator\Result\Reason\DotAtStart;
+use Egulias\EmailValidator\Result\Reason\ConsecutiveDot;
+use Egulias\EmailValidator\Result\Reason\ExpectingATEXT;
+use Egulias\EmailValidator\Parser\CommentStrategy\LocalComment;
 
-class LocalPart extends Parser
+class LocalPart extends PartParser
 {
-    public function parse($localPart)
+    public const INVALID_TOKENS = [
+        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
+    ];
+
+    /**
+     * @var string
+     */
+    private $localPart = '';
+
+
+    public function parse() : Result
     {
-        $parseDQuote = true;
-        $closingQuote = false;
-        $openedParenthesis = 0;
-        $totalLength = 0;
+        $this->lexer->startRecording();
 
         while ($this->lexer->token['type'] !== EmailLexer::S_AT && null !== $this->lexer->token['type']) {
-            if ($this->lexer->token['type'] === EmailLexer::S_DOT && null === $this->lexer->getPrevious()['type']) {
-                throw new DotAtStart();
+            if ($this->hasDotAtStart()) {
+                return new InvalidEmail(new DotAtStart(), $this->lexer->token['value']);
             }
 
-            $closingQuote = $this->checkDQUOTE($closingQuote);
-            if ($closingQuote && $parseDQuote) {
-                $parseDQuote = $this->parseDoubleQuote();
-            }
+            if ($this->lexer->token['type'] === EmailLexer::S_DQUOTE) {
+                $dquoteParsingResult = $this->parseDoubleQuote();
 
-            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
-                $this->parseComments();
-                $openedParenthesis += $this->getOpenedParenthesis();
-            }
-
-            if ($this->lexer->token['type'] === EmailLexer::S_CLOSEPARENTHESIS) {
-                if ($openedParenthesis === 0) {
-                    throw new UnopenedComment();
+                //Invalid double quote parsing
+                if($dquoteParsingResult->isInvalid()) {
+                    return $dquoteParsingResult;
                 }
-
-                $openedParenthesis--;
             }
 
-            $this->checkConsecutiveDots();
+            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)) {
+                return new InvalidEmail(new ConsecutiveDot(), $this->lexer->token['value']);
+            }
 
             if ($this->lexer->token['type'] === EmailLexer::S_DOT &&
                 $this->lexer->isNextToken(EmailLexer::S_AT)
             ) {
-                throw new DotAtEnd();
+                return new InvalidEmail(new DotAtEnd(), $this->lexer->token['value']);
             }
 
-            $this->warnEscaping();
-            $this->isInvalidToken($this->lexer->token, $closingQuote);
-
-            if ($this->isFWS()) {
-                $this->parseFWS();
+            $resultEscaping = $this->validateEscaping();
+            if ($resultEscaping->isInvalid()) {
+                return $resultEscaping;
+            }
+
+            $resultToken = $this->validateTokens(false);
+            if ($resultToken->isInvalid()) {
+                return $resultToken;
+            }
+
+            $resultFWS = $this->parseLocalFWS();
+            if($resultFWS->isInvalid()) {
+                return $resultFWS;
             }
 
-            $totalLength += strlen($this->lexer->token['value']);
             $this->lexer->moveNext();
         }
 
-        if ($totalLength > LocalTooLong::LOCAL_PART_LENGTH) {
+        $this->lexer->stopRecording();
+        $this->localPart = rtrim($this->lexer->getAccumulatedValues(), '@');
+        if (strlen($this->localPart) > LocalTooLong::LOCAL_PART_LENGTH) {
             $this->warnings[LocalTooLong::CODE] = new LocalTooLong();
         }
+
+        return new ValidEmail();
     }
 
-    /**
-     * @return bool
-     */
-    protected function parseDoubleQuote()
+    protected function validateTokens(bool $hasComments) : Result
     {
-        $parseAgain = true;
-        $special = array(
-            EmailLexer::S_CR => true,
-            EmailLexer::S_HTAB => true,
-            EmailLexer::S_LF => true
-        );
-
-        $invalid = array(
-            EmailLexer::C_NUL => true,
-            EmailLexer::S_HTAB => true,
-            EmailLexer::S_CR => true,
-            EmailLexer::S_LF => true
-        );
-        $setSpecialsWarning = true;
-
-        $this->lexer->moveNext();
-
-        while ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE && null !== $this->lexer->token['type']) {
-            $parseAgain = false;
-            if (isset($special[$this->lexer->token['type']]) && $setSpecialsWarning) {
-                $this->warnings[CFWSWithFWS::CODE] = new CFWSWithFWS();
-                $setSpecialsWarning = false;
-            }
-            if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH && $this->lexer->isNextToken(EmailLexer::S_DQUOTE)) {
-                $this->lexer->moveNext();
-            }
-
-            $this->lexer->moveNext();
-
-            if (!$this->escaped() && isset($invalid[$this->lexer->token['type']])) {
-                throw new ExpectingATEXT();
-            }
+        if (isset(self::INVALID_TOKENS[$this->lexer->token['type']])) {
+            return new InvalidEmail(new ExpectingATEXT('Invalid token found'), $this->lexer->token['value']);
         }
+        return new ValidEmail();
+    }
 
-        $prev = $this->lexer->getPrevious();
+    public function localPart() : string
+    {
+        return $this->localPart;
+    }
 
-        if ($prev['type'] === EmailLexer::S_BACKSLASH) {
-            if (!$this->checkDQUOTE(false)) {
-                throw new UnclosedQuotedString();
-            }
+    private function parseLocalFWS() : Result 
+    {
+        $foldingWS = new FoldingWhiteSpace($this->lexer);
+        $resultFWS = $foldingWS->parse();
+        if ($resultFWS->isValid()) {
+            $this->warnings = array_merge($this->warnings, $foldingWS->getWarnings());
         }
+        return $resultFWS;
+    }
 
-        if (!$this->lexer->isNextToken(EmailLexer::S_AT) && $prev['type'] !== EmailLexer::S_BACKSLASH) {
-            throw new ExpectingAT();
-        }
+    private function hasDotAtStart() : bool
+    {
+            return $this->lexer->token['type'] === EmailLexer::S_DOT && null === $this->lexer->getPrevious()['type'];
+    }
+
+    private function parseDoubleQuote() : Result
+    {
+        $dquoteParser = new DoubleQuote($this->lexer);
+        $parseAgain = $dquoteParser->parse();
+        $this->warnings = array_merge($this->warnings, $dquoteParser->getWarnings());
 
         return $parseAgain;
     }
 
-    /**
-     * @param bool $closingQuote
-     */
-    protected function isInvalidToken(array $token, $closingQuote)
+    protected function parseComments(): Result
     {
-        $forbidden = array(
-            EmailLexer::S_COMMA,
-            EmailLexer::S_CLOSEBRACKET,
-            EmailLexer::S_OPENBRACKET,
-            EmailLexer::S_GREATERTHAN,
-            EmailLexer::S_LOWERTHAN,
-            EmailLexer::S_COLON,
-            EmailLexer::S_SEMICOLON,
-            EmailLexer::INVALID
-        );
-
-        if (in_array($token['type'], $forbidden) && !$closingQuote) {
-            throw new ExpectingATEXT();
+        $commentParser = new Comment($this->lexer, new LocalComment());
+        $result = $commentParser->parse();
+        $this->warnings = array_merge($this->warnings, $commentParser->getWarnings());
+        if($result->isInvalid()) {
+            return $result;
         }
+        return $result;
+    }
+
+    private function validateEscaping() : Result
+    {
+        //Backslash found
+        if ($this->lexer->token['type'] !== EmailLexer::S_BACKSLASH) {
+            return new ValidEmail();
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC)) {
+            return new InvalidEmail(new ExpectingATEXT('Found ATOM after escaping'), $this->lexer->token['value']);
+        }
+
+        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB, EmailLexer::C_DEL))) {
+            return new ValidEmail();
+        }
+
+        return new ValidEmail();
     }
 }

vendor/egulias/email-validator/src/Parser/Parser.php

@@ -1,249 +0,0 @@
-<?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();
-        }
-    }
-}

vendor/egulias/email-validator/src/Parser/PartParser.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\ConsecutiveDot;
+use Egulias\EmailValidator\Result\Result;
+use Egulias\EmailValidator\Result\ValidEmail;
+
+abstract class PartParser
+{
+    /**
+     * @var array
+     */
+    protected $warnings = [];
+
+    /**
+     * @var EmailLexer
+     */
+    protected $lexer;
+
+    public function __construct(EmailLexer $lexer)
+    {
+        $this->lexer = $lexer;
+    }
+
+    abstract public function parse() : Result;
+
+    /**
+     * @return \Egulias\EmailValidator\Warning\Warning[]
+     */
+    public function getWarnings()
+    {
+        return $this->warnings;
+    }
+
+    protected function parseFWS() : Result
+    {
+        $foldingWS = new FoldingWhiteSpace($this->lexer);
+        $resultFWS = $foldingWS->parse();
+        $this->warnings = array_merge($this->warnings, $foldingWS->getWarnings());
+        return $resultFWS;
+    }
+
+    protected function checkConsecutiveDots() : Result
+    {
+        if ($this->lexer->token['type'] === EmailLexer::S_DOT && $this->lexer->isNextToken(EmailLexer::S_DOT)) {
+            return new InvalidEmail(new ConsecutiveDot(), $this->lexer->token['value']);
+        }
+
+        return new ValidEmail();
+    }
+
+    protected function escaped() : bool
+    {
+        $previous = $this->lexer->getPrevious();
+
+        return $previous && $previous['type'] === EmailLexer::S_BACKSLASH
+            &&
+            $this->lexer->token['type'] !== EmailLexer::GENERIC;
+    }
+}