Interface-based config support

.gitignore

@@ -17,7 +17,7 @@ build-logic/*/bin/
 /format/*/.apt_generated_tests/
 /format/*/.checkstyle
 /format/*/.settings/
-/extra/*/build/
+/extra/**/build/
 /extra/*/out/
 /extra/*/bin/
 /extra/*/.factorypath

core/src/main/java/org/spongepowered/configurate/objectmapping/ObjectMapper.java

@@ -316,6 +316,44 @@ default <A extends Annotation> Builder addProcessor(final Class<A> definition, f
              */
             <A extends Annotation, T> Builder addProcessor(Class<A> definition, Class<T> valueType, Processor.Factory<A, T> factory);
 
+            /**
+             * Register a {@link Processor} that will process fields after write.
+             * The difference between an AdvancedFactory and a Factory is that
+             * an AdvancedFactory has access to all the annotations on the
+             * field, which makes more advanced processors possible.
+             *
+             * <p>Processors registered without a specific data type should be
+             * able to operate on any value type.</p>
+             *
+             * @param definition annotation providing data
+             * @param factory factory for callback function
+             * @param <A> annotation type
+             * @return this builder
+             * @since 4.0.0
+             */
+            default <A extends Annotation> Builder addProcessor(final Class<A> definition, final Processor.AdvancedFactory<A, Object> factory) {
+                return addProcessor(definition, Object.class, factory);
+            }
+
+            /**
+             * Register a {@link Processor} that will process fields after write.
+             * The difference between an AdvancedFactory and a Factory is that
+             * an AdvancedFactory has access to all the annotations on the
+             * field, which makes more advanced processors possible.
+             *
+             * <p>All value types will be tested against types normalized to
+             * their boxed variants.</p>
+             *
+             * @param definition annotation providing data
+             * @param valueType value types the processor will handle
+             * @param factory factory for callback function
+             * @param <A> annotation type
+             * @param <T> data type
+             * @return this builder
+             * @since 4.0.0
+             */
+            <A extends Annotation, T> Builder addProcessor(Class<A> definition, Class<T> valueType, Processor.AdvancedFactory<A, T> factory);
+
             /**
              * Register a {@link Constraint} that will be used to validate fields.
              *

core/src/main/java/org/spongepowered/configurate/objectmapping/ObjectMapperFactoryImpl.java

@@ -25,6 +25,17 @@
 import static java.util.Objects.requireNonNull;
 
 import io.leangen.geantyref.GenericTypeReflector;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.spongepowered.configurate.BasicConfigurationNode;
 import org.spongepowered.configurate.ConfigurationNode;
@@ -42,18 +53,6 @@
 import org.spongepowered.configurate.util.NamingScheme;
 import org.spongepowered.configurate.util.NamingSchemes;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.AnnotatedType;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
 /**
  * Factory for a basic {@link ObjectMapper}.
  */
