Merge branch 'master' into coreCleanU

Author: croudet38

modules/swagger-annotations/src/main/java/io/swagger/v3/oas/annotations/media/Schema.java

@@ -237,7 +237,7 @@
     /**
      * Allows to specify the access mode (AccessMode.READ_ONLY, READ_WRITE)
      *
-     * AccessMode.READ_ONLY: value will only be written to during a request but not returned during a response.
+     * AccessMode.READ_ONLY: value will not be written to during a request but may be returned during a response.
      * AccessMode.WRITE_ONLY: value will only be written to during a request but not returned during a response.
      * AccessMode.READ_WRITE: value will be written to during a request and returned during a response.
      *

modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java

@@ -7,6 +7,7 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.JsonUnwrapped;
+import com.fasterxml.jackson.annotation.JsonValue;
 import com.fasterxml.jackson.annotation.JsonView;
 import com.fasterxml.jackson.annotation.ObjectIdGenerator;
 import com.fasterxml.jackson.annotation.ObjectIdGenerators;
@@ -81,6 +82,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -938,11 +940,29 @@ protected void _addEnumProps(Class<?> propClass, Schema property) {
         final boolean useIndex = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_INDEX);
         final boolean useToString = _mapper.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
 
+
+        Optional<Method> jsonValueMethod = Arrays.stream(propClass.getMethods())
+                .filter(m -> m.isAnnotationPresent(JsonValue.class))
+                .filter(m -> m.getAnnotation(JsonValue.class).value())
+                .findFirst();
+
         @SuppressWarnings("unchecked")
         Class<Enum<?>> enumClass = (Class<Enum<?>>) propClass;
-        for (Enum<?> en : enumClass.getEnumConstants()) {
+
+        Enum<?>[] enumConstants = enumClass.getEnumConstants();
+        String[] enumValues = _intr.findEnumValues(propClass, enumConstants, new String[enumConstants.length]);
+
+        for (Enum<?> en : enumConstants) {
             String n;
-            if (useIndex) {
+
+            String enumValue = enumValues[en.ordinal()];
+            String s = jsonValueMethod.flatMap(m -> ReflectionUtils.safeInvoke(m, en)).map(Object::toString).orElse(null);
+
+            if (s != null) {
+                n = s;
+            } else if (enumValue != null) {
+                n = enumValue;
+            } else if (useIndex) {
                 n = String.valueOf(en.ordinal());
             } else if (useToString) {
                 n = en.toString();

modules/swagger-core/src/main/java/io/swagger/v3/core/util/AnnotationsUtils.java

@@ -555,15 +555,19 @@ public static Schema resolveSchemaFromType(Class<?> schemaImplementation, Compon
             Map<String, Schema> schemaMap;
             if (resolvedSchema != null) {
                 schemaMap = resolvedSchema.referencedSchemas;
-                schemaMap.forEach((key, referencedSchema) -> {
-                    if (components != null) {
-                        components.addSchemas(key, referencedSchema);
+                if (schemaMap != null) {
+                    schemaMap.forEach((key, referencedSchema) -> {
+                        if (components != null) {
+                            components.addSchemas(key, referencedSchema);
+                        }
+                    });
+                }
+                if (resolvedSchema.schema != null) {
+                    if (StringUtils.isNotBlank(resolvedSchema.schema.getName())) {
+                        schemaObject.set$ref(COMPONENTS_REF + resolvedSchema.schema.getName());
+                    } else {
+                        schemaObject = resolvedSchema.schema;
                     }
-                });
-                if (StringUtils.isNotBlank(resolvedSchema.schema.getName())) {
-                    schemaObject.set$ref(COMPONENTS_REF + resolvedSchema.schema.getName());
-                } else {
-                    schemaObject = resolvedSchema.schema;
                 }
             }
         }

modules/swagger-core/src/main/java/io/swagger/v3/core/util/ParameterProcessor.java

@@ -21,7 +21,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -107,7 +107,7 @@ public static Parameter applyAnnotations(
                     parameter.setAllowReserved(p.allowReserved());
                 }
 
-                Map<String, Example> exampleMap = new HashMap<>();
+                Map<String, Example> exampleMap = new LinkedHashMap<>();
                 if (p.examples().length == 1 && StringUtils.isBlank(p.examples()[0].name())) {
                     Optional<Example> exampleOptional = AnnotationsUtils.getExample(p.examples()[0], true);
                     if (exampleOptional.isPresent()) {

modules/swagger-core/src/main/java/io/swagger/v3/core/util/ReflectionUtils.java

@@ -9,6 +9,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
@@ -17,6 +18,7 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 public class ReflectionUtils {
@@ -366,4 +368,13 @@ public static boolean isSystemType(JavaType type) {
         }
         return type.isArrayType();
     }
+
+    public static Optional<Object> safeInvoke(Method method, Object obj, Object... args) {
+        try {
+            return Optional.ofNullable(method.invoke(obj, args));
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            return Optional.empty();
+        }
+
+    }
 }

modules/swagger-core/src/test/java/io/swagger/v3/core/converting/EnumPropertyTest.java

@@ -10,6 +10,7 @@
 import io.swagger.v3.core.oas.models.ModelWithEnumField;
 import io.swagger.v3.core.oas.models.ModelWithEnumProperty;
 import io.swagger.v3.core.oas.models.ModelWithEnumRefProperty;
+import io.swagger.v3.core.oas.models.ModelWithJacksonEnumField;
 import io.swagger.v3.oas.models.media.Schema;
 import io.swagger.v3.oas.models.media.StringSchema;
 import org.testng.annotations.AfterTest;
@@ -156,4 +157,25 @@ public void testEnumRefPropertyGlobalNotAffectingNonEnums() {
         SerializationMatchers.assertEqualsToYaml(models, yaml);
         ModelResolver.enumsAsRef = false;
     }
+
+    @Test(description = "it should extract enum values from fields using JsonProperty and JsonValue")
+    public void testExtractJacksonEnumFields() {
+        final Map<String, Schema> models = ModelConverters.getInstance().read(ModelWithJacksonEnumField.class);
+        final Schema model = models.get("ModelWithJacksonEnumField");
+
+        final Schema firstEnumProperty = (Schema) model.getProperties().get("firstEnumValue");
+        assertTrue(firstEnumProperty instanceof StringSchema);
+        final StringSchema stringProperty = (StringSchema) firstEnumProperty;
+        assertEquals(stringProperty.getEnum(), Arrays.asList("p1", "p2", "SYSTEM", "INVITE_ONLY"));
+
+        final Schema secondEnumProperty = (Schema) model.getProperties().get("secondEnumValue");
+        assertTrue(secondEnumProperty instanceof StringSchema);
+        final StringSchema secondStringProperty = (StringSchema) secondEnumProperty;
+        assertEquals(secondStringProperty.getEnum(), Arrays.asList("one", "two", "three"));
+
+        final Schema thirdEnumProperty = (Schema) model.getProperties().get("thirdEnumValue");
+        assertTrue(thirdEnumProperty instanceof StringSchema);
+        final StringSchema thirdStringProperty = (StringSchema) thirdEnumProperty;
+        assertEquals(thirdStringProperty.getEnum(), Arrays.asList("2", "4", "6"));
+    }
 }

modules/swagger-core/src/test/java/io/swagger/v3/core/deserialization/JsonDeserializationTest.java

@@ -256,6 +256,7 @@ public void deserializeLongSchema() throws IOException {
         assertEquals(s.getEnum().get(0), 2147483647);
         assertEquals(s.getEnum().get(1), 3147483647L);
         assertEquals(s.getEnum().get(2), 31474836475505055L);
+        assertEquals(s.getEnum().get(3), -9223372036854775808L);
     }
 
     @Test

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonNumberValueEnum.java

@@ -0,0 +1,20 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum JacksonNumberValueEnum {
+    FIRST(2),
+    SECOND(4),
+    THIRD(6);
+
+    private final int value;
+
+    JacksonNumberValueEnum(int value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public Number getValue() {
+        return value;
+    }
+}

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonPropertyEnum.java

@@ -0,0 +1,10 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+public enum JacksonPropertyEnum {
+    @JsonProperty("p1") PRIVATE,
+    @JsonProperty("p2") PUBLIC,
+    SYSTEM,
+    INVITE_ONLY
+}

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/JacksonValueEnum.java

@@ -0,0 +1,20 @@
+package io.swagger.v3.core.oas.models;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+
+public enum JacksonValueEnum {
+    FIRST("one"),
+    SECOND("two"),
+    THIRD("three");
+
+    private final String value;
+
+    JacksonValueEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}