The @EnumMappers annotation will now ignore duplicate enums.

Martin · Martin · commit 6ef832a0180d · 2017-05-30T12:45:11.000+02:00
This fixes #3
diff --git a/.gitignore b/.gitignore
@@ -51,6 +51,6 @@ fabric.properties
 .gradle
 /local.properties
 .DS_Store
-**/build
+build/
 /captures
 .externalNativeBuild
diff --git a/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapAllEnumsHandler.java b/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapAllEnumsHandler.java
@@ -18,9 +18,13 @@
 import com.google.auto.common.MoreElements;
 import com.google.auto.common.MoreTypes;
 import com.google.common.base.Optional;
+import com.google.common.collect.ArrayListMultimap;
 import com.tmtron.enums.EnumMappers;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.AnnotationMirror;
@@ -37,47 +41,102 @@ class MapAllEnumsHandler {
 
     // the EnumMappers class must have a member named value (array of Enum classes)
     private static final String ENUMS_ID = "value";
-    private final AnnotationMirror annotationMirrorMapAllEnums;
     private final ProcessingEnvironment processingEnvironment;
-    private final Element annotatedElement;
+    private final Set<Element> annotatedElements;
+    ;
 
     /**
      * Will process an element (e.g. a class) which must have the {@link EnumMappers} annotation.
      * Note: the {@link EnumMappers} annotation may contain multiple Enum classes in the enums class array.
      *
      * @param processingEnvironment the processing environment
-     * @param annotatedElement      the element (e.g. class) which has the {@link EnumMappers} annotation
+     * @param annotatedElements     the element/s (e.g. class) which has/have the {@link EnumMappers} annotation
      */
-    MapAllEnumsHandler(ProcessingEnvironment processingEnvironment, Element annotatedElement) {
+    MapAllEnumsHandler(ProcessingEnvironment processingEnvironment, Set<Element> annotatedElements) {
         this.processingEnvironment = processingEnvironment;
-        this.annotatedElement = annotatedElement;
+        this.annotatedElements = annotatedElements;
+    }
+
+    /* Returns a map where the keys are all the unique enumerations and the values are the annotated classes
+     * since V1.0.2 we can use the same enum in multiple @EnumMapper annotations
+     * see issue #3 "duplicate enums in @EnumMappers should be ignored"
+     * https://github.com/tmtron/enum-mapper/issues/3
+     */
+    private Map<AnnotationValueWrapper, Collection<Element>> getEnumAnnotationsMap() {
+        ArrayListMultimap<AnnotationValueWrapper, Element> enumAnnotations = ArrayListMultimap.create();
+        for (Element annotatedElement : annotatedElements) {
+            Optional<AnnotationMirror> optMirror = MoreElements.getAnnotationMirror(annotatedElement, EnumMappers
+                    .class);
+            if (!optMirror.isPresent()) {
+                throw new RuntimeException(EnumMappers.class.getSimpleName() + " annotation not found!");
+            }
+            final AnnotationMirror annotationMirrorMapAllEnums = optMirror.get();
 
-        Optional<AnnotationMirror> optMirror = MoreElements.getAnnotationMirror(annotatedElement, EnumMappers.class);
-        if (!optMirror.isPresent()) {
-            throw new RuntimeException(EnumMappers.class.getSimpleName() + " annotation not found!");
+            // get the "value" annotationValue (which is of type: array of classes)
+            AnnotationValue annotationValue = AnnotationProcessingUtil.getRequiredAnnotationValue
+                    (annotationMirrorMapAllEnums, ENUMS_ID);
+
+            // the annotationValue is an array of classes
+            // we convert it to a list where each item is the class
+            // e.g. "value" -> {com.test.Dummy.ColorEnum.class, com.test.Dummy.BoolEnum.class}
+            //      --> the enumsList will contain 2 items (ColorEnum and BoolEnum)
+            List<? extends AnnotationValue> enumsList = AnnotationProcessingUtil.asList(annotationValue.getValue(),
+                    AnnotationValue.class, ENUMS_ID);
+
+            // loop over each (Enum-)class in the "value" array
+            /*
+             * NOTE: AnnotationValue
+             */
+            for (AnnotationValue enumsClassAnnotationValue : enumsList) {
+                //noinspection ResultOfMethodCallIgnored
+                enumAnnotations.put(new AnnotationValueWrapper(enumsClassAnnotationValue), annotatedElement);
+            }
         }
-        this.annotationMirrorMapAllEnums = optMirror.get();
+        return enumAnnotations.asMap();
     }
 
     void work() {
-        // get the "value" annotationValue (which is of type: array of classes)
-        AnnotationValue annotationValue = AnnotationProcessingUtil.getRequiredAnnotationValue
-                (annotationMirrorMapAllEnums, ENUMS_ID);
-
-        // the annotationValue is an array of classes
-        // we convert it to a list where each item is the class
-        // e.g. "value" -> {com.test.Dummy.ColorEnum.class, com.test.Dummy.BoolEnum.class}
-        //      --> the enumsList will contain 2 items (ColorEnum and BoolEnum)
-        List<? extends AnnotationValue> enumsList = AnnotationProcessingUtil.asList(annotationValue.getValue(),
-                AnnotationValue.class, ENUMS_ID);
-
-        // loop over each (Enum-)class in the "value" array
-        for (AnnotationValue enumsClassAnnotationValue : enumsList) {
+        Map<AnnotationValueWrapper, Collection<Element>> enumAnnotationMap = getEnumAnnotationsMap();
+
+        for (AnnotationValueWrapper enumsClassAnnotationValueWrapper : enumAnnotationMap.keySet()) {
+            AnnotationValue enumsClassAnnotationValue = enumsClassAnnotationValueWrapper.annotationValue;
             TypeMirror enumsClassTypeMirror = (TypeMirror) enumsClassAnnotationValue.getValue();
             TypeElement enumsClassTypeElement = MoreTypes.asTypeElement(enumsClassTypeMirror);
+
+            Collection<Element> originElements = enumAnnotationMap.get(enumsClassAnnotationValueWrapper);
+
             // now process each (Enum-)class
             // e.g. enumsClassTypeElement.getQualifiedName() "com.test.Dummy.BoolEnum.class"
-            new MapEnumElement(processingEnvironment, annotatedElement, enumsClassTypeElement).work();
+            new MapEnumElement(processingEnvironment, originElements, enumsClassTypeElement).work();
+        }
+    }
+
+    /**
+     * Simple wrapper around an {@link AnnotationValue} that uses the toString() value for equals and hashCode.
+     */
+    private static class AnnotationValueWrapper {
+
+        final AnnotationValue annotationValue;
+        final String stringRep;
+
+        private AnnotationValueWrapper(AnnotationValue annotationValue) {
+            this.annotationValue = annotationValue;
+            stringRep = annotationValue.toString();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            AnnotationValueWrapper that = (AnnotationValueWrapper) o;
+
+            return stringRep.equals(that.stringRep);
+        }
+
+        @Override
+        public int hashCode() {
+            return stringRep.hashCode();
         }
     }
 
diff --git a/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapAllEnumsProcessingStep.java b/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapAllEnumsProcessingStep.java
@@ -92,7 +92,8 @@ private void processEnumMapperAnnotation(Set<Element> annotatedElements) {
                 TypeElement enumsClassTypeElement = MoreTypes.asTypeElement(enumsClassTypeMirror);
                 // now process each (Enum-)class
                 // e.g. enumsClassTypeElement.getQualifiedName() "com.test.Dummy.BoolEnum.class"
-                new MapEnumElement(processingEnvironment, element, enumsClassTypeElement).work();
+                new MapEnumElement(processingEnvironment, Collections.singletonList(element), enumsClassTypeElement)
+                        .work();
 
             } catch (Exception e) {
                 processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR
@@ -103,15 +104,11 @@ private void processEnumMapperAnnotation(Set<Element> annotatedElements) {
     }
 
     private void processEnumMappersAnnotation(Set<Element> annotatedElements) {
-        // the EnumMappers annotation may be present on multiple elements (classes or packages)
-        for (Element element : annotatedElements) {
-            try {
-                new MapAllEnumsHandler(processingEnvironment, element).work();
-            } catch (Exception e) {
-                processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR
-                        , "Annotation processing error: " + e.getClass().getSimpleName() + "-" + e.getMessage()
-                        , element);
-            }
+        try {
+            new MapAllEnumsHandler(processingEnvironment, annotatedElements).work();
+        } catch (Exception e) {
+            processingEnvironment.getMessager().printMessage(Diagnostic.Kind.ERROR
+                    , "Annotation processing error: " + e.getClass().getSimpleName() + "-" + e.getMessage());
         }
     }
 }
diff --git a/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapEnumElement.java b/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/MapEnumElement.java
@@ -21,6 +21,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 import javax.annotation.processing.ProcessingEnvironment;
@@ -34,7 +35,7 @@
 class MapEnumElement {
 
     private final ProcessingEnvironment processingEnvironment;
-    private final Element annotatedElement;
+    private final Collection<Element> annotatedElements;
     private final TypeElement enumsClassTypeElement;
     private final List<CodeGenEnumConst> enumConstants = new ArrayList<>();
     private final TypeVariableName typeVariableName4Value;
@@ -43,13 +44,13 @@ class MapEnumElement {
      * Will process a single Enum class of the {@link EnumMappers} annotation.
      *
      * @param processingEnvironment the processing environment
-     * @param annotatedElement      the element (e.g. class) which has the {@link EnumMappers} annotation
+     * @param annotatedElements     the element/s (e.g. classe) which has/have the {@link EnumMappers} annotation
      * @param enumsClassTypeElement a single Enum class from the "values" array of the {@link EnumMappers} annotation
      */
-    MapEnumElement(ProcessingEnvironment processingEnvironment, Element annotatedElement,
+    MapEnumElement(ProcessingEnvironment processingEnvironment, Collection<Element> annotatedElements,
                    TypeElement enumsClassTypeElement) {
         this.processingEnvironment = processingEnvironment;
-        this.annotatedElement = annotatedElement;
+        this.annotatedElements = annotatedElements;
         this.enumsClassTypeElement = enumsClassTypeElement;
         typeVariableName4Value = TypeVariableName.get("V");
     }
@@ -73,7 +74,7 @@ void work() {
         }
         if (enumConstants.size() < 2) throw new RuntimeException("The Enum must have at least 2 constants!");
 
-        WriteMapperFull writeMapperFull = new WriteMapperFull(annotatedElement, enumsClassTypeElement
+        WriteMapperFull writeMapperFull = new WriteMapperFull(annotatedElements, enumsClassTypeElement
                 , enumConstants, typeVariableName4Value);
         try {
             JavaFile.builder(getPackageName(), writeMapperFull.work())
diff --git a/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/WriteMapperFull.java b/enum-mapper-processor/src/main/java/com/tmtron/enums/processor/WriteMapperFull.java
@@ -26,6 +26,7 @@
 import com.tmtron.enums.EnumMapperFull;
 
 import java.time.format.DateTimeFormatter;
+import java.util.Collection;
 import java.util.List;
 
 import javax.annotation.Generated;
@@ -34,14 +35,14 @@
 import javax.lang.model.element.TypeElement;
 
 class WriteMapperFull {
-    private final Element annotatedElement;
+    private final Collection<Element> annotatedElements;
     private final TypeElement enumsClassTypeElement;
     private final List<CodeGenEnumConst> enumConstants;
     private final TypeVariableName typeVariableName4Value;
 
-    WriteMapperFull(Element annotatedElement, TypeElement enumsClassTypeElement, List<CodeGenEnumConst>
-            enumConstants, TypeVariableName typeVariableName4Value) {
-        this.annotatedElement = annotatedElement;
+    WriteMapperFull(Collection<Element> annotatedElements, TypeElement enumsClassTypeElement
+            , List<CodeGenEnumConst> enumConstants, TypeVariableName typeVariableName4Value) {
+        this.annotatedElements = annotatedElements;
         this.enumsClassTypeElement = enumsClassTypeElement;
         this.enumConstants = enumConstants;
         this.typeVariableName4Value = typeVariableName4Value;
@@ -53,7 +54,7 @@ class WriteMapperFull {
      *  {@literal @}Generated(
      *    value = "com.tmtron.enums.processor.EnumsAnnotationProcessor",
      *    date = "1976-12-14T15:16:17.234+02:00",
-     *    comments = "origin=com.test.TwoEnums_Source"
+     *    comments = "origin=[com.test.TwoEnums_SourceA,com.test.TwoEnums_SourceB]"
      *    )
      * </code></pre>
      *
@@ -65,7 +66,23 @@ private AnnotationSpec createGeneratedAnnotation(Class<?> annotationProcessorCla
                 .addMember("value", "$S", annotationProcessorClass.getCanonicalName())
                 .addMember("date", "$S", dateString);
 
-        String commentsString = "origin=" + MoreElements.asType(annotatedElement).getQualifiedName().toString();
+        StringBuilder sbOrigin = new StringBuilder();
+        annotatedElements.forEach(annotatedElement -> {
+            if (sbOrigin.length() > 0) {
+                sbOrigin.append(",");
+            }
+            sbOrigin.append(MoreElements.asType(annotatedElement).getQualifiedName().toString());
+        });
+
+        String commentsString = "origin=";
+        if (annotatedElements.size() > 1) {
+            commentsString += "[";
+        }
+        commentsString += sbOrigin.toString();
+        if (annotatedElements.size() > 1) {
+            commentsString += "]";
+        }
+
         annotationSpecBuilder.addMember("comments", "$S", commentsString);
 
         return annotationSpecBuilder.build();
diff --git a/enum-mapper-processor/src/test/java/com/tmtron/enums/processor/TestMappers4DuplicateEnums.java b/enum-mapper-processor/src/test/java/com/tmtron/enums/processor/TestMappers4DuplicateEnums.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2017 Martin Trummer (martin.trummer@tmtron.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.tmtron.enums.processor;
+
+import org.junit.Test;
+
+public class TestMappers4DuplicateEnums extends AnnotationProcessorTest {
+
+    /**
+     * Test if we can put the @EnumMappers annotation handles duplicate enums gracefully.
+     * <p>
+     * Did not work in V1.0.1. See <a href="https://github.com/tmtron/enum-mapper/issues/3">
+     * issue #3 "duplicate enums in @EnumMappers should be ignored"</a>
+     * </p>
+     */
+    @Test
+    public void test() throws Exception {
+        assertAboutEnumsProcessing(getJfoResource("DuplicateEnums_Source.java"))
+                .compilesWithoutWarnings()
+                .and()
+                .generatesSources(
+                        getJfoResource("BoolEnum_MapperFull.java"),
+                        getJfoResource("ColorEnum_MapperFull.java"));
+    }
+
+}
diff --git a/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/BoolEnum_MapperFull.java b/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/BoolEnum_MapperFull.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2017 Martin Trummer (martin.trummer@tmtron.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// GENERATED
+package com.test;
+
+import com.tmtron.enums.EnumMapperFull;
+
+import javax.annotation.Generated;
+
+@Generated(
+        value = "com.tmtron.enums.processor.EnumsAnnotationProcessor",
+        date = "1976-12-14T15:16:17.234+02:00",
+        comments = "origin=[com.test.DuplicateEnums_Source.AnnotatedClassA,com.test.DuplicateEnums_Source" +
+                ".AnnotatedClassC]"
+)
+public final class BoolEnum_MapperFull {
+    public static <V> IsetON<V> setOFF(V value) {
+        StagedBuilder<V> result = new StagedBuilder<>();
+        result.enumMapperBuilder.put(DuplicateEnums_Source.BoolEnum.OFF, value);
+        return result;
+    }
+
+    public interface IsetON<V> {
+        EnumMapperFull<DuplicateEnums_Source.BoolEnum, V> setON(V value);
+    }
+
+    private static class StagedBuilder<V> implements IsetON<V> {
+        private final EnumMapperFull.Builder<DuplicateEnums_Source.BoolEnum, V> enumMapperBuilder = EnumMapperFull
+                .builder
+                        (DuplicateEnums_Source.BoolEnum.class);
+
+        @Override
+        public EnumMapperFull<DuplicateEnums_Source.BoolEnum, V> setON(V value) {
+            enumMapperBuilder.put(DuplicateEnums_Source.BoolEnum.ON, value);
+            return enumMapperBuilder.build();
+        }
+    }
+}
diff --git a/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/ColorEnum_MapperFull.java b/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/ColorEnum_MapperFull.java
diff --git a/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/DuplicateEnums_Source.java b/enum-mapper-processor/src/test/resources/TestMappers4DuplicateEnums/DuplicateEnums_Source.java
diff --git a/enum-mapper-processor/src/test/resources/TestMappersOn2Classes/TwoClasses_Source.java b/enum-mapper-processor/src/test/resources/TestMappersOn2Classes/TwoClasses_Source.java