@@ -72,7 +71,7 @@ protected boolean removeEldestEntry(final Map.Entry<Type, ObjectMapper<?>> eldes
     private final List<NodeResolver.Factory> resolverFactories;
     private final List<FieldDiscoverer<?>> fieldDiscoverers;
     private final Map<Class<? extends Annotation>, List<Definition<?, ?, ? extends Constraint.Factory<?, ?>>>> constraints;
-    private final Map<Class<? extends Annotation>, List<Definition<?, ?, ? extends Processor.Factory<?, ?>>>> processors;
+    private final Map<Class<? extends Annotation>, List<Definition<?, ?, ? extends Processor.AdvancedFactory<?, ?>>>> processors;
     private final List<PostProcessor.Factory> postProcessors;
 
     ObjectMapperFactoryImpl(final Builder builder) {
@@ -97,7 +96,7 @@ protected boolean removeEldestEntry(final Map.Entry<Type, ObjectMapper<?>> eldes
         this.constraints.values().forEach(Collections::reverse);
 
         this.processors = new HashMap<>();
-        for (final Definition<?, ?, ? extends Processor.Factory<?, ?>> def : builder.processors) {
+        for (final Definition<?, ?, ? extends Processor.AdvancedFactory<?, ?>> def : builder.processors) {
             this.processors.computeIfAbsent(def.annotation(), k -> new ArrayList<>()).add(def);
         }
         this.processors.values().forEach(Collections::reverse);
@@ -206,11 +205,11 @@ private <I, O> void makeData(final List<FieldData<I, O>> fields, final String na
                 }
             }
 
-            final List<Definition<?, ?, ? extends Processor.Factory<?, ?>>> processorDefs = this.processors.get(annotation.annotationType());
+            final List<Definition<?, ?, ? extends Processor.AdvancedFactory<?, ?>>> processorDefs = this.processors.get(annotation.annotationType());
             if (processorDefs != null) {
-                for (final Definition<?, ?, ? extends Processor.Factory<?, ?>> processorDef : processorDefs) {
+                for (final Definition<?, ?, ? extends Processor.AdvancedFactory<?, ?>> processorDef : processorDefs) {
                     if (isSuperType(processorDef.type(), normalizedType)) {
-                        processors.add(((Processor.Factory) processorDef.factory()).make(annotation, type.getType()));
+                        processors.add(((Processor.AdvancedFactory) processorDef.factory()).make(annotation, type.getType(), container));
                     }
                 }
             }
@@ -356,7 +355,7 @@ static class Builder implements ObjectMapper.Factory.Builder {
         private final List<NodeResolver.Factory> resolvers = new ArrayList<>();
         private final List<FieldDiscoverer<?>> discoverer = new ArrayList<>();
         private final List<Definition<?, ?, ? extends Constraint.Factory<?, ?>>> constraints = new ArrayList<>();
-        private final List<Definition<?, ?, ? extends Processor.Factory<?, ?>>> processors = new ArrayList<>();
+        private final List<Definition<?, ?, ? extends Processor.AdvancedFactory<?, ?>>> processors = new ArrayList<>();
         private final List<PostProcessor.Factory> postProcessors = new ArrayList<>();
 
         @Override
@@ -384,6 +383,13 @@ public <A extends Annotation, T> Builder addProcessor(final Class<A> definition,
             return this;
         }
 
+        @Override
+        public <A extends Annotation, T> Builder addProcessor(final Class<A> definition, final Class<T> valueType,
+                final Processor.AdvancedFactory<A, T> factory) {
+            this.processors.add(Definition.of(definition, valueType, factory));
+            return this;
+        }
+
         @Override
         public <A extends Annotation, T> Builder addConstraint(final Class<A> definition, final Class<T> valueType,
                 final Constraint.Factory<A, T> factory) {

core/src/main/java/org/spongepowered/configurate/objectmapping/meta/Comment.java

@@ -33,7 +33,7 @@
  *
  * @since 4.0.0
  */
-@Target({ElementType.FIELD, ElementType.PARAMETER})
+@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Comment {
 

core/src/main/java/org/spongepowered/configurate/objectmapping/meta/Matches.java

@@ -35,7 +35,7 @@
  */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
+@Target({ElementType.FIELD, ElementType.METHOD})
 public @interface Matches {
 
     /**

core/src/main/java/org/spongepowered/configurate/objectmapping/meta/Processor.java

@@ -16,6 +16,7 @@
  */
 package org.spongepowered.configurate.objectmapping.meta;
 
+import java.lang.reflect.AnnotatedElement;
 import org.spongepowered.configurate.CommentedConfigurationNodeIntermediary;
 import org.spongepowered.configurate.ConfigurationNode;
 
@@ -40,6 +41,31 @@ public interface Processor<V> {
      */
     void process(V value, ConfigurationNode destination);
 
+    /**
+     * Provider to, given an annotation instance and the type it's on,
+     * create a {@link Processor}. If you don't need access to the other
+     * annotations on the field, you can also choose the simpler {@link Factory}.
+     *
+     * @param <A> annotation type
+     * @param <T> handled value type
+     * @since 4.0.0
+     */
+    @FunctionalInterface
+    interface AdvancedFactory<A extends Annotation, T> {
+
+        /**
+         * Create a new processor given the annotation and data type.
+         *
+         * @param data annotation type on record field
+         * @param value declared field type
+         * @param container container holding the field, with its annotations
+         * @return new processor
+         * @since 4.0.0
+         */
+        Processor<T> make(A data, Type value, AnnotatedElement container);
+
+    }
+
     /**
      * Provider to, given an annotation instance and the type it's on,
      * create a {@link Processor}.
@@ -49,7 +75,7 @@ public interface Processor<V> {
      * @since 4.0.0
      */
     @FunctionalInterface
-    interface Factory<A extends Annotation, T> {
+    interface Factory<A extends Annotation, T> extends AdvancedFactory<A, T> {
 
         /**
          * Create a new processor given the annotation and data type.
@@ -61,6 +87,10 @@ interface Factory<A extends Annotation, T> {
          */
         Processor<T> make(A data, Type value);
 
+        @Override
+        default Processor<T> make(A data, Type value, AnnotatedElement element) {
+            return make(data, value);
+        }
     }
 
     /**

core/src/main/java/org/spongepowered/configurate/objectmapping/meta/Required.java

@@ -34,7 +34,7 @@
  */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
+@Target({ElementType.FIELD, ElementType.METHOD})
 @SubtypeOf(NonNull.class)
 public @interface Required {
 }

extra/interface/ap/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id "org.spongepowered.configurate.build.component"
+}
+
+description = "Annotation processor for Configurate to generate an implementation for config interfaces"
+
+dependencies {
+    implementation projects.core
+    implementation projects.extra.extraInterface
+    implementation libs.javapoet
+    implementation libs.auto.service
+    annotationProcessor libs.auto.service
+
+    testImplementation libs.compile.testing
+}
+
+// there is no javadoc
+tasks.withType(Javadoc).configureEach { enabled = false }
+
+tasks.withType(Test).configureEach {
+    // See: https://github.com/google/compile-testing/issues/222
+    jvmArgs '--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED'
+    jvmArgs '--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED'
+    jvmArgs '--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'
+}

extra/interface/ap/src/main/java/org/spongepowered/configurate/interfaces/processor/AnnotationConfigurate.java

@@ -0,0 +1,30 @@
+package org.spongepowered.configurate.interfaces.processor;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.FieldSpec;
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.List;
+import javax.lang.model.element.ExecutableElement;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.spongepowered.configurate.objectmapping.meta.Comment;
+import org.spongepowered.configurate.objectmapping.meta.Matches;
+import org.spongepowered.configurate.objectmapping.meta.Required;
+
+final class AnnotationConfigurate {
+
+    private static final List<Class<? extends Annotation>> annotations = Arrays.asList(Comment.class, Matches.class, Required.class);
+
+    private AnnotationConfigurate() {}
+
+    static void process(final ExecutableElement element, final FieldSpec.Builder fieldSpec) {
+        for (final Class<? extends Annotation> annotation : annotations) {
+            final @Nullable Annotation current = element.getAnnotation(annotation);
+            //noinspection ConstantValue
+            if (current != null) {
+                fieldSpec.addAnnotation(AnnotationSpec.get(current));
+            }
+        }
+    }
+
+}

extra/interface/ap/src/main/java/org/spongepowered/configurate/interfaces/processor/AnnotationDefaults.java

@@ -0,0 +1,88 @@
+package org.spongepowered.configurate.interfaces.processor;
+
+import com.google.auto.common.MoreTypes;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import java.lang.annotation.Annotation;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.TypeMirror;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.spongepowered.configurate.interfaces.meta.defaults.DefaultBoolean;
+import org.spongepowered.configurate.interfaces.meta.defaults.DefaultDecimal;
+import org.spongepowered.configurate.interfaces.meta.defaults.DefaultNumeric;
+import org.spongepowered.configurate.interfaces.meta.defaults.DefaultString;
+
+final class AnnotationDefaults {
+
+    private AnnotationDefaults() {}
+
+    static void process(final ExecutableElement element, final TypeMirror nodeType, final FieldSpec.Builder fieldSpec) {
+        final @Nullable DefaultBoolean defaultBoolean = element.getAnnotation(DefaultBoolean.class);
+        final @Nullable DefaultDecimal defaultDecimal = element.getAnnotation(DefaultDecimal.class);
+        final @Nullable DefaultNumeric defaultNumeric = element.getAnnotation(DefaultNumeric.class);
+        final @Nullable DefaultString defaultString = element.getAnnotation(DefaultString.class);
+        //noinspection ConstantValue not everything is nonnull by default
+        final boolean hasDefault = defaultBoolean != null || defaultDecimal != null || defaultNumeric != null || defaultString != null;
+
+        @Nullable Object defaultValue = null;
+        boolean isString = false;
+        //noinspection ConstantValue
+        if (hasDefault) {
+            if (MoreTypes.isTypeOf(Boolean.TYPE, nodeType)) {
+                //noinspection ConstantValue
+                if (defaultBoolean == null) {
+                    throw new IllegalStateException("A default value of the incorrect type was provided for " + element);
+                }
+                defaultValue = defaultBoolean.value();
+                buildAndAddAnnotation(fieldSpec, DefaultBoolean.class, defaultValue, false);
+
+            } else if (Utils.isDecimal(nodeType)) {
+                //noinspection ConstantValue
+                if (defaultDecimal == null) {
+                    throw new IllegalStateException("A default value of the incorrect type was provided for " + element);
+                }
+                defaultValue = defaultDecimal.value() + (MoreTypes.isTypeOf(Float.TYPE, nodeType) ? "F" : "D");
+                buildAndAddAnnotation(fieldSpec, DefaultDecimal.class, defaultValue, false);
+
+            } else if (Utils.isNumeric(nodeType)) {
+                //noinspection ConstantValue
+                if (defaultNumeric == null) {
+                    throw new IllegalStateException("A default value of the incorrect type was provided for " + element);
+                }
+                defaultValue = defaultNumeric.value();
+                if (MoreTypes.isTypeOf(Long.TYPE, nodeType)) {
+                    defaultValue += "L";
+                }
+                buildAndAddAnnotation(fieldSpec, DefaultNumeric.class, defaultValue, false);
+
+            } else if (MoreTypes.isTypeOf(String.class, nodeType)) {
+                //noinspection ConstantValue
+                if (defaultString == null) {
+                    throw new IllegalStateException("A default value of the incorrect type was provided for " + element);
+                }
+                defaultValue = defaultString.value();
+                isString = true;
+                buildAndAddAnnotation(fieldSpec, DefaultString.class, defaultValue, true);
+            }
+        }
+
+        if (defaultValue != null) {
+            fieldSpec.initializer(isString ? "$S" : "$L", defaultValue);
+        }
+    }
+
+    private static void buildAndAddAnnotation(
+        final FieldSpec.Builder fieldSpec,
+        final Class<? extends Annotation> annotationClass,
+        final Object value,
+        final boolean isString
+    ) {
+        fieldSpec.addAnnotation(
+            AnnotationSpec.builder(annotationClass)
+                .addMember("value", CodeBlock.of(isString ? "$S" : "$L", value))
+                .build()
+        );
+    }
+
+}

extra/interface/ap/src/main/java/org/spongepowered/configurate/interfaces/processor/AnnotationHidden.java

@@ -0,0 +1,17 @@
+package org.spongepowered.configurate.interfaces.processor;
+
+import com.squareup.javapoet.FieldSpec;
+import javax.lang.model.element.ExecutableElement;
+import org.spongepowered.configurate.interfaces.meta.Hidden;
+
+final class AnnotationHidden {
+
+    private AnnotationHidden() {}
+
+    static void process(final ExecutableElement element, final FieldSpec.Builder fieldSpec) {
+        if (Utils.hasAnnotation(element, Hidden.class)) {
+            fieldSpec.addAnnotation(Hidden.class);
+        }
+    }
+
+}