Add support for enum values in @ConfigProperties

Author: geoand

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/configproperties/ClassConfigPropertiesUtil.java

@@ -267,26 +267,37 @@ private static ResultHandle populateConfigObject(ClassLoader classLoader, ClassI
                  */
                 DotName fieldTypeDotName = fieldType.name();
                 ClassInfo fieldTypeClassInfo = applicationIndex.getClassByName(fieldType.name());
+                ResultHandle mpConfig = methodCreator.getMethodParam(0);
                 if (fieldTypeClassInfo != null) {
-                    if (!fieldTypeClassInfo.hasNoArgsConstructor()) {
-                        throw new IllegalArgumentException(
-                                "Nested configuration class '" + fieldTypeClassInfo + "' must contain a no-args constructor ");
-                    }
-
-                    if (!Modifier.isPublic(fieldTypeClassInfo.flags())) {
-                        throw new IllegalArgumentException(
-                                "Nested configuration class '" + fieldTypeClassInfo + "' must be public ");
-                    }
+                    if (DotNames.ENUM.equals(fieldTypeClassInfo.superName())) {
+                        // just read the value from MP Config normally
+                        ResultHandle value = methodCreator.invokeInterfaceMethod(
+                                MethodDescriptor.ofMethod(Config.class, "getValue", Object.class, String.class, Class.class),
+                                mpConfig,
+                                methodCreator.load(getFullConfigName(prefixStr, namingStrategy, field)),
+                                methodCreator.loadClass(fieldTypeDotName.toString()));
+
+                        createWriteValue(methodCreator, configObject, field, setter, useFieldAccess, value);
+                    } else {
+                        if (!fieldTypeClassInfo.hasNoArgsConstructor()) {
+                            throw new IllegalArgumentException(
+                                    "Nested configuration class '" + fieldTypeClassInfo
+                                            + "' must contain a no-args constructor ");
+                        }
 
-                    ResultHandle nestedConfigObject = populateConfigObject(classLoader, fieldTypeClassInfo,
-                            prefixStr + "." + namingStrategy.getName(field.name()), namingStrategy, failOnMismatchingMember,
-                            methodCreator,
-                            applicationIndex, configProperties);
-                    createWriteValue(methodCreator, configObject, field, setter, useFieldAccess, nestedConfigObject);
+                        if (!Modifier.isPublic(fieldTypeClassInfo.flags())) {
+                            throw new IllegalArgumentException(
+                                    "Nested configuration class '" + fieldTypeClassInfo + "' must be public ");
+                        }
 
+                        ResultHandle nestedConfigObject = populateConfigObject(classLoader, fieldTypeClassInfo,
+                                getFullConfigName(prefixStr, namingStrategy, field), namingStrategy, failOnMismatchingMember,
+                                methodCreator,
+                                applicationIndex, configProperties);
+                        createWriteValue(methodCreator, configObject, field, setter, useFieldAccess, nestedConfigObject);
+                    }
                 } else {
-                    String fullConfigName = prefixStr + "." + namingStrategy.getName(field.name());
-                    ResultHandle config = methodCreator.getMethodParam(0);
+                    String fullConfigName = getFullConfigName(prefixStr, namingStrategy, field);
                     if (DotNames.OPTIONAL.equals(fieldTypeDotName)) {
                         Type genericType = determineSingleGenericType(field.type(),
                                 field.declaringClass().name());
@@ -296,14 +307,14 @@ private static ResultHandle populateConfigObject(ClassLoader classLoader, ClassI
                             ResultHandle setterValue = methodCreator.invokeInterfaceMethod(
                                     MethodDescriptor.ofMethod(Config.class, "getOptionalValue", Optional.class, String.class,
                                             Class.class),
-                                    config, methodCreator.load(fullConfigName),
+                                    mpConfig, methodCreator.load(fullConfigName),
                                     methodCreator.loadClass(genericType.name().toString()));
                             createWriteValue(methodCreator, configObject, field, setter, useFieldAccess, setterValue);
                         } else {
                             // convert the String value and populate an Optional with it
                             ReadOptionalResponse readOptionalResponse = createReadOptionalValueAndConvertIfNeeded(
                                     fullConfigName,
-                                    genericType, field.declaringClass().name(), methodCreator, config);
+                                    genericType, field.declaringClass().name(), methodCreator, mpConfig);
                             createWriteValue(readOptionalResponse.getIsPresentTrue(), configObject, field, setter,
                                     useFieldAccess,
                                     readOptionalResponse.getIsPresentTrue().invokeStaticMethod(
@@ -329,7 +340,7 @@ private static ResultHandle populateConfigObject(ClassLoader classLoader, ClassI
 
                             ReadOptionalResponse readOptionalResponse = createReadOptionalValueAndConvertIfNeeded(
                                     fullConfigName,
-                                    fieldType, field.declaringClass().name(), methodCreator, config);
+                                    fieldType, field.declaringClass().name(), methodCreator, mpConfig);
 
                             // call the setter if the optional contained data
                             createWriteValue(readOptionalResponse.getIsPresentTrue(), configObject, field, setter,
@@ -342,7 +353,7 @@ private static ResultHandle populateConfigObject(ClassLoader classLoader, ClassI
                              */
                             ResultHandle setterValue = createReadMandatoryValueAndConvertIfNeeded(
                                     fullConfigName, fieldType,
-                                    field.declaringClass().name(), methodCreator, config);
+                                    field.declaringClass().name(), methodCreator, mpConfig);
                             createWriteValue(methodCreator, configObject, field, setter, useFieldAccess, setterValue);
 
                         }
@@ -382,6 +393,10 @@ private static ResultHandle populateConfigObject(ClassLoader classLoader, ClassI
         return configObject;
     }
 
+    private static String getFullConfigName(String prefixStr, ConfigProperties.NamingStrategy namingStrategy, FieldInfo field) {
+        return prefixStr + "." + namingStrategy.getName(field.name());
+    }
+
     private static void createWriteValue(BytecodeCreator bytecodeCreator, ResultHandle configObject, FieldInfo field,
             MethodInfo setter, boolean useFieldAccess, ResultHandle value) {
         if (useFieldAccess) {

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/configproperties/DotNames.java

@@ -22,6 +22,7 @@ private DotNames() {
     static final DotName LIST = DotName.createSimple(List.class.getName());
     static final DotName SET = DotName.createSimple(Set.class.getName());
     static final DotName COLLECTION = DotName.createSimple(Collection.class.getName());
+    static final DotName ENUM = DotName.createSimple(Enum.class.getName());
     static final DotName CONFIG_PROPERTIES = DotName.createSimple(ConfigProperties.class.getName());
     static final DotName CONFIG_PREFIX = DotName.createSimple(ConfigPrefix.class.getName());
     static final DotName CONFIG_PROPERTY = DotName.createSimple(ConfigProperty.class.getName());

extensions/arc/deployment/src/test/java/io/quarkus/arc/test/configproperties/ClassWithoutGettersConfigPropertiesTest.java

@@ -24,37 +24,32 @@ public class ClassWithoutGettersConfigPropertiesTest {
             .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
                     .addClasses(DummyBean.class, DummyProperties.class)
                     .addAsResource(new StringAsset(
-                            "dummy.name=quarkus\ndummy.numbers=1,2,3,4\ndummy.unused=whatever"),
+                            "dummy.name=quarkus\ndummy.my-enum=OPTIONAL\ndummy.numbers=1,2,3,4\ndummy.unused=whatever"),
                             "application.properties"));
 
     @Inject
     DummyBean dummyBean;
 
     @Test
     public void testConfiguredValues() {
-        assertEquals("quarkus", dummyBean.getName());
-        assertEquals(Arrays.asList(1, 2, 3, 4), dummyBean.getNumbers());
+        DummyProperties dummyProperties = dummyBean.dummyProperties;
+        assertEquals("quarkus", dummyProperties.name);
+        assertEquals(Arrays.asList(1, 2, 3, 4), dummyProperties.numbers);
+        assertEquals(MyEnum.OPTIONAL, dummyProperties.myEnum);
     }
 
     @Singleton
     public static class DummyBean {
         @Inject
         DummyProperties dummyProperties;
-
-        String getName() {
-            return dummyProperties.name;
-        }
-
-        List<Integer> getNumbers() {
-            return dummyProperties.numbers;
-        }
     }
 
     @ConfigProperties(prefix = "dummy")
     public static class DummyProperties {
 
         public String name;
         public List<Integer> numbers;
+        public MyEnum myEnum;
 
         public void setName(String name) {
             this.name = name;
@@ -64,4 +59,10 @@ public void setNumbers(List<Integer> numbers) {
             this.numbers = numbers;
         }
     }
+
+    public enum MyEnum {
+        OPTIONAL,
+        ENUM_ONE,
+        Enum_Two
+    }
 }