refactor: applying best code practices

Author: gabriel-logan

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

@@ -23,9 +23,21 @@ private Utils() {
      * Options for the getOnlyEmail method.
      */
     public static class GetOnlyEmailOptionsParams {
-        public Boolean multiple = false;
-        public Object cleanDomain = false;
-        public Boolean repeatEmail = false;
+        private Boolean multiple = false;
+        private Object cleanDomain = false;
+        private Boolean repeatEmail = false;
+
+        public void setMultiple(Boolean multiple) {
+            this.multiple = multiple;
+        }
+
+        public void setCleanDomain(Object cleanDomain) {
+            this.cleanDomain = cleanDomain;
+        }
+
+        public void setRepeatEmail(Boolean repeatEmail) {
+            this.repeatEmail = repeatEmail;
+        }
     }
 
     private static final GetOnlyEmailOptionsParams getOnlyEmailDefaultOptionsParams = new GetOnlyEmailOptionsParams();

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

@@ -17,7 +17,7 @@ private Validate() {
     // ##############################################################################################################
     // ##############################################################################################################
     // validateEmail
-    
+
     /**
      * The default list of valid email domains.
      */
@@ -39,10 +39,26 @@ private Validate() {
      * The ValidateEmailOptionsParams class represents the options for email validation.
      */
     public static class ValidateEmailOptionsParams {
-        public int maxLength = 400;
-        public String country = "";
-        public boolean validDomains = false;
-        public List<String> validDomainsList = new ArrayList<>();
+        private int maxLength = 400;
+        private String country = "";
+        private boolean validDomains = false;
+        private List<String> validDomainsList = new ArrayList<>();
+
+        public void setMaxLength(int maxLength) {
+            this.maxLength = maxLength;
+        }
+
+        public void setCountry(String country) {
+            this.country = country;
+        }
+
+        public void setValidDomains(boolean validDomains) {
+            this.validDomains = validDomains;
+        }
+
+        public void setValidDomainsList(List<String> validDomainsList) {
+            this.validDomainsList = validDomainsList;
+        }
     }
 
     // Default options for email validation
@@ -62,7 +78,7 @@ public static boolean validateEmail(String email) {
     /**
      * Validates an email address using the specified options.
      *
-     * @param email The email address to validate.
+     * @param email   The email address to validate.
      * @param options The options for email validation.
      * @return true if the email address is valid, false otherwise.
      * @throws IllegalArgumentException if the input value is empty or if both validDomains and validDomainsList are used at the same time.

.idea/workspace.xml

@@ -22,54 +22,54 @@ void testGetOnlyEmail() {
 
         // Test with multiple emails
         Utils.GetOnlyEmailOptionsParams options1 = new Utils.GetOnlyEmailOptionsParams();
-        options1.multiple = true;
+        options1.setMultiple(true);
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@example.com", "test2@example.com")),
                 Utils.getOnlyEmail("This is a sample text with emails test1@example.com and test2@example.com", options1)
         );
 
         // Test with multiple emails and clean domain
         Utils.GetOnlyEmailOptionsParams options2 = new Utils.GetOnlyEmailOptionsParams();
-        options2.multiple = true;
-        options2.cleanDomain = true;
+        options2.setMultiple(true);
+        options2.setCleanDomain(true);
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@example.com", "test2@example.com")),
                 Utils.getOnlyEmail("This is a sample text with emails test1@example.comAWODI test2@example.comAWDOI awwdawd", options2)
         );
 
         // Test with multiple emails and clean domain and repeat email
         Utils.GetOnlyEmailOptionsParams options3 = new Utils.GetOnlyEmailOptionsParams();
-        options3.multiple = true;
-        options3.cleanDomain = true;
-        options3.repeatEmail = true;
+        options3.setMultiple(true);
+        options3.setCleanDomain(true);
+        options3.setRepeatEmail(true);
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@example.com", "test1@example.com", "test2@example.com")),
                 Utils.getOnlyEmail("This is a sample text with emails test1@example.comASD test1@example.comASD blabla test2@example.com", options3)
         );
 
         // Test with multiple emails and repeated email however repeatEmail is false
         Utils.GetOnlyEmailOptionsParams options4 = new Utils.GetOnlyEmailOptionsParams();
-        options4.multiple = true;
-        options4.cleanDomain = true;
-        options4.repeatEmail = false;
+        options4.setMultiple(true);
+        options4.setCleanDomain(true);
+        options4.setRepeatEmail(false);
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@example.com", "test2@example.com")),
                 Utils.getOnlyEmail("vails test1@example.comASD test1@example.comASD blabla test2@example.com", options4)
         );
 
         // Test with clean domain as false
         Utils.GetOnlyEmailOptionsParams options5 = new Utils.GetOnlyEmailOptionsParams();
-        options5.multiple = true;
-        options5.cleanDomain = false;
+        options5.setMultiple(true);
+        options5.setCleanDomain(false);
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@example.comAAA", "test2@example.com.br")),
                 Utils.getOnlyEmail("vails test1@example.comAAA , test2@example.com.br yes no", options5)
         );
 
         // Test passing own clean domain
         Utils.GetOnlyEmailOptionsParams options6 = new Utils.GetOnlyEmailOptionsParams();
-        options6.multiple = true;
-        options6.cleanDomain = Collections.singletonList(".own");
+        options6.setMultiple(true);
+        options6.setCleanDomain(Collections.singletonList(".own"));
         assertEquals(
                 new ArrayList<>(Arrays.asList("test1@com.own", "test2@com.own")),
                 Utils.getOnlyEmail("vails test1@com.ownASDAW , test2@com.ownyes no", options6)

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

@@ -2,6 +2,8 @@
 import io.github.multiform_validator.Validate.ValidateEmailOptionsParams;
 import org.junit.jupiter.api.Test;
 
+import java.util.Collections;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 class ValidateTest {
@@ -19,37 +21,37 @@ void testValidateEmail() {
 
         // Test with maxLength option
         ValidateEmailOptionsParams options1 = new ValidateEmailOptionsParams();
-        options1.maxLength = 10;
+        options1.setMaxLength(10);
         assertFalse(Validate.validateEmail("foo@gmail.com", options1));
 
         // Test with country option
         ValidateEmailOptionsParams options2 = new ValidateEmailOptionsParams();
-        options2.maxLength = 400;
-        options2.country = "br";
+        options2.setMaxLength(400);
+        options2.setCountry("br");
         assertTrue(Validate.validateEmail("foo@gmail.com.br", options2));
         assertFalse(Validate.validateEmail("foo@gmail.org", options2));
 
         // Test with validDomains option
         ValidateEmailOptionsParams options3 = new ValidateEmailOptionsParams();
-        options3.validDomains = true;
+        options3.setValidDomains(true);
         assertTrue(Validate.validateEmail("foo@gmail.com", options3));
         assertFalse(Validate.validateEmail("foo@bar.com", options3));
 
         // Test with validDomainsList option
         ValidateEmailOptionsParams options4 = new ValidateEmailOptionsParams();
-        options4.validDomainsList.add("@voicemail.com");
+        options4.setValidDomainsList(Collections.singletonList("@voicemail.com"));
         assertTrue(Validate.validateEmail("foo@voicemail.com", options4));
         assertFalse(Validate.validateEmail("foo@gmail.com", options4));
 
         // Test with validDomains and validDomainsList options at the same time
         ValidateEmailOptionsParams options5 = new ValidateEmailOptionsParams();
-        options5.validDomains = true;
-        options5.validDomainsList.add("@voicemail.com");
+        options5.setValidDomains(true);
+        options5.setValidDomainsList(Collections.singletonList("@voicemail.com"));
         assertThrows(IllegalArgumentException.class, () -> Validate.validateEmail("foo@gmail.com", options5));
 
         // Test with invalid domain
         ValidateEmailOptionsParams options6 = new ValidateEmailOptionsParams();
-        options6.validDomains = true;
+        options6.setValidDomains(true);
         assertFalse(Validate.validateEmail("foo@bar.com", options6));
     }