Add charset rule

JanHolger · Sep 4, 2023 · Oct 7, 2022 · Jan 26, 2023 · Jan 26, 2023 · Apr 20, 2023
commit 11e3194890b3732743ed52602347fe378e8dbf91
diff --git a/pom.xml b/pom.xml
@@ -44,15 +44,8 @@
         <dependency>
             <groupId>org.javawebstack</groupId>
             <artifactId>abstract-data</artifactId>
-            <version>1.0.4</version>
+            <version>1.0.6</version>
         </dependency>
-        <!--- Temporary fix for transitive vulnerabilities -->
-        <dependency>
-            <groupId>org.yaml</groupId>
-            <artifactId>snakeyaml</artifactId>
-            <version>1.33</version>
-        </dependency>
-        <!--- ============================================ -->
         <dependency>
             <groupId>com.sun.mail</groupId>
             <artifactId>javax.mail</artifactId>

diff --git a/src/main/java/org/javawebstack/validator/Validator.java b/src/main/java/org/javawebstack/validator/Validator.java
@@ -2,8 +2,8 @@
 
 import org.javawebstack.abstractdata.AbstractArray;
 import org.javawebstack.abstractdata.AbstractElement;
-import org.javawebstack.abstractdata.AbstractMapper;
 import org.javawebstack.abstractdata.AbstractNull;
+import org.javawebstack.abstractdata.mapper.Mapper;
 import org.javawebstack.abstractdata.mapper.MapperTypeSpec;
 import org.javawebstack.validator.rule.*;
 
@@ -45,6 +45,7 @@ public class Validator {
         registerRuleType("email",      EmailRule.Validator.class,       EmailRule.class);
         registerRuleType("regex",      RegexRule.Validator.class,       RegexRule.class);
         registerRuleType("uuid",       UUIDRule.Validator.class,        UUIDRule.class);
+        registerRuleType("charset",    CharsetRule.Validator.class,     CharsetRule.class);
     }
 
     private final Map<String[], ValidationConfig> rules = new HashMap<>();
@@ -121,16 +122,16 @@ public static Validator getValidator(Class<?> type) {
         return validator;
     }
 
-    public static <T> T map(ValidationContext context, Class<T> type, AbstractElement element, AbstractMapper mapper) {
+    public static <T> T map(ValidationContext context, Class<T> type, AbstractElement element, Mapper mapper) {
         Validator validator = getValidator(type);
         ValidationResult result = validator.validate(context, element);
         if (!result.isValid())
             throw new ValidationException(result);
-        return mapper.fromAbstract(element, type);
+        return mapper.map(element, type);
     }
 
     public static <T> T map(ValidationContext context, Class<T> type, AbstractElement element) {
-        return map(context, type, element, new AbstractMapper());
+        return map(context, type, element, new Mapper());
     }
 
     public Validator rule(String[] key, ValidationRule... rules) {

diff --git a/src/main/java/org/javawebstack/validator/rule/CharsetRule.java b/src/main/java/org/javawebstack/validator/rule/CharsetRule.java
@@ -0,0 +1,77 @@
+package org.javawebstack.validator.rule;
+
+import org.javawebstack.abstractdata.AbstractElement;
+import org.javawebstack.validator.ValidationContext;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.util.Locale;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CharsetRule {
+
+    String value() default "";
+    boolean upper() default false;
+    boolean lower() default false;
+    boolean numeric() default false;
+    boolean accents() default false;
+
+    class Validator implements ValidationRule {
+
+        private static final String ALPHA = "abcdefghijklmnopqrstuvwxyz";
+        private static final String ACCENTS = "äëïöüéàèùâêîôûç";
+
+        private final String charset;
+
+        public Validator(CharsetRule rule) {
+            this(makeCharset(rule));
+        }
+
+        public Validator(String charset) {
+            this.charset = charset;
+        }
+
+        public Validator(String[] params) {
+            this(params.length > 0 ? params[0] : "");
+        }
+
+        public String validate(ValidationContext context, Field field, AbstractElement value) {
+            if (value == null || value.isNull())
+                return null;
+            if (!value.isPrimitive())
+                return "Not a string value";
+            char[] chars = value.string().toCharArray();
+            for(int i=0; i<chars.length; i++) {
+                char c = chars[i];
+                if(!charset.contains(String.valueOf(c))) {
+                    return String.format("Forbidden character '%c' at position %d", c, i);
+                }
+            }
+            return null;
+        }
+
+        private static String makeCharset(CharsetRule rule) {
+            StringBuilder sb = new StringBuilder(rule.value());
+            if(rule.lower()) {
+                sb.append(ALPHA);
+                if(rule.accents())
+                    sb.append(ACCENTS);
+            }
+            if(rule.upper()) {
+                sb.append(ALPHA.toUpperCase(Locale.ROOT));
+                if(rule.accents())
+                    sb.append(ACCENTS.toUpperCase(Locale.ROOT));
+            }
+            if(rule.numeric()) {
+                sb.append("1234567890");
+            }
+            return sb.toString();
+        }
+
+    }
+
+}