Add support for array, List, and Set overrides with tests for type conversion.

Signed-off-by: Nora <46890129+RainbowDashLabs@users.noreply.github.com>

Author: rainbowdashlabs

build.gradle.kts

@@ -12,7 +12,7 @@ plugins {
 
 publishData {
     useEldoNexusRepos(false)
-    publishingVersion = "2.1.4"
+    publishingVersion = "2.2.0"
 }
 
 group = "dev.chojo"

src/main/java/dev/chojo/ocular/override/OverrideApplier.java

@@ -7,9 +7,16 @@
 
 import org.slf4j.Logger;
 
+import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import static org.slf4j.LoggerFactory.getLogger;
 
@@ -68,7 +75,7 @@ public static <V> void applyOverrides(V object, ValueSupplier supplier) {
                     field.setAccessible(true);
                     // The override value comes as a String (from env / prop), but the field
                     // might be an int, boolean, etc. convertValue handles that conversion.
-                    Object value = convertValue(field.getType(), override.get());
+                    Object value = convertValue(field.getType(), field.getGenericType(), override.get());
                     if (value != null) {
                         // Actually write the override value into the field on the config object
                         field.set(object, value);
@@ -91,7 +98,7 @@ public static <V> void applyOverrides(V object, ValueSupplier supplier) {
                 try {
                     method.setAccessible(true);
                     // Convert the string value to match the method's parameter type
-                    Object value = convertValue(method.getParameterTypes()[0], override.get());
+                    Object value = convertValue(method.getParameterTypes()[0], method.getGenericParameterTypes()[0], override.get());
                     if (value != null) {
                         // Call the method on the config object, passing the override value
                         method.invoke(object, value);
@@ -119,7 +126,7 @@ public static <V> void applyOverrides(V object, ValueSupplier supplier) {
                 if (targetField != null) {
                     try {
                         targetField.setAccessible(true);
-                        Object value = convertValue(targetField.getType(), override.get());
+                        Object value = convertValue(targetField.getType(), targetField.getGenericType(), override.get());
                         if (value != null) {
                             targetField.set(object, value);
                         }
@@ -253,9 +260,11 @@ private static void logOverwriteSources(Overwrite overwrite, String prefix, bool
     /**
      * Converts a string override value to the target field/parameter type.
      * Supports all Java primitive types and their boxed equivalents, plus String.
+     * Also supports arrays, {@link List} and {@link Set} of String, where the input
+     * value is a comma-separated string.
      * Returns null for unsupported types (with a warning logged).
      */
-    private static Object convertValue(Class<?> type, Object value) {
+    private static Object convertValue(Class<?> type, Type genericType, Object value) {
         if (value == null) return null;
         // Environment variables and system properties are always strings, so we need to parse
         // them into the correct Java type. For example, the string "8080" becomes the int 8080.
@@ -270,6 +279,44 @@ private static Object convertValue(Class<?> type, Object value) {
         if (type == short.class || type == Short.class) return Short.parseShort(stringValue);
         if (type == byte.class || type == Byte.class) return Byte.parseByte(stringValue);
 
+        // Arrays, Lists and Sets are provided as comma-separated strings
+        if (type.isArray()) {
+            Class<?> componentType = type.getComponentType();
+            String[] parts = stringValue.split(",", -1);
+            Object array = Array.newInstance(componentType, parts.length);
+            for (int i = 0; i < parts.length; i++) {
+                Object element = convertValue(componentType, componentType, parts[i].trim());
+                Array.set(array, i, element);
+            }
+            return array;
+        }
+
+        // Resolve the element type from the generic type parameter (e.g. List<Integer> -> Integer)
+        Class<?> elementType = String.class;
+        if (genericType instanceof ParameterizedType parameterized) {
+            Type[] typeArgs = parameterized.getActualTypeArguments();
+            if (typeArgs.length == 1 && typeArgs[0] instanceof Class<?> cls) {
+                elementType = cls;
+            }
+        }
+
+        if (type == List.class || type == ArrayList.class) {
+            String[] parts = stringValue.split(",", -1);
+            List<Object> list = new ArrayList<>();
+            for (String part : parts) {
+                list.add(convertValue(elementType, elementType, part.trim()));
+            }
+            return list;
+        }
+        if (type == Set.class || type == HashSet.class) {
+            String[] parts = stringValue.split(",", -1);
+            Set<Object> set = new HashSet<>();
+            for (String part : parts) {
+                set.add(convertValue(elementType, elementType, part.trim()));
+            }
+            return set;
+        }
+
         log.warn("Unsupported override type: {}", type.getName());
         return null;
     }

src/test/java/dev/chojo/ocular/OverrideApplierTest.java

@@ -9,9 +9,12 @@
 import dev.chojo.ocular.override.ValueSupplier;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -107,6 +110,75 @@ void applierUsesSupplierValue() {
         assertEquals("supplied", target.name);
     }
 
+    @Test
+    void stringArrayOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("tags", "a,b,c"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertArrayEquals(new String[]{"a", "b", "c"}, target.tags);
+    }
+
+    @Test
+    void intArrayOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("numbers", "1,2,3"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertArrayEquals(new int[]{1, 2, 3}, target.numbers);
+    }
+
+    @Test
+    void listOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("names", "alice,bob,charlie"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertEquals(List.of("alice", "bob", "charlie"), target.names);
+    }
+
+    @Test
+    void listOfIntegersOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("counts", "10,20,30"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertEquals(List.of(10, 20, 30), target.counts);
+    }
+
+    @Test
+    void setOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("roles", "admin,user,guest"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertEquals(Set.of("admin", "user", "guest"), target.roles);
+    }
+
+    @Test
+    void setOfIntegersOverride() {
+        CollectionTarget target = new CollectionTarget();
+        MapSupplier supplier = new MapSupplier(Map.of("ids", "1,2,3"));
+
+        OverrideApplier.applyOverrides(target, supplier);
+
+        assertEquals(Set.of(1, 2, 3), target.ids);
+    }
+
+    static class CollectionTarget {
+        String[] tags = {};
+        int[] numbers = {};
+        List<String> names = List.of();
+        List<Integer> counts = List.of();
+        Set<String> roles = Set.of();
+        Set<Integer> ids = Set.of();
+    }
+
     static class FieldTarget {
         String name = "original";
         int count = 0;