Feature/issue #13 default mapping strategy

src/main/java/be/archilios/open/domainmapper/DomainMapper.java

@@ -28,27 +28,41 @@ public <T, V> T map(V source, Class<T> targetClass) {
         }
     }
 
-    private <T, V> T tryMap(V Source, Class<T> targetClass) throws Exception {
+    private <T, V> T tryMap(V source, Class<T> targetClass) throws Exception {
         T result = targetClass.getDeclaredConstructor().newInstance();
 
-        Field[] sourceFields = Source.getClass().getDeclaredFields();
+        Field[] sourceFields = source.getClass().getDeclaredFields();
         Field[] targetFields = targetClass.getDeclaredFields();
 
+        mapFields(source, sourceFields, targetFields, result);
+        handleEmptyFields(targetFields, result);
+
+        if (getActiveMappingStrategy() == MappingStrategyPattern.STRICT) {
+            throw new MappingException("Could not map " + source.getClass().getSimpleName() + " to " + targetClass.getSimpleName() + " because of possible missing fields");
+        }
+
+        return result;
+    }
+
+    private static <T, V> void mapFields(V source, Field[] sourceFields, Field[] targetFields, T result) throws IllegalAccessException {
         for (Field sourceField : sourceFields) {
             for (Field targetField : targetFields) {
                 if (sourceField.getName().equals(targetField.getName())) {
                     sourceField.setAccessible(true);
                     targetField.setAccessible(true);
-                    targetField.set(result, sourceField.get(Source));
+                    targetField.set(result, sourceField.get(source));
                 }
             }
         }
-
-        if (getActiveMappingStrategy() == MappingStrategyPattern.STRICT) {
-            throw new MappingException("Could not map " + Source.getClass().getSimpleName() + " to " + targetClass.getSimpleName() + " because of possible missing fields");
+    }
+
+    private <T> void handleEmptyFields(Field[] targetFields, T result) throws IllegalAccessException {
+        for (Field targetField : targetFields) {
+            if (!targetField.canAccess(result)) {
+                targetField.setAccessible(true);
+                targetField.set(result, mappingStrategy.handleEmptyField(targetField.getType()));
+            }
         }
-
-        return result;
     }
-
+    
 }

src/main/java/be/archilios/open/domainmapper/config/MappingStrategyPattern.java

@@ -1,6 +1,19 @@
 package be.archilios.open.domainmapper.config;
 
+import be.archilios.open.domainmapper.strategies.EmptyFieldStrategy;
+
 public enum MappingStrategyPattern {
-    LOOSELY,
-    STRICT
+    LOOSELY(new EmptyFieldStrategy.EmptyFieldLooseStrategy()),
+    STRICT(new EmptyFieldStrategy.EmptyFieldStrictStrategy()),
+    DEFAULT(new EmptyFieldStrategy.EmptyFieldDefaultStrategy());
+
+    private final EmptyFieldStrategy emptyFieldStrategy;
+
+    MappingStrategyPattern(EmptyFieldStrategy emptyFieldStrategy) {
+        this.emptyFieldStrategy = emptyFieldStrategy;
+    }
+
+    public Object handleEmptyField(Class<?> clazz) {
+        return emptyFieldStrategy.handle(clazz);
+    }
 }

src/main/java/be/archilios/open/domainmapper/strategies/EmptyFieldStrategy.java

@@ -0,0 +1,46 @@
+package be.archilios.open.domainmapper.strategies;
+
+import be.archilios.open.domainmapper.exceptions.MappingException;
+
+public sealed interface EmptyFieldStrategy {
+
+    <T> T handle(Class<T> clazz);
+
+    final class EmptyFieldDefaultStrategy implements EmptyFieldStrategy {
+        @Override
+        public <T> T handle(Class<T> clazz) {
+            if (clazz.isPrimitive()) {
+                EmptyFieldStrategy looseStrategy = new EmptyFieldLooseStrategy();
+                return looseStrategy.handle(clazz);
+            }
+            throw new MappingException("Mapping not allowed because no default is know for empty field of type " + clazz.getSimpleName() + ", strategy DEFAULT requires default value to be declared when empty");
+        }
+    }
+
+    final class EmptyFieldLooseStrategy implements EmptyFieldStrategy {
+        @Override
+        public <T> T handle(Class<T> clazz) {
+            if (clazz.isPrimitive()) {
+                return switch (clazz.getSimpleName()) {
+                    case "boolean" -> (T) Boolean.FALSE;
+                    case "byte" -> (T) Byte.valueOf("0");
+                    case "short" -> (T) Short.valueOf("0");
+                    case "int" -> (T) Integer.valueOf("0");
+                    case "long" -> (T) Long.valueOf("0");
+                    case "float" -> (T) Float.valueOf("0");
+                    case "double" -> (T) Double.valueOf("0");
+                    case "char" -> (T) Character.valueOf('\u0000');
+                    default -> throw new IllegalStateException("Unexpected value: " + clazz.getSimpleName());
+                };
+            }
+            return null;
+        }
+    }
+
+    final class EmptyFieldStrictStrategy implements EmptyFieldStrategy {
+        @Override
+        public <T> T handle(Class<T> clazz) {
+            throw new MappingException("Mapping not allowed because of empty field with type " + clazz.getSimpleName() + " and strategy STRICT");
+        }
+    }
+}

src/test/java/be/archilios/open/domainmapper/ConfigureMappingStrategiesTest.java

@@ -0,0 +1,38 @@
+package be.archilios.open.domainmapper;
+
+import be.archilios.open.domainmapper.config.MappingStrategyPattern;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ConfigureMappingStrategiesTest {
+
+    @Test
+    void DefaultsToLooseStrategy() {
+        DomainMapper mapper = new DomainMapper();
+
+        assertEquals(MappingStrategyPattern.LOOSELY, mapper.getActiveMappingStrategy());
+    }
+
+    @Test
+    void CanSetLooseStrategy() {
+        DomainMapper mapper = new DomainMapper(MappingStrategyPattern.LOOSELY);
+
+        assertEquals(MappingStrategyPattern.LOOSELY, mapper.getActiveMappingStrategy());
+    }
+
+    @Test
+    void CanSetStrictStrategy() {
+        DomainMapper mapper = new DomainMapper(MappingStrategyPattern.STRICT);
+
+        assertEquals(MappingStrategyPattern.STRICT, mapper.getActiveMappingStrategy());
+    }
+
+    @Test
+    void canSetDefaultStrategy() {
+        DomainMapper mapper = new DomainMapper(MappingStrategyPattern.DEFAULT);
+
+        assertEquals(MappingStrategyPattern.DEFAULT, mapper.getActiveMappingStrategy());
+    }
+
+}

src/test/java/be/archilios/open/domainmapper/MapWithDefaultStrategyTest.java

@@ -0,0 +1,64 @@
+package be.archilios.open.domainmapper;
+
+import be.archilios.open.domainmapper.config.MappingStrategyPattern;
+import be.archilios.open.domainmapper.data.PrimitiveOnlyData;
+import be.archilios.open.domainmapper.data.PrimitiveOnlyDataMother;
+import be.archilios.open.domainmapper.data.PrimitiveOnlyDataReceiver;
+import be.archilios.open.domainmapper.data.PrimitiveOnlyRecord;
+import be.archilios.open.domainmapper.exceptions.MappingException;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class MapWithDefaultStrategyTest {
+    private final DomainMapper mapper = new DomainMapper(MappingStrategyPattern.DEFAULT);
+    @Test
+    void primitiveObjectToPrimitiveObject() {
+        PrimitiveOnlyData source = PrimitiveOnlyDataMother.data().buildObject();
+
+        PrimitiveOnlyDataReceiver destination = mapper.map(source, PrimitiveOnlyDataReceiver.class);
+
+        assertEquals(source.getName(), destination.getName(), "Name should be mapped");
+        assertEquals(source.getAge(), destination.getAge(), "Age should be mapped");
+        assertEquals(source.isAdult(), destination.isAdult(), "Adult should be mapped");
+        assertEquals(0, destination.getId(), "Id should be mapped to default value");
+    }
+
+    @Test
+    void primitiveObjectToItself() {
+        final String changedName = "Dear";
+        PrimitiveOnlyData source = PrimitiveOnlyDataMother.data().withName(changedName).buildObject();
+
+        PrimitiveOnlyData destination = mapper.map(source, PrimitiveOnlyData.class);
+
+        assertEquals(changedName, destination.getName(), "Name should be correctly mapped");
+    }
+
+    @Test
+    void primitiveRecordToPrimitiveObject() {
+        PrimitiveOnlyRecord source = PrimitiveOnlyDataMother.data().buildRecord();
+
+        PrimitiveOnlyData destination = mapper.map(source, PrimitiveOnlyData.class);
+
+        assertEquals(source.name(), destination.getName(), "Name should be mapped");
+        assertEquals(source.age(), destination.getAge(), "Age should be mapped");
+        assertEquals(source.isAdult(), destination.isAdult(), "isAdult should be mapped");
+        assertEquals(0, destination.getHeight(), "Height should be mapped to default value");
+    }
+
+    @Test
+    void primitiveObjectToPrimitiveRecord() {
+        PrimitiveOnlyData source = PrimitiveOnlyDataMother.data().buildObject();
+
+        assertThrows(MappingException.class, () -> mapper.map(source, PrimitiveOnlyRecord.class));
+    }
+
+    @Test
+    void primitiveRecordToItself() {
+        final String changedName = "Dear";
+        PrimitiveOnlyRecord source = PrimitiveOnlyDataMother.data().withName(changedName).buildRecord();
+
+        assertThrows(MappingException.class, () -> mapper.map(source, PrimitiveOnlyRecord.class));
+    }
+}