🐛 Valid domains won't validate (#11)

* 🐛 Valid domains won't validate

 - Allow valid domains with subdomains starting with numbers

 - Allow valid domains with hyphens

* 🎨 Address @egulias code review

 - Extract method for characters not allowed in subdomains

 - Separate no warning domain tests from warning tests

 - Expand domain tests to cover unicode, leading num, and hyphens

Author: AlainODea

src/main/java/emailvalidator4j/lexer/EmailLexer.java

@@ -16,7 +16,7 @@ public class EmailLexer {
 
     public void lex(String input) {
         Pattern pattern = Pattern.compile(
-                "(([a-zA-Z_]|[^\\u0000-\\u007F])+[46]?)|([0-9]+)|(\r\n)|(::)|(\\s+?)|(.)|(\\p{Cc}+)", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
+                "(([a-zA-Z0-9!#$%&'*+\\-/=?^_`{|}~]|[^\\u0000-\\u007F])+[46]?)|([0-9]+)|(\r\n)|(::)|(\\s+?)|(.)|(\\p{Cc}+)", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
         );
         Matcher matcher = pattern.matcher(input);
 

src/main/java/emailvalidator4j/parser/DomainPart.java

@@ -12,6 +12,7 @@
 
 final class DomainPart extends Parser {
 
+    private static final Pattern subDomainIllegalCharacters = Pattern.compile("[^a-zA-Z0-9\\-\\x00007F-\\u10FFFF]");
     private static final int DOMAINPART_MAX_LENGTH = 255;
     private static final int LABEL_MAX_LENGTH = 63;
     private final HashSet<TokenInterface> notAllowedTokens = new HashSet<TokenInterface>(2) {{
@@ -112,13 +113,29 @@ private boolean isDomainLiteral(boolean openBrackets) throws UnclosedDomainLiter
         return this.lexer.getCurrent().equals(Tokens.OPENBRACKET);
     }
 
-    private void checkNotAllowedChars(TokenInterface token) throws DomainNotAllowedCharacter {
+    private void checkNotAllowedChars(TokenInterface token) throws DomainNotAllowedCharacter, DomainHyphen {
         if (notAllowedTokens.contains(token)) {
             throw new DomainNotAllowedCharacter(
                     String.format("%s is not allowed in domain part", token.getName())
             );
         }
+        checkNotAllowedCharsInSubDomain(token);
+    }
 
+    private void checkNotAllowedCharsInSubDomain(TokenInterface token) throws DomainHyphen, DomainNotAllowedCharacter {
+        if (Tokens.GENERIC.equals(token.getName())) {
+            String subDomain = token.getText();
+            if (subDomain.charAt(0) == '-') {
+                throw new DomainHyphen("Sub-domains cannot start with hyphen");
+            }
+            if (subDomain.charAt(Math.max(0, subDomain.length() - 1)) == '-') {
+                throw new DomainHyphen("Sub-domains cannot end with hyphen");
+            }
+            Matcher matcher = subDomainIllegalCharacters.matcher(subDomain);
+            if (matcher.find()) {
+                throw new DomainNotAllowedCharacter(matcher.group());
+            }
+        }
     }
 
     private void checkLabelLength() {

src/test/java/emailvalidator4j/EmailValidatorTest.java

@@ -81,6 +81,10 @@ public static Object[][] validEmailsProvider() {
                 {"example((example))@fakedfake.co.uk"},
                 {"example@faked(fake).co.uk"},
                 {"[email protected]"},
+                {"[email protected]"},
+                {"[email protected]"},
+                {"[email protected]"},
+                {"[email protected]"},
                 {"инфо@письмо.рф"},
                 {"\"username\"@example.com"},
                 {"\"user,name\"@example.com"},

src/test/java/emailvalidator4j/lexer/EmailLexerTest.java

@@ -167,6 +167,17 @@ public void toStringReturnsLeftTokens() {
         Assert.assertTrue("@bar.com".equals(lexer.toString()));
     }
 
+    @Test
+    @UseDataProvider("atextExamples")
+    public void atextParsing(String atext) {
+        EmailLexer lexer = new EmailLexer();
+        lexer.lex(atext);
+        TokenInterface token = lexer.getCurrent();
+        Assert.assertEquals(Tokens.GENERIC, token.getName());
+        Assert.assertEquals(atext, token.getText());
+
+    }
+
     @Test
     @UseDataProvider("invalidUTF8StringsProvider")
     public void invalidUTF8CharsAreInvalidTokens(String utf8String) throws Exception {
@@ -178,6 +189,42 @@ public void invalidUTF8CharsAreInvalidTokens(String utf8String) throws Exception
         );
     }
 
+    /*
+     *    atext           =   UTF8-non-ascii /
+     *                        ALPHA / DIGIT /    ; Printable US-ASCII
+     *                        "!" / "#" /        ;  characters not including
+     *                        "$" / "%" /        ;  specials.  Used for atoms.
+     *                        "&" / "'" /
+     *                        "*" / "+" /
+     *                        "-" / "/" /
+     *                        "=" / "?" /
+     *                        "^" / "_" /
+     *                        "`" / "{" /
+     *                        "|" / "}" /
+     *                        "~"
+     */
+    @DataProvider
+    public static Object[][] atextExamples() {
+        return new Object[][] {
+                {"a"},
+                {"1"},
+                {"!"},
+                {"\uD83D"},
+                {"aa"},
+                {"a1"},
+                {"a!"},
+                {"a\uD83D"},
+                {"aaa"},
+                {"a1a"},
+                {"a!a"},
+                {"a\uD83D!"},
+                {"aaa\uD83D"},
+                {"a1a\uD83D"},
+                {"a!a\uD83D"},
+                {"a\uD83Da\uD83D"},
+        };
+    }
+
     @DataProvider
     public static Object[][] invalidUTF8StringsProvider() throws Exception {
         ArrayList<ArrayList<String>> invalidStrings = new ArrayList<>();

src/test/java/emailvalidator4j/parser/DomainPartTest.java

@@ -12,6 +12,7 @@
 import org.junit.runner.RunWith;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 @RunWith(DataProviderRunner.class)
@@ -54,7 +55,7 @@ public static Object[][] invalidDomainParts() {
                 {DomainNotAllowedCharacter.class, "@example\\"},
                 {DomainNotAllowedCharacter.class, "@exa\\mple"},
                 {UnclosedDomainLiteral.class, "@example]"},
-                {ConsecutiveGeneric.class, "@example'"},
+                {DomainNotAllowedCharacter.class, "@example'"},
         };
     }
 
@@ -116,6 +117,30 @@ public static Object[][] domainPartWithWarnings() {
         };
     }
 
+    @Test
+    @UseDataProvider("domainPartWithoutWarnings")
+    public void domainPartHasNoWarnings(String domainPart) throws InvalidEmail {
+        DomainPart parser = this.getDomainPartParser();
+        parser.parse(domainPart);
+
+        Assert.assertEquals(Collections.emptyList(), parser.getWarnings());
+    }
+
+    @DataProvider
+    public static Object[][] domainPartWithoutWarnings() {
+        return new Object[][]{
+                {"@example.com"},
+                {"@subdomain.example.com"},
+                {"@has-hyphen.example.com"},
+                {"@1leadingnumber.example.com"},
+                {"@письмо.рф"},
+                {"@example.co"},
+                {"@subdomain.example.co"},
+                {"@has-hyphen.example.co"},
+                {"@1leadingnumber.example.co"},
+        };
+    }
+
     @Test
     public void lexedDomainIsExposed() throws InvalidEmail {
         DomainPart parser = this.getDomainPartParser();