<master> Merge branch 'feature/nested_field'

devindi · devindi · commit 91c9723b04f4 · 2017-09-16T20:59:22.000+03:00
diff --git a/processor/src/main/java/com/devindi/mapper/MapperGenerator.java b/processor/src/main/java/com/devindi/mapper/MapperGenerator.java
@@ -2,6 +2,8 @@
 
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 
 import java.util.ArrayList;
@@ -16,7 +18,6 @@
 import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.ElementFilter;
 import javax.tools.Diagnostic;
@@ -34,12 +35,14 @@ static MapperGenerator create(TypeElement element, ProcessingEnvironment env) {
 
     private final TypeElement element;
     private final ProcessingEnvironment processingEnv;
-    private List<Mapping> mappings;
+    private List<MappingInfo> mappings;
+    private List<MappingInfo> autoMappings;
 
     private MapperGenerator(TypeElement mapperElement, ProcessingEnvironment processingEnvironment) {
         this.processingEnv = processingEnvironment;
         this.element = mapperElement;
         mappings = new ArrayList<>();
+        autoMappings = new ArrayList<>();
     }
 
     public TypeSpec generate() {
@@ -49,85 +52,93 @@ public TypeSpec generate() {
                 .addModifiers(Modifier.PUBLIC)
                 .addSuperinterface(ClassName.get(element));
 
-        for (Mapping mapping : mappings) {
+        for (MappingInfo mapping : mappings) {
             MethodSpec methodSpec = generateMappingMethod(mapping);
             implBuilder.addMethod(methodSpec);
         }
 
+        for (MappingInfo autoMapping : autoMappings) {
+            MethodSpec methodSpec = generateMappingMethod(autoMapping);
+            implBuilder.addMethod(methodSpec);
+        }
+
+
         return implBuilder.build();
     }
 
     private void collectMappings() {
         for (ExecutableElement method : ElementFilter.methodsIn(element.getEnclosedElements())) {
             try {
-                mappings.add(new Mapping(method));
+                mappings.add(new MappingInfo(method));
             } catch (IllegalArgumentException exc) {
                 processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, exc.getMessage(), method);
             }
         }
     }
 
-    private MethodSpec generateMappingMethod(Mapping mapping) {
-        ExecutableElement constructorElement = getConstructorElement(mapping.target.toString());
+    private MethodSpec generateMappingMethod(MappingInfo mapping) {
+        ExecutableElement constructorElement = getConstructorElement(mapping.getTargetType().toString());
         List<? extends VariableElement> constructorParameters = constructorElement.getParameters();
 
-        Map<String, ExecutableElement> argumentGetters = getGetters(mapping.source.toString());
+        Map<String, ExecutableElement> argumentGetters = getGetters(mapping.getSourceType().toString());
 
 
         if (constructorParameters.size() != argumentGetters.size()) {
-            processingEnv.getMessager().printMessage(Diagnostic.Kind.MANDATORY_WARNING, "Target constructor have different arguments count", mapping.method);
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.MANDATORY_WARNING, "Target constructor have different arguments count", mapping.getMethod());
         }
 
-        MethodSpec.Builder methodBuilder = MethodSpec.overriding(mapping.method);
+
+        MethodSpec.Builder methodBuilder = createMethodBuilder(mapping);
         StringBuilder statementBuilder = new StringBuilder();
         statementBuilder
                 .append("return new ")
-                .append(mapping.target.toString())
+                .append(mapping.getTargetType().toString())
                 .append("(");
 
         String separator = "";
         for (VariableElement constructorParameter : constructorParameters) {
-            String sourceFieldName = constructorParameter.getSimpleName().toString().toLowerCase();
-            com.devindi.mapper.Mapping annotation = mapping.method.getAnnotation(com.devindi.mapper.Mapping.class);
-            if (annotation != null && annotation.target().toLowerCase().equals(constructorParameter.getSimpleName().toString().toLowerCase())) {
-                sourceFieldName = annotation.source();
-            }
-            Mappings mappings = mapping.method.getAnnotation(Mappings.class);
-            if (mappings != null) {
-                for (com.devindi.mapper.Mapping fieldMapping : mappings.value()) {
-                    if (fieldMapping != null && fieldMapping.target().toLowerCase().equals(constructorParameter.getSimpleName().toString().toLowerCase())) {
-                        sourceFieldName = fieldMapping.source();
-                    }
-                }
-            }
+            String sourceFieldName = mapping.getSourceFieldName(constructorParameter.getSimpleName().toString().toLowerCase());
             ExecutableElement getter = argumentGetters.get(sourceFieldName.toLowerCase());
             if (getter == null) {
                 processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Failed to find getter at source for target field", constructorParameter);
                 return null;
             }
             if (!constructorParameter.asType().equals(getter.getReturnType())) {
                 //getter and constructor parameter have different types
-                // TODO: 01.09.17 try to map/convert source field to target field
-                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Getter return type and constructor argument type are different", mapping.method);
+                MappingInfo depMapping = findMapping(getter.getReturnType(), constructorParameter.asType());
+                if (depMapping == null) {
+                    depMapping = new MappingInfo(getter.getReturnType(), constructorParameter.asType());
+                    autoMappings.add(depMapping);
+                }
+                statementBuilder
+                        .append(separator)
+                        .append('\n')
+                        .append("this.")
+                        .append(depMapping.getMethodName())
+                        .append("(")
+                        .append(mapping.getSourceName())
+                        .append(".")
+                        .append(getter.getSimpleName())
+                        .append("()")
+                        .append(")");
+                separator = ",";
+            } else {
+                statementBuilder
+                        .append(separator)
+                        .append('\n')
+                        .append(mapping.getSourceName())
+                        .append(".")
+                        .append(getter.getSimpleName())
+                        .append("()");
+                separator = ",";
             }
-
-            statementBuilder
-                    .append(separator)
-                    .append('\n')
-                    .append(mapping.method.getParameters().get(0).getSimpleName())
-                    .append(".")
-                    .append(getter.getSimpleName())
-                    .append("()");
-            separator = ",";
         }
 
         statementBuilder
                 .append('\n')
                 .append(")");
         methodBuilder.addStatement(statementBuilder.toString());
 
-
-
         return methodBuilder.build();
     }
 
@@ -151,24 +162,24 @@ private Map<String, ExecutableElement> getGetters(String className) {
         return gettersMap;
     }
 
-    private static class Mapping {
-        private final TypeMirror source;
-        private final TypeMirror target;
-        private final ExecutableElement method;
-
-        public Mapping(ExecutableElement method) {
-            this.method = method;
-            target = method.getReturnType();
-            if (target.getKind().equals(TypeKind.VOID)) {
-                throw new IllegalArgumentException("Mapper method should return value. Method will be ignored");
+    private MappingInfo findMapping(TypeMirror source, TypeMirror target) {
+        for (MappingInfo mapping : mappings) {
+            if (mapping.getSourceType().equals(source) && mapping.getTargetType().equals(target)) {
+                return mapping;
             }
-            List<? extends VariableElement> parameters = method.getParameters();
-            if (parameters.size() != 1) {
-                throw new IllegalArgumentException("Mapper method should have only 1 parameter. Method will be ignored");
-            }
-            source = parameters.get(0).asType();
         }
+        return null;
     }
 
-
+    private MethodSpec.Builder createMethodBuilder(MappingInfo info) {
+        ExecutableElement method = info.getMethod();
+        if (method == null) {
+            MethodSpec.Builder builder = MethodSpec.methodBuilder(info.getMethodName().toString());
+            builder.addModifiers(Modifier.PRIVATE);
+            builder.returns(TypeName.get(info.getTargetType()));
+            builder.addParameter(ParameterSpec.builder(TypeName.get(info.getSourceType()), "source").build());
+            return builder;
+        }
+        return MethodSpec.overriding(method);
+    }
 }
diff --git a/processor/src/main/java/com/devindi/mapper/MappingInfo.java b/processor/src/main/java/com/devindi/mapper/MappingInfo.java
@@ -0,0 +1,80 @@
+package com.devindi.mapper;
+
+import java.util.List;
+
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+public class MappingInfo {
+
+    private final TypeMirror sourceType;
+    private final TypeMirror targetType;
+    private final ExecutableElement method;
+    private final CharSequence sourceName;
+    private final CharSequence mappingName;
+
+    public MappingInfo(ExecutableElement method) {
+        targetType = method.getReturnType();
+        if (targetType.getKind().equals(TypeKind.VOID)) {
+            throw new IllegalArgumentException("Mapper method should return value. Method will be ignored");
+        }
+        List<? extends VariableElement> parameters = method.getParameters();
+        if (parameters.size() != 1) {
+            throw new IllegalArgumentException("Mapper method should have only 1 parameter. Method will be ignored");
+        }
+        sourceType = parameters.get(0).asType();
+        sourceName = parameters.get(0).getSimpleName();
+        mappingName = method.getSimpleName();
+        this.method = method;
+    }
+
+    public MappingInfo(TypeMirror source, TypeMirror target) {
+        sourceType = source;
+        targetType = target;
+        this.sourceName = "source";
+        mappingName = "convert";
+        method = null;
+    }
+
+    public TypeMirror getSourceType() {
+        return sourceType;
+    }
+
+    public TypeMirror getTargetType() {
+        return targetType;
+    }
+
+    public ExecutableElement getMethod() {
+        return method;
+    }
+
+    public CharSequence getMethodName() {
+        return mappingName;
+    }
+
+    public CharSequence getSourceName() {
+        return sourceName;
+    }
+
+    public String getSourceFieldName(String defaultName) {
+        if (method == null) {
+            return defaultName;
+        }
+        com.devindi.mapper.Mapping annotation = method.getAnnotation(com.devindi.mapper.Mapping.class);
+        if (annotation != null && annotation.target().toLowerCase().equals(defaultName)) {
+            return annotation.source();
+        }
+        Mappings mappings = method.getAnnotation(Mappings.class);
+        if (mappings != null) {
+            for (com.devindi.mapper.Mapping fieldMapping : mappings.value()) {
+                if (fieldMapping != null && fieldMapping.target().toLowerCase().equals(defaultName)) {
+                    return fieldMapping.source();
+                }
+            }
+        }
+        return defaultName;
+    }
+}
diff --git a/sample/src/main/java/com/example/nested/AutoDriverMapper.java b/sample/src/main/java/com/example/nested/AutoDriverMapper.java
@@ -0,0 +1,10 @@
+package com.example.nested;
+
+import com.devindi.mapper.Mapper;
+import com.devindi.mapper.Mapping;
+
+@Mapper
+public interface AutoDriverMapper {
+    @Mapping(source = "license", target = "licenseDto")
+    DriverDto toDto(Driver d);
+}
diff --git a/sample/src/main/java/com/example/nested/Driver.java b/sample/src/main/java/com/example/nested/Driver.java
@@ -0,0 +1,26 @@
+package com.example.nested;
+
+public class Driver {
+
+    private final String name;
+    private final int age;
+    private final DriverLicense license;
+
+    public Driver(int age, String name, DriverLicense license) {
+        this.name = name;
+        this.age = age;
+        this.license = license;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public DriverLicense getLicense() {
+        return license;
+    }
+}
diff --git a/sample/src/main/java/com/example/nested/DriverDto.java b/sample/src/main/java/com/example/nested/DriverDto.java
@@ -0,0 +1,47 @@
+package com.example.nested;
+
+public class DriverDto {
+
+    private String name;
+    private int age;
+    private LicenseDto licenseDto;
+
+    public DriverDto(String name, int age, LicenseDto licenseDto) {
+        this.name = name;
+        this.age = age;
+        this.licenseDto = licenseDto;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public LicenseDto getLicenseDto() {
+        return licenseDto;
+    }
+
+    public void setLicenseDto(LicenseDto licenseDto) {
+        this.licenseDto = licenseDto;
+    }
+
+    @Override
+    public String toString() {
+        return "DriverDto{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                ", licenseDto=" + licenseDto +
+                '}';
+    }
+}
diff --git a/sample/src/main/java/com/example/nested/DriverLicense.java b/sample/src/main/java/com/example/nested/DriverLicense.java
@@ -0,0 +1,27 @@
+package com.example.nested;
+
+import java.util.Date;
+
+public class DriverLicense {
+    private final String id;
+    private final String photoUrl;
+    private final Date validUntil;
+
+    public DriverLicense(String id, String photoUrl, Date validUntil) {
+        this.id = id;
+        this.photoUrl = photoUrl;
+        this.validUntil = validUntil;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getPhotoUrl() {
+        return photoUrl;
+    }
+
+    public Date getValidUntil() {
+        return validUntil;
+    }
+}
diff --git a/sample/src/main/java/com/example/nested/DriverMapper.java b/sample/src/main/java/com/example/nested/DriverMapper.java
diff --git a/sample/src/main/java/com/example/nested/LicenseDto.java b/sample/src/main/java/com/example/nested/LicenseDto.java
diff --git a/sample/src/test/java/com/example/nested/DriverMapperTest.java b/sample/src/test/java/com/example/nested/DriverMapperTest.java
