adjust to generator version 3

CarstenWickner · CarstenWickner · commit 404464af6330 · 2019-06-10T22:29:35.000+02:00
and extend annotation support to field/getter paris
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- Consider the same validation annotations on a getter method also for its field
+- Consider the same validation annotations on a field also for its getter method
+
+### Changed
+- Internal changes to comply with latest `jsonschema-generator` release `v3.x`
 
 ## v1.0.0 – 2019-05-22
 ### Added
diff --git a/README.md b/README.md
@@ -1,11 +1,20 @@
 # Java JSON Schema Generator – Module javax.validation
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.victools/jsonschema-module-javax-validation/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.victools/jsonschema-module-javax-validation)
 
-Module for the `jsonschema-generator` – deriving JSON Schema attributes from `javax.validation` annotations.
+Module for the `jsonschema-generator` – deriving JSON Schema attributes from `javax.validation.constraints` annotations.
+
+## Features
+1. Determine whether a member is not nullable, base assumption being that all fields and method return values are nullable if not annotated. Based on `@NotNull`/`@Null`/`@NotEmpty`/`@NotBlank`
+2. Populate "minItems" and "maxItems" for containers (i.e. arrays and collections). Based on `@Size`/`@NotEmpty`
+3. Populate "minLength" and "maxLength" for strings. Based on `@Size`/`@NotEmpty`/`@NotBlank`
+4. Populate "minimum"/"exclusiveMinimum" for numbers. Based on `@Min`/`@DecimalMin`/`@Positive`/`@PositiveOrZero`
+5. Populate "maximum"/"exclusiveMaximum" for numbers. Based on `@Max`/`@DecimalMax`/`@Negative`/`@NegativeOrZero`
+
+Schema attributes derived from validation annotations on fields are also applied to their respective getter methods.
+Schema attributes derived from validation annotations on getter methods are also applied to their associated fields.
 
 ## Usage
 ### Dependency (Maven)
-
 ```xml
 <dependency>
     <groupId>com.github.victools</groupId>
diff --git a/pom.xml b/pom.xml
@@ -8,7 +8,7 @@
 
     <groupId>com.github.victools</groupId>
     <artifactId>jsonschema-module-javax-validation</artifactId>
-    <version>1.1.0-SNAPSHOT</version>
+    <version>3.0.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <licenses>
@@ -58,6 +58,9 @@
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
 
+        <version.generator>3.0.0</version.generator>
+
+        <version.javax.validation>2.0.1.Final</version.javax.validation>
         <version.junit>4.12</version.junit>
         <version.junitparams>1.1.1</version.junitparams>
         <version.mockito>2.27.0</version.mockito>
@@ -67,13 +70,13 @@
         <dependency>
             <groupId>com.github.victools</groupId>
             <artifactId>jsonschema-generator</artifactId>
-            <version>1.0.1</version>
+            <version>${version.generator}</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>javax.validation</groupId>
             <artifactId>validation-api</artifactId>
-            <version>2.0.1.Final</version>
+            <version>${version.javax.validation}</version>
             <scope>provided</scope>
         </dependency>
         <!-- junit is only required in "test" scope -->
diff --git a/src/main/java/com/github/victools/jsonschema/module/javax/validation/JavaxValidationModule.java b/src/main/java/com/github/victools/jsonschema/module/javax/validation/JavaxValidationModule.java
@@ -16,12 +16,13 @@
 
 package com.github.victools.jsonschema.module.javax.validation;
 
-import com.github.victools.jsonschema.generator.JavaType;
+import com.github.victools.jsonschema.generator.FieldScope;
+import com.github.victools.jsonschema.generator.MemberScope;
+import com.github.victools.jsonschema.generator.MethodScope;
 import com.github.victools.jsonschema.generator.Module;
 import com.github.victools.jsonschema.generator.SchemaGeneratorConfigBuilder;
 import com.github.victools.jsonschema.generator.SchemaGeneratorConfigPart;
-import com.github.victools.jsonschema.generator.impl.ReflectionTypeUtils;
-import java.lang.reflect.AccessibleObject;
+import java.lang.annotation.Annotation;
 import java.math.BigDecimal;
 import javax.validation.constraints.DecimalMax;
 import javax.validation.constraints.DecimalMin;
@@ -38,7 +39,13 @@
 import javax.validation.constraints.Size;
 
 /**
- * With this module, the base assumption for the nullable indication is that all fields and methods are nullable unless annotated otherwise.
+ * JSON Schema Generation Module: based on annotations from the {@code javax.validation.constraints} package.
+ * <ul>
+ * <li>Determine whether a member is not nullable, base assumption being that all fields and method return values are nullable if not annotated.</li>
+ * <li>Populate "minItems" and "maxItems" for containers (i.e. arrays and collections).</li>
+ * <li>Populate "minLength" and "maxLength" for strings.</li>
+ * <li>Populate "minimum"/"exclusiveMinimum" and "maximum"/"exclusiveMaximum" for numbers.</li>
+ * </ul>
  */
 public class JavaxValidationModule implements Module {
 
@@ -53,7 +60,7 @@ public void applyToConfigBuilder(SchemaGeneratorConfigBuilder builder) {
      *
      * @param configPart config builder part to add configurations to
      */
-    private void applyToConfigPart(SchemaGeneratorConfigPart<? extends AccessibleObject> configPart) {
+    private void applyToConfigPart(SchemaGeneratorConfigPart<?> configPart) {
         configPart.withNullableCheck(this::isNullable);
         configPart.withArrayMinItemsResolver(this::resolveArrayMinItems);
         configPart.withArrayMaxItemsResolver(this::resolveArrayMaxItems);
@@ -65,21 +72,47 @@ private void applyToConfigPart(SchemaGeneratorConfigPart<? extends AccessibleObj
         configPart.withNumberExclusiveMaximumResolver(this::resolveNumberExclusiveMaximum);
     }
 
+    /**
+     * Retrieves the annotation instance of the given type, either from the field it self or (if not present) from its getter.
+     *
+     * @param <A> type of annotation
+     * @param member field or method to retrieve annotation instance from (or from a field's getter or getter method's field)
+     * @param annotationClass type of annotation
+     * @return annotation instance (or {@code null})
+     * @see MemberScope#getAnnotation(Class)
+     * @see FieldScope#findGetter()
+     * @see MethodScope#findGetterField()
+     */
+    protected <A extends Annotation> A getAnnotationFromFieldOrGetter(MemberScope<?, ?> member, Class<A> annotationClass) {
+        A annotation = member.getAnnotation(annotationClass);
+        if (annotation == null) {
+            MemberScope<?, ?> associatedGetterOrField;
+            if (member instanceof FieldScope) {
+                associatedGetterOrField = ((FieldScope) member).findGetter();
+            } else if (member instanceof MethodScope) {
+                associatedGetterOrField = ((MethodScope) member).findGetterField();
+            } else {
+                associatedGetterOrField = null;
+            }
+            annotation = associatedGetterOrField == null ? null : associatedGetterOrField.getAnnotation(annotationClass);
+        }
+        return annotation;
+    }
+
     /**
      * Determine whether a given field or method is annotated to be not nullable.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
-     * @return whether the field/method is specifically annotated as nullable or not (returns null if not specified: assumption it is nullable then)
+     * @param member the field or method to check
+     * @return whether member is annotated as nullable or not (returns null if not specified: assumption it is nullable then)
      */
-    private Boolean isNullable(AccessibleObject fieldOrMethod, JavaType type) {
+    protected Boolean isNullable(MemberScope<?, ?> member) {
         Boolean result;
-        if (fieldOrMethod.isAnnotationPresent(NotNull.class)
-                || fieldOrMethod.isAnnotationPresent(NotBlank.class)
-                || fieldOrMethod.isAnnotationPresent(NotEmpty.class)) {
+        if (this.getAnnotationFromFieldOrGetter(member, NotNull.class) != null
+                || this.getAnnotationFromFieldOrGetter(member, NotBlank.class) != null
+                || this.getAnnotationFromFieldOrGetter(member, NotEmpty.class) != null) {
             // field is specifically NOT nullable
             result = Boolean.FALSE;
-        } else if (fieldOrMethod.isAnnotationPresent(Null.class)) {
+        } else if (this.getAnnotationFromFieldOrGetter(member, Null.class) != null) {
             // field is specifically null (and thereby nullable)
             result = Boolean.TRUE;
         } else {
@@ -91,19 +124,18 @@ private Boolean isNullable(AccessibleObject fieldOrMethod, JavaType type) {
     /**
      * Determine a given array type's minimum number of items.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified minimum number of array items (or null)
      * @see Size
      */
-    private Integer resolveArrayMinItems(AccessibleObject fieldOrMethod, JavaType type) {
-        if (ReflectionTypeUtils.isArrayType(type)) {
-            Size sizeAnnotation = fieldOrMethod.getAnnotation(Size.class);
+    protected Integer resolveArrayMinItems(MemberScope<?, ?> member) {
+        if (member.isContainerType()) {
+            Size sizeAnnotation = this.getAnnotationFromFieldOrGetter(member, Size.class);
             if (sizeAnnotation != null && sizeAnnotation.min() > 0) {
                 // minimum length greater than the default 0 was specified
                 return sizeAnnotation.min();
             }
-            if (fieldOrMethod.isAnnotationPresent(NotEmpty.class)) {
+            if (this.getAnnotationFromFieldOrGetter(member, NotEmpty.class) != null) {
                 return 1;
             }
         }
@@ -113,14 +145,13 @@ private Integer resolveArrayMinItems(AccessibleObject fieldOrMethod, JavaType ty
     /**
      * Determine a given array type's maximum number of items.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified maximum number of array items (or null)
      * @see Size
      */
-    private Integer resolveArrayMaxItems(AccessibleObject fieldOrMethod, JavaType type) {
-        if (ReflectionTypeUtils.isArrayType(type)) {
-            Size sizeAnnotation = fieldOrMethod.getAnnotation(Size.class);
+    protected Integer resolveArrayMaxItems(MemberScope<?, ?> member) {
+        if (member.isContainerType()) {
+            Size sizeAnnotation = this.getAnnotationFromFieldOrGetter(member, Size.class);
             if (sizeAnnotation != null && sizeAnnotation.max() < 2147483647) {
                 // maximum length below the default 2147483647 was specified
                 return sizeAnnotation.max();
@@ -132,23 +163,21 @@ private Integer resolveArrayMaxItems(AccessibleObject fieldOrMethod, JavaType ty
     /**
      * Determine a given text type's minimum number of characters.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified minimum number of characters (or null)
      * @see Size
      * @see NotEmpty
      * @see NotBlank
      */
-    private Integer resolveStringMinLength(AccessibleObject fieldOrMethod, JavaType type) {
-        Class<?> rawType = ReflectionTypeUtils.getRawType(type.getResolvedType());
-        if (CharSequence.class.isAssignableFrom(rawType)) {
-            Size sizeAnnotation = fieldOrMethod.getAnnotation(Size.class);
+    protected Integer resolveStringMinLength(MemberScope<?, ?> member) {
+        if (member.getType().isInstanceOf(CharSequence.class)) {
+            Size sizeAnnotation = this.getAnnotationFromFieldOrGetter(member, Size.class);
             if (sizeAnnotation != null && sizeAnnotation.min() > 0) {
                 // minimum length greater than the default 0 was specified
                 return sizeAnnotation.min();
             }
-            if (fieldOrMethod.isAnnotationPresent(NotEmpty.class)
-                    || fieldOrMethod.isAnnotationPresent(NotBlank.class)) {
+            if (this.getAnnotationFromFieldOrGetter(member, NotEmpty.class) != null
+                    || this.getAnnotationFromFieldOrGetter(member, NotBlank.class) != null) {
                 return 1;
             }
         }
@@ -158,15 +187,13 @@ private Integer resolveStringMinLength(AccessibleObject fieldOrMethod, JavaType
     /**
      * Determine a given text type's maximum number of characters.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified minimum number of characters (or null)
      * @see Size
      */
-    private Integer resolveStringMaxLength(AccessibleObject fieldOrMethod, JavaType type) {
-        Class<?> rawType = ReflectionTypeUtils.getRawType(type.getResolvedType());
-        if (CharSequence.class.isAssignableFrom(rawType)) {
-            Size sizeAnnotation = fieldOrMethod.getAnnotation(Size.class);
+    protected Integer resolveStringMaxLength(MemberScope<?, ?> member) {
+        if (member.getType().isInstanceOf(CharSequence.class)) {
+            Size sizeAnnotation = this.getAnnotationFromFieldOrGetter(member, Size.class);
             if (sizeAnnotation != null && sizeAnnotation.max() < 2147483647) {
                 // maximum length below the default 2147483647 was specified
                 return sizeAnnotation.max();
@@ -178,23 +205,22 @@ private Integer resolveStringMaxLength(AccessibleObject fieldOrMethod, JavaType
     /**
      * Determine a number type's minimum (inclusive) value.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified inclusive minimum value (or null)
      * @see Min
      * @see DecimalMin
      * @see PositiveOrZero
      */
-    private BigDecimal resolveNumberInclusiveMinimum(AccessibleObject fieldOrMethod, JavaType type) {
-        Min minAnnotation = fieldOrMethod.getAnnotation(Min.class);
+    protected BigDecimal resolveNumberInclusiveMinimum(MemberScope<?, ?> member) {
+        Min minAnnotation = this.getAnnotationFromFieldOrGetter(member, Min.class);
         if (minAnnotation != null) {
             return new BigDecimal(minAnnotation.value());
         }
-        DecimalMin decimalMinAnnotation = fieldOrMethod.getAnnotation(DecimalMin.class);
+        DecimalMin decimalMinAnnotation = this.getAnnotationFromFieldOrGetter(member, DecimalMin.class);
         if (decimalMinAnnotation != null && decimalMinAnnotation.inclusive()) {
             return new BigDecimal(decimalMinAnnotation.value());
         }
-        PositiveOrZero positiveAnnotation = fieldOrMethod.getAnnotation(PositiveOrZero.class);
+        PositiveOrZero positiveAnnotation = this.getAnnotationFromFieldOrGetter(member, PositiveOrZero.class);
         if (positiveAnnotation != null) {
             return BigDecimal.ZERO;
         }
@@ -204,18 +230,17 @@ private BigDecimal resolveNumberInclusiveMinimum(AccessibleObject fieldOrMethod,
     /**
      * Determine a number type's minimum (exclusive) value.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified exclusive minimum value (or null)
      * @see DecimalMin
      * @see Positive
      */
-    private BigDecimal resolveNumberExclusiveMinimum(AccessibleObject fieldOrMethod, JavaType type) {
-        DecimalMin decimalMinAnnotation = fieldOrMethod.getAnnotation(DecimalMin.class);
+    protected BigDecimal resolveNumberExclusiveMinimum(MemberScope<?, ?> member) {
+        DecimalMin decimalMinAnnotation = this.getAnnotationFromFieldOrGetter(member, DecimalMin.class);
         if (decimalMinAnnotation != null && !decimalMinAnnotation.inclusive()) {
             return new BigDecimal(decimalMinAnnotation.value());
         }
-        Positive positiveAnnotation = fieldOrMethod.getAnnotation(Positive.class);
+        Positive positiveAnnotation = this.getAnnotationFromFieldOrGetter(member, Positive.class);
         if (positiveAnnotation != null) {
             return BigDecimal.ZERO;
         }
@@ -225,23 +250,22 @@ private BigDecimal resolveNumberExclusiveMinimum(AccessibleObject fieldOrMethod,
     /**
      * Determine a number type's maximum (inclusive) value.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified inclusive maximum value (or null)
      * @see Max
      * @see DecimalMax#inclusive()
      * @see NegativeOrZero
      */
-    private BigDecimal resolveNumberInclusiveMaximum(AccessibleObject fieldOrMethod, JavaType type) {
-        Max maxAnnotation = fieldOrMethod.getAnnotation(Max.class);
+    protected BigDecimal resolveNumberInclusiveMaximum(MemberScope<?, ?> member) {
+        Max maxAnnotation = this.getAnnotationFromFieldOrGetter(member, Max.class);
         if (maxAnnotation != null) {
             return new BigDecimal(maxAnnotation.value());
         }
-        DecimalMax decimalMaxAnnotation = fieldOrMethod.getAnnotation(DecimalMax.class);
+        DecimalMax decimalMaxAnnotation = this.getAnnotationFromFieldOrGetter(member, DecimalMax.class);
         if (decimalMaxAnnotation != null && decimalMaxAnnotation.inclusive()) {
             return new BigDecimal(decimalMaxAnnotation.value());
         }
-        NegativeOrZero negativeAnnotation = fieldOrMethod.getAnnotation(NegativeOrZero.class);
+        NegativeOrZero negativeAnnotation = this.getAnnotationFromFieldOrGetter(member, NegativeOrZero.class);
         if (negativeAnnotation != null) {
             return BigDecimal.ZERO;
         }
@@ -251,18 +275,17 @@ private BigDecimal resolveNumberInclusiveMaximum(AccessibleObject fieldOrMethod,
     /**
      * Determine a number type's maximum (exclusive) value.
      *
-     * @param fieldOrMethod the field or method to check
-     * @param type field's or method return value's type
+     * @param member the field or method to check
      * @return specified exclusive maximum value (or null)
      * @see DecimalMax#inclusive()
      * @see Negative
      */
-    private BigDecimal resolveNumberExclusiveMaximum(AccessibleObject fieldOrMethod, JavaType type) {
-        DecimalMax decimalMaxAnnotation = fieldOrMethod.getAnnotation(DecimalMax.class);
+    protected BigDecimal resolveNumberExclusiveMaximum(MemberScope<?, ?> member) {
+        DecimalMax decimalMaxAnnotation = this.getAnnotationFromFieldOrGetter(member, DecimalMax.class);
         if (decimalMaxAnnotation != null && !decimalMaxAnnotation.inclusive()) {
             return new BigDecimal(decimalMaxAnnotation.value());
         }
-        Negative negativeAnnotation = fieldOrMethod.getAnnotation(Negative.class);
+        Negative negativeAnnotation = this.getAnnotationFromFieldOrGetter(member, Negative.class);
         if (negativeAnnotation != null) {
             return BigDecimal.ZERO;
         }
diff --git a/src/test/java/com/github/victools/jsonschema/module/javax/validation/JavaxValidationModuleTest.java b/src/test/java/com/github/victools/jsonschema/module/javax/validation/JavaxValidationModuleTest.java
diff --git a/src/test/java/com/github/victools/jsonschema/module/javax/validation/TestType.java b/src/test/java/com/github/victools/jsonschema/module/javax/validation/TestType.java
