Skip to content

Commit ec68e03

Browse files
gabriel-logangabriel-logan
committed
refactor: utils and validate to use best practices
1 parent 2db50d4 commit ec68e03

8 files changed

Lines changed: 135 additions & 107 deletions

File tree

‎.idea/sonarlint/issuestore/1/0/1035b95fde851fd8381dabb4da89dd79908aed9b‎

Lines changed: 4 additions & 6 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎.idea/sonarlint/issuestore/5/8/5879b52636e240d2cfcbd5e54543d3959f957811‎

Lines changed: 3 additions & 5 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎.idea/sonarlint/issuestore/5/a/5a503c465e2e403dbd4c3fe2906c7cecc8e13602‎

Lines changed: 0 additions & 5 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎.idea/workspace.xml‎

Lines changed: 3 additions & 15 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎src/main/java/io/github/multiform_validator/Utils.java‎

Lines changed: 59 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package io.github.multiform_validator;
22

3+
import org.jetbrains.annotations.NotNull;
4+
35
import java.util.*;
46
import java.util.regex.*;
57

@@ -36,14 +38,34 @@ public static class GetOnlyEmailOptionsParams {
3638
* @return The extracted email addresses.
3739
*/
3840
public static Object getOnlyEmail(String text, GetOnlyEmailOptionsParams options) {
41+
options = validateOptions(options);
42+
43+
List<String> matches = getEmailMatches(text);
44+
45+
if (matches.isEmpty()) {
46+
return "No email found";
47+
}
48+
49+
if (options.cleanDomain != null && !options.cleanDomain.equals(false)) {
50+
matches = cleanDomain(matches, options.cleanDomain);
51+
}
52+
53+
return handleRepeatEmail(matches, options);
54+
}
55+
56+
private static @NotNull GetOnlyEmailOptionsParams validateOptions(GetOnlyEmailOptionsParams options) {
3957
if (options == null) {
4058
options = getOnlyEmailDefaultOptionsParams;
4159
}
4260

43-
Boolean multiple = options.multiple != null ? options.multiple : getOnlyEmailDefaultOptionsParams.multiple;
44-
Object cleanDomain = options.cleanDomain != null ? options.cleanDomain : getOnlyEmailDefaultOptionsParams.cleanDomain;
45-
Boolean repeatEmail = options.repeatEmail != null ? options.repeatEmail : getOnlyEmailDefaultOptionsParams.repeatEmail;
61+
options.multiple = options.multiple != null ? options.multiple : getOnlyEmailDefaultOptionsParams.multiple;
62+
options.cleanDomain = options.cleanDomain != null ? options.cleanDomain : getOnlyEmailDefaultOptionsParams.cleanDomain;
63+
options.repeatEmail = options.repeatEmail != null ? options.repeatEmail : getOnlyEmailDefaultOptionsParams.repeatEmail;
64+
65+
return options;
66+
}
4667

68+
private static @NotNull List<String> getEmailMatches(String text) {
4769
Pattern emailPattern = Pattern.compile("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}");
4870
Matcher matcher = emailPattern.matcher(text);
4971

@@ -52,46 +74,49 @@ public static Object getOnlyEmail(String text, GetOnlyEmailOptionsParams options
5274
matches.add(matcher.group());
5375
}
5476

55-
if (matches.isEmpty()) {
56-
return "No email found";
57-
}
77+
return matches;
78+
}
5879

59-
if (cleanDomain != null && !cleanDomain.equals(false)) {
60-
List<String> domainsToClean = cleanDomain instanceof List ? (List<String>) cleanDomain : GetOnlyEmailCleanAfterDefaultDomain;
61-
62-
List<String> cleanedEmails = new ArrayList<>();
63-
for (String email : matches) {
64-
for (String domain : domainsToClean) {
65-
int index = email.lastIndexOf(domain);
66-
if (index != -1) {
67-
email = email.substring(0, index + domain.length());
68-
break;
69-
}
70-
}
80+
private static @NotNull List<String> cleanDomain(@NotNull List<String> emails, Object cleanDomain) {
81+
List<String> domainsToClean;
7182

72-
for (String domain : domainsToClean) {
73-
int index = email.indexOf(domain);
74-
if (index != -1) {
75-
email = email.substring(0, index + domain.length());
76-
break;
77-
}
83+
if (cleanDomain instanceof List) {
84+
@SuppressWarnings("unchecked")
85+
List<String> castedList = (List<String>) cleanDomain;
86+
domainsToClean = castedList;
87+
} else {
88+
domainsToClean = GetOnlyEmailCleanAfterDefaultDomain;
89+
}
90+
91+
List<String> cleanedEmails = new ArrayList<>();
92+
for (String email : emails) {
93+
for (String domain : domainsToClean) {
94+
int index = email.lastIndexOf(domain);
95+
if (index != -1) {
96+
email = email.substring(0, index + domain.length());
97+
break;
7898
}
79-
cleanedEmails.add(email);
8099
}
81100

82-
if (Boolean.FALSE.equals(repeatEmail)) {
83-
Set<String> uniqueEmails = new LinkedHashSet<>(cleanedEmails);
84-
return Boolean.TRUE.equals(multiple) ? new ArrayList<>(uniqueEmails) : uniqueEmails.iterator().next();
101+
for (String domain : domainsToClean) {
102+
int index = email.indexOf(domain);
103+
if (index != -1) {
104+
email = email.substring(0, index + domain.length());
105+
break;
106+
}
85107
}
86-
87-
return Boolean.TRUE.equals(multiple) ? cleanedEmails : cleanedEmails.get(0);
108+
cleanedEmails.add(email);
88109
}
89110

90-
if (Boolean.FALSE.equals(repeatEmail)) {
91-
Set<String> uniqueEmails = new LinkedHashSet<>(matches);
92-
return Boolean.TRUE.equals(multiple) ? new ArrayList<>(uniqueEmails) : uniqueEmails.iterator().next();
111+
return cleanedEmails;
112+
}
113+
114+
private static Object handleRepeatEmail(List<String> emails, @NotNull GetOnlyEmailOptionsParams options) {
115+
if (Boolean.FALSE.equals(options.repeatEmail)) {
116+
Set<String> uniqueEmails = new LinkedHashSet<>(emails);
117+
return Boolean.TRUE.equals(options.multiple) ? new ArrayList<>(uniqueEmails) : uniqueEmails.iterator().next();
93118
}
94119

95-
return Boolean.TRUE.equals(multiple) ? matches : matches.get(0);
120+
return Boolean.TRUE.equals(options.multiple) ? emails : emails.get(0);
96121
}
97122
}

‎src/main/java/io/github/multiform_validator/Validate.java‎

Lines changed: 26 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package io.github.multiform_validator;
22

3+
import org.jetbrains.annotations.NotNull;
4+
35
import java.util.*;
46
import java.util.regex.*;
57

@@ -66,36 +68,46 @@ public static boolean validateEmail(String email) {
6668
* @throws IllegalArgumentException if the input value is empty or if both validDomains and validDomainsList are used at the same time.
6769
*/
6870
public static boolean validateEmail(String email, ValidateEmailOptionsParams options) {
69-
if (options == null) {
70-
options = validateEmailDefaultOptionsParams;
71-
}
71+
options = validateOptions(options);
7272

7373
if (email == null || email.isEmpty()) {
7474
throw new IllegalArgumentException("Input value cannot be empty.");
7575
}
7676

77+
Pattern regex = createRegexPattern(options);
78+
79+
return validateEmailWithRegex(email, regex, options);
80+
}
81+
82+
private static @NotNull ValidateEmailOptionsParams validateOptions(ValidateEmailOptionsParams options) {
83+
if (options == null) {
84+
options = validateEmailDefaultOptionsParams;
85+
}
86+
7787
if (options.validDomains && !options.validDomainsList.isEmpty()) {
7888
throw new IllegalArgumentException("Cannot use validDomains and validDomainsList at the same time.");
7989
}
8090

81-
int maxLength = options.maxLength > 0 ? options.maxLength : validateEmailDefaultOptionsParams.maxLength;
82-
String country = options.country != null ? options.country : validateEmailDefaultOptionsParams.country;
91+
return options;
92+
}
93+
94+
private static @NotNull Pattern createRegexPattern(@NotNull ValidateEmailOptionsParams options) {
8395
List<String> validDomains = options.validDomains ? validateEmailDefaultOptionsParams.validDomainsList : options.validDomainsList;
8496

85-
// Initialize with an empty regular expression
86-
Pattern regex = Pattern.compile("");
8797
List<String> validDomainsCustom = new ArrayList<>();
88-
8998
if (validDomains != null && !validDomains.isEmpty()) {
9099
for (String domain : validDomains) {
91100
validDomainsCustom.add(domain.replaceAll("[.*+?^${}()|\\[\\]\\\\]", "\\\\$0"));
92101
}
93-
regex = Pattern.compile(String.join("|", validDomainsCustom) + "$", Pattern.CASE_INSENSITIVE);
102+
return Pattern.compile(String.join("|", validDomainsCustom) + "$", Pattern.CASE_INSENSITIVE);
94103
} else if (validDomains != null) {
95-
regex = Pattern.compile(String.join("|", validateEmailValidDomainsDefault) + "$", Pattern.CASE_INSENSITIVE);
104+
return Pattern.compile(String.join("|", validateEmailValidDomainsDefault) + "$", Pattern.CASE_INSENSITIVE);
96105
}
97106

98-
// Use the Matcher to check if the email ends with one of the valid domains
107+
return Pattern.compile("");
108+
}
109+
110+
private static boolean validateEmailWithRegex(String email, @NotNull Pattern regex, ValidateEmailOptionsParams options) {
99111
Matcher matcher = regex.matcher(email);
100112
if (!matcher.find()) {
101113
return false;
@@ -105,13 +117,12 @@ public static boolean validateEmail(String email, ValidateEmailOptionsParams opt
105117
return false;
106118
}
107119

108-
if (email.length() > maxLength) {
120+
if (email.length() > options.maxLength) {
109121
return false;
110122
}
111123

112-
// If country is provided, check if the email ends with the country code
113-
if (country != null && !country.isEmpty()) {
114-
return email.endsWith("." + country);
124+
if (options.country != null && !options.country.isEmpty()) {
125+
return email.endsWith("." + options.country);
115126
}
116127

117128
return true;

‎src/main/java/io/github/multiform_validator/Validator.java‎

Lines changed: 11 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -311,33 +311,17 @@ public static boolean isPostalCode(String postalCode) {
311311
throw new IllegalArgumentException("Input value must be a string.");
312312
}
313313

314-
final String usZipCodeRegex = "^\\d{5}(-\\d{4})?$";
315-
final String canadaPostalCodeRegex = "^[A-Za-z]\\d[A-Za-z] \\d[A-Za-z]\\d$";
316-
final String ukPostalCodeRegex = "^[A-Za-z]{1,2}\\d[A-Za-z\\d]? \\d[A-Za-z]{2}$";
317-
final String francePostalCodeRegex = "^\\d{5}$";
318-
final String netherlandsPostalCodeRegex = "^\\d{4}$";
319-
final String japanPostalCodeRegex = "^\\d{3}-\\d{4}$";
320-
final String spainPostalCodeRegex = "^\\d{5}$";
321-
final String southAfricaPostalCodeRegex = "^\\d{4}$";
322-
final String germanyPostalCodeRegex = "^\\d{5}$";
323-
final String switzerlandPostalCodeRegex = "^\\d{4}$";
324-
final String brazilPostalCodeRegex = "^\\d{5}-\\d{3}$";
325-
final String italyPostalCodeRegex = "^\\d{5}$";
326-
final String usZipCodeOnlyRegex = "^\\d{5}$";
327-
328-
return postalCode.matches(usZipCodeRegex) ||
329-
postalCode.matches(canadaPostalCodeRegex) ||
330-
postalCode.matches(ukPostalCodeRegex) ||
331-
postalCode.matches(francePostalCodeRegex) ||
332-
postalCode.matches(netherlandsPostalCodeRegex) ||
333-
postalCode.matches(japanPostalCodeRegex) ||
334-
postalCode.matches(spainPostalCodeRegex) ||
335-
postalCode.matches(southAfricaPostalCodeRegex) ||
336-
postalCode.matches(germanyPostalCodeRegex) ||
337-
postalCode.matches(switzerlandPostalCodeRegex) ||
338-
postalCode.matches(brazilPostalCodeRegex) ||
339-
postalCode.matches(italyPostalCodeRegex) ||
340-
postalCode.matches(usZipCodeOnlyRegex);
314+
final String REGEX_TEST1 = "^\\d{5}(-\\d{4})?$"; // US ZIP code
315+
final String REGEX_TEST2 = "^[A-Za-z]\\d[A-Za-z] \\d[A-Za-z]\\d$"; // Canada postal code
316+
final String REGEX_TEST3 = "^[A-Za-z]{1,2}\\d[A-Za-z\\d]? \\d[A-Za-z]{2}$"; // UK postal code
317+
final String REGEX_TEST4 = "^\\d{5}$"; // France, Spain, Italy, Germany, US postal code
318+
final String REGEX_TEST5 = "^\\d{4}$"; // Netherlands, South Africa, Switzerland postal code
319+
final String REGEX_TEST6 = "^\\d{3}-\\d{4}$"; // Japan postal code
320+
final String REGEX_TEST7 = "^\\d{5}-\\d{3}$"; // Brazil postal code
321+
322+
return postalCode.matches(REGEX_TEST1) || postalCode.matches(REGEX_TEST2) || postalCode.matches(REGEX_TEST3)
323+
|| postalCode.matches(REGEX_TEST4) || postalCode.matches(REGEX_TEST5) || postalCode.matches(REGEX_TEST6)
324+
|| postalCode.matches(REGEX_TEST7);
341325
}
342326

343327
// ##############################################################################################################

0 commit comments

Comments
 (0)