string-to-enum-conversion now works just by default

Signed-off-by: Daniel Kraschewski <[email protected]>

Author: Daniel Kraschewski

README.md

@@ -94,7 +94,7 @@ This order can be customized, see [§5 (Change the order in which annotations ar
 Fields don't have to be Strings. You can configure collection fields or even any type you wish (or a collection of that type).
 
 Some simple transformers are included and used by default, e.g. a String will automatically be converted to an integer, a
-boolean value or even a collection as needed.
+boolean value, an enum value, or even a collection as needed.
 
 If you need more complex transformers, you can also implement your own by extending the `TypeTransformer` class, and specifying them in the `@TypeTransformers` annotation.
 

src/main/java/com/tngtech/configbuilder/annotation/typetransformer/StringToEnumTypeTransformer.java

@@ -8,6 +8,11 @@ public StringToEnumTypeTransformer(Class<E> enumClass) {
         this.enumClass = enumClass;
     }
 
+    @Override
+    public boolean isMatching(Class<?> sourceClass, Class<?> targetClass) {
+        return sourceClass.equals(String.class) && targetClass.equals(enumClass);
+    }
+
     @Override
     public E transform(final String value) {
         return E.valueOf(enumClass, value.trim().replace(' ', '_').toUpperCase());

src/main/java/com/tngtech/configbuilder/util/EnumTypeExtractor.java

@@ -0,0 +1,23 @@
+package com.tngtech.configbuilder.util;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.stream;
+
+public class EnumTypeExtractor {
+
+    Stream<Class<? extends Enum<?>>> getEnumTypesRelevantFor(Type type) {
+        if (type instanceof Class && ((Class<?>) type).isEnum()) {
+            return Stream.of((Class<? extends Enum<?>>) type);
+        }
+        if (type instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            return stream(parameterizedType.getActualTypeArguments())
+                    .flatMap(this::getEnumTypesRelevantFor)
+                    .distinct();
+        }
+        return Stream.empty();
+    }
+}

src/main/java/com/tngtech/configbuilder/util/FieldValueTransformer.java

@@ -20,6 +20,7 @@ public class FieldValueTransformer {
     private final ConfigBuilderFactory configBuilderFactory;
     private final ErrorMessageSetup errorMessageSetup;
     private final GenericsAndCastingHelper genericsAndCastingHelper;
+    private final EnumTypeExtractor enumTypeExtractor;
     private Object[] additionalOptions;
 
     //Order is important: Prefer List over Set if both apply!
@@ -38,6 +39,7 @@ public FieldValueTransformer(ConfigBuilderFactory configBuilderFactory) {
         this.configBuilderFactory = configBuilderFactory;
         this.errorMessageSetup = configBuilderFactory.getInstance(ErrorMessageSetup.class);
         this.genericsAndCastingHelper = configBuilderFactory.getInstance(GenericsAndCastingHelper.class);
+        this.enumTypeExtractor = configBuilderFactory.getInstance(EnumTypeExtractor.class);
     }
 
     public Object transformFieldValue(Field field, Object sourceValue) {
@@ -51,6 +53,10 @@ private void initialize(Field field) {
         for(Class<? extends TypeTransformer> transformerClass : getAllTransformers(field)) {
             availableTransformers.add(configBuilderFactory.getInstance(transformerClass));
         }
+        enumTypeExtractor.getEnumTypesRelevantFor(field.getGenericType())
+                .map(enumClass -> new StringToEnumTypeTransformer(enumClass))
+                .forEach(availableTransformers::add);
+
         additionalOptions = field.isAnnotationPresent(Separator.class)? new Object[]{field.getAnnotation(Separator.class).value()} : new Object[]{","};
     }
 

src/test/java/com/tngtech/configbuilder/annotation/typetransformer/StringToEnumTypeTransformerTest.java

@@ -51,6 +51,5 @@ public void testTransform() {
     public void testIsMatching() {
         assertThat(transformer.isMatching(String.class, TestEnum.class)).isTrue();
         assertThat(transformer.isMatching(String.class, Integer.class)).isFalse();
-        assertThat(transformer.isMatching(String.class, Enum.class)).isTrue();
     }
 }

src/test/java/com/tngtech/configbuilder/util/EnumTypeExtractorTest.java

@@ -0,0 +1,71 @@
+package com.tngtech.configbuilder.util;
+
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EnumTypeExtractorTest {
+
+    enum TestEnum1 {}
+
+    enum TestEnum2 {}
+
+    public static class TestClass {
+
+        String simpleNonEnumField;
+        Map<Integer, String> nonEnumParameterizedField;
+
+        TestEnum1 simpleEnumField;
+        Map<TestEnum1, TestEnum2> fieldWithEnumTypeParameters;
+        Map<TestEnum1, List<TestEnum2>> fieldWithNestedEnumTypeParameters;
+        Map<TestEnum1, Map<TestEnum1, TestEnum1>> fieldWithRepeatedEnumTypeParameter;
+    }
+
+    private final EnumTypeExtractor enumTypeExtractor = new EnumTypeExtractor();
+
+    @Test
+    public void testExtractionOnSimpleNonEnumType() throws Exception {
+        Field simpleNonEnumField = TestClass.class.getDeclaredField("simpleNonEnumField");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(simpleNonEnumField.getGenericType()))
+                .isEmpty();
+    }
+
+    @Test
+    public void testExtractionOnNonEnumParameterizedType() throws Exception {
+        Field nonEnumParameterizedField = TestClass.class.getDeclaredField("nonEnumParameterizedField");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(nonEnumParameterizedField.getGenericType()))
+                .isEmpty();
+    }
+
+    @Test
+    public void testExtractionOfSimpleEnumType() throws Exception {
+        Field simpleEnumField = TestClass.class.getDeclaredField("simpleEnumField");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(simpleEnumField.getGenericType()))
+                .containsExactly(TestEnum1.class);
+    }
+
+    @Test
+    public void testExtractionOfEnumTypeParameters() throws Exception {
+        Field fieldWithEnumTypeParameters = TestClass.class.getDeclaredField("fieldWithEnumTypeParameters");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(fieldWithEnumTypeParameters.getGenericType()))
+                .containsExactlyInAnyOrder(TestEnum1.class, TestEnum2.class);
+    }
+
+    @Test
+    public void testExtractionOfNestedEnumTypeParameters() throws Exception {
+        Field fieldWithNestedEnumTypeParameters = TestClass.class.getDeclaredField("fieldWithNestedEnumTypeParameters");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(fieldWithNestedEnumTypeParameters.getGenericType()))
+                .containsExactlyInAnyOrder(TestEnum1.class, TestEnum2.class);
+    }
+
+    @Test
+    public void testExtractedEnumTypesAreDeduplicated() throws Exception {
+        Field fieldWithRepeatedEnumTypeParameter = TestClass.class.getDeclaredField("fieldWithRepeatedEnumTypeParameter");
+        assertThat(enumTypeExtractor.getEnumTypesRelevantFor(fieldWithRepeatedEnumTypeParameter.getGenericType()))
+                .containsExactly(TestEnum1.class);
+    }
+}

src/test/java/com/tngtech/configbuilder/util/FieldValueTransformerComponentTest.java

@@ -1,7 +1,6 @@
 package com.tngtech.configbuilder.util;
 
 import com.tngtech.configbuilder.annotation.typetransformer.*;
-import com.tngtech.configbuilder.configuration.BuilderConfiguration;
 import com.tngtech.configbuilder.configuration.ErrorMessageSetup;
 import com.tngtech.configbuilder.exception.PrimitiveParsingException;
 import org.junit.Before;
@@ -14,30 +13,31 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Set;
 
 import static com.google.common.collect.Lists.newArrayList;
+import static com.tngtech.configbuilder.util.FieldValueTransformerComponentTest.TestEnum.BAR;
+import static com.tngtech.configbuilder.util.FieldValueTransformerComponentTest.TestEnum.FOO;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
 public class FieldValueTransformerComponentTest {
 
-    public class TestTransformer extends TypeTransformer<String, Integer> {
+    public static class TestTransformer extends TypeTransformer<String, Integer> {
         @Override
         public Integer transform(String argument) {
             return 1472;
         }
     }
 
-    public static class AnotherTestTransformer extends TypeTransformer<String, Integer> {
-        @Override
-        public Integer transform(String argument) {
-            return 1472;
-        }
+    enum TestEnum {
+        FOO, BAR
     }
 
-    private class TestConfigClass {
+    private static class TestConfigClass {
 
         @TypeTransformers({CharacterSeparatedStringToStringListTransformer.class})
         private Collection<String> stringCollectionField;
@@ -46,36 +46,38 @@ private class TestConfigClass {
         private Boolean boolField;
         @TypeTransformers({TestTransformer.class})
         private int otherIntField;
-        @TypeTransformers({AnotherTestTransformer.class})
-        private Integer integerField;
         private Collection<Path> pathCollectionField;
         private Collection<Integer> integerCollectionField;
         private Collection<Object> objectCollectionField;
+        private TestEnum enumField;
+        private List<TestEnum> enumListField;
+        private Set<TestEnum> enumSetField;
     }
 
     @Mock
     private ConfigBuilderFactory configBuilderFactory;
     @Mock
     private ErrorMessageSetup errorMessageSetup;
-    @Mock
-    private BuilderConfiguration builderConfiguration;
+
+    private FieldValueTransformer fieldValueTransformer;
 
     private Field stringCollectionField;
     private Field intField;
     private Field doubleField;
     private Field boolField;
     private Field otherIntField;
-    private Field integerField;
     private Field pathCollectionField;
     private Field integerCollectionField;
     private Field objectCollectionField;
-
-    private FieldValueTransformer fieldValueTransformer;
+    private Field enumField;
+    private Field enumListField;
+    private Field enumSetField;
 
     @Before
     public void setUp() throws Exception {
         when(configBuilderFactory.getInstance(ErrorMessageSetup.class)).thenReturn(errorMessageSetup);
         when(configBuilderFactory.getInstance(GenericsAndCastingHelper.class)).thenReturn(new GenericsAndCastingHelper());
+        when(configBuilderFactory.getInstance(EnumTypeExtractor.class)).thenReturn(new EnumTypeExtractor());
 
         when(configBuilderFactory.getInstance(CharacterSeparatedStringToStringListTransformer.class)).thenReturn(new CharacterSeparatedStringToStringListTransformer());
         when(configBuilderFactory.getInstance(CharacterSeparatedStringToStringSetTransformer.class)).thenReturn(new CharacterSeparatedStringToStringSetTransformer());
@@ -86,23 +88,25 @@ public void setUp() throws Exception {
         when(configBuilderFactory.getInstance(StringOrPrimitiveToPrimitiveTransformer.class)).thenReturn(new StringOrPrimitiveToPrimitiveTransformer());
         when(configBuilderFactory.getInstance(TestTransformer.class)).thenReturn(new TestTransformer());
 
+        this.fieldValueTransformer = new FieldValueTransformer(configBuilderFactory);
+
         stringCollectionField = TestConfigClass.class.getDeclaredField("stringCollectionField");
         intField = TestConfigClass.class.getDeclaredField("intField");
         boolField = TestConfigClass.class.getDeclaredField("boolField");
         otherIntField = TestConfigClass.class.getDeclaredField("otherIntField");
-        integerField = TestConfigClass.class.getDeclaredField("integerField");
         pathCollectionField = TestConfigClass.class.getDeclaredField("pathCollectionField");
         integerCollectionField = TestConfigClass.class.getDeclaredField("integerCollectionField");
         doubleField = TestConfigClass.class.getDeclaredField("doubleField");
         objectCollectionField = TestConfigClass.class.getDeclaredField("objectCollectionField");
-
-        this.fieldValueTransformer = new FieldValueTransformer(configBuilderFactory);
+        enumField = TestConfigClass.class.getDeclaredField("enumField");
+        enumListField = TestConfigClass.class.getDeclaredField("enumListField");
+        enumSetField = TestConfigClass.class.getDeclaredField("enumSetField");
     }
 
     @Test
     public void testTransformingStringToStringCollection() {
-        List<String> actualResult = (List<String>) fieldValueTransformer.transformFieldValue(stringCollectionField, "Alpha,Beta,Gamma");
-        assertThat(actualResult).containsExactly("Alpha", "Beta", "Gamma");
+        Object actualResult = fieldValueTransformer.transformFieldValue(stringCollectionField, "Alpha,Beta,Gamma");
+        assertThat(actualResult).isEqualTo(newArrayList("Alpha", "Beta", "Gamma"));
     }
 
     @Test
@@ -136,25 +140,43 @@ public void testThatTransformersInAnnotationArePrioritized() {
 
     @Test
     public void testTransformingStringToPathCollection() {
-        Collection<Path> actualResult = (Collection<Path>) fieldValueTransformer.transformFieldValue(pathCollectionField, "/etc,/usr");
+        Object actualResult = fieldValueTransformer.transformFieldValue(pathCollectionField, "/etc,/usr");
         assertThat(actualResult).isEqualTo(newArrayList(Paths.get("/etc"), Paths.get("/usr")));
     }
 
     @Test
     public void testTransformingStringToIntegerCollection() {
-        Collection<Integer> actualResult = (Collection<Integer>) fieldValueTransformer.transformFieldValue(integerCollectionField, "3,4");
+        Object actualResult = fieldValueTransformer.transformFieldValue(integerCollectionField, "3,4");
         assertThat(actualResult).isEqualTo(newArrayList(3, 4));
     }
 
     @Test
     public void testTransformingStringToObjectCollection() {
-        Collection<Object> actualResult = (Collection<Object>) fieldValueTransformer.transformFieldValue(objectCollectionField, "someString,anotherString");
+        Object actualResult = fieldValueTransformer.transformFieldValue(objectCollectionField, "someString,anotherString");
         assertThat(actualResult).isEqualTo(newArrayList("someString", "anotherString"));
     }
 
+    @Test
+    public void testTransformingStringToEnum() {
+        Object actualResult = fieldValueTransformer.transformFieldValue(enumField, "FOO");
+        assertThat(actualResult).isEqualTo(FOO);
+    }
+
+    @Test
+    public void testTransformingStringToEnumList() {
+        Object actualResult = fieldValueTransformer.transformFieldValue(enumListField, "FOO, BAR, FOO");
+        assertThat(actualResult).isEqualTo(newArrayList(FOO, BAR, FOO));
+    }
+
+    @Test
+    public void testTransformingStringToEnumSet() {
+        Object actualResult = fieldValueTransformer.transformFieldValue(enumSetField, "BAR, FOO");
+        assertThat(actualResult).isEqualTo(EnumSet.of(BAR, FOO));
+    }
+
     @Test
     public void testThatValueTransformerIgnoresNull() {
-        Collection<Path> actualResult = (Collection<Path>) fieldValueTransformer.transformFieldValue(pathCollectionField, null);
+        Object actualResult = fieldValueTransformer.transformFieldValue(pathCollectionField, null);
         assertThat(actualResult).isNull();
     }
-}
+}

src/test/java/com/tngtech/configbuilder/util/FieldValueTransformerTest.java

@@ -36,6 +36,8 @@ public class FieldValueTransformerTest {
     @Mock
     private GenericsAndCastingHelper genericsAndCastingHelper;
     @Mock
+    private EnumTypeExtractor enumTypeExtractor;
+    @Mock
     private CollectionToArrayListTransformer collectionToArrayListTransformer;
     @Mock
     private CharacterSeparatedStringToStringListTransformer characterSeparatedStringToStringListTransformer;
@@ -59,6 +61,7 @@ public class FieldValueTransformerTest {
     public void setUp() throws Exception {
         when(configBuilderFactory.getInstance(ErrorMessageSetup.class)).thenReturn(errorMessageSetup);
         when(configBuilderFactory.getInstance(GenericsAndCastingHelper.class)).thenReturn(genericsAndCastingHelper);
+        when(configBuilderFactory.getInstance(EnumTypeExtractor.class)).thenReturn(enumTypeExtractor);
 
         fieldValueTransformer = new FieldValueTransformer(configBuilderFactory);
         field = this.getClass().getDeclaredField("testField");