Merge branch 'master' into migration-guide-for-7

Author: christiangoerdes

annot/src/main/java/com/predic8/membrane/annot/SpringConfigurationXSDGeneratingAnnotationProcessor.java

@@ -221,20 +221,9 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                     if (ii.getAnnotation().component())
                         main.getComponents().put(ii.getAnnotation().name(), ii);
 
-                    if (ii.getAnnotation().noEnvelope()) {
-                        if (ii.getAnnotation().mixed())
-                            throw new ProcessingException("@MCElement(..., noEnvelope=true, mixed=true) is invalid.", ii.getElement());
-                        if (ii.getChildElementSpecs().size() != 1)
-                            throw new ProcessingException("@MCElement(noEnvelope=true) requires exactly one @MCChildElement.", ii.getElement());
-                        if (!ii.getChildElementSpecs().getFirst().isList())
-                            throw new ProcessingException("@MCElement(noEnvelope=true) requires its @MCChildElement() to be a List or Collection.", ii.getElement());
-                        if (!ii.getAis().isEmpty())
-                            throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCAttribute to be not present.", ii.getElement());
-                        if (ii.getOai() != null)
-                            throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCOtherAttributes to be not present.", ii.getElement());
-                        if (ii.getTci() != null)
-                            throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCTextContent to be not present.", ii.getElement());
-                    }
+                    validateNoEnvelope(ii);
+                    validateCollapsed(ii);
+
                     if (ii.getTci() != null && !ii.getAnnotation().mixed())
                         throw new ProcessingException("@MCTextContent requires @MCElement(..., mixed=true) on the class.", ii.getElement());
                     if (ii.getTci() == null && ii.getAnnotation().mixed())
@@ -300,6 +289,42 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         }
     }
 
+    private static void validateNoEnvelope(ElementInfo ii) {
+        if (ii.getAnnotation().noEnvelope()) {
+            if (ii.getAnnotation().mixed())
+                throw new ProcessingException("@MCElement(..., noEnvelope=true, mixed=true) is invalid.", ii.getElement());
+            if (ii.getChildElementSpecs().size() != 1)
+                throw new ProcessingException("@MCElement(noEnvelope=true) requires exactly one @MCChildElement.", ii.getElement());
+            if (!ii.getChildElementSpecs().getFirst().isList())
+                throw new ProcessingException("@MCElement(noEnvelope=true) requires its @MCChildElement() to be a List or Collection.", ii.getElement());
+            if (!ii.getAis().isEmpty())
+                throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCAttribute to be not present.", ii.getElement());
+            if (ii.getOai() != null)
+                throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCOtherAttributes to be not present.", ii.getElement());
+            if (ii.getTci() != null)
+                throw new ProcessingException("@MCElement(noEnvelope=true) requires @MCTextContent to be not present.", ii.getElement());
+        }
+    }
+
+    private static void validateCollapsed(ElementInfo ii) {
+        // A collapsed class has exactly one @MCAttribute OR exactly one @MCTextContent and no @MCElement or @MCAttribute.
+        if (ii.getAnnotation().collapsed()) {
+            int attrCount = ii.getAis().size();
+            if (hasAttributeAndTextContent(attrCount, ii))
+                throw new ProcessingException("@MCElement(collapsed=true) requires exactly one @MCAttribute OR exactly one @MCTextContent.", ii.getElement());
+            if (attrCount != 0 && attrCount != 1)
+                throw new ProcessingException("@MCElement(collapsed=true) allows only one @MCAttribute setter.", ii.getElement());
+            if (!ii.getChildElementSpecs().isEmpty())
+                throw new ProcessingException("@MCElement(collapsed=true) must not declare @MCChildElement.", ii.getElement());
+            if (ii.getOai() != null)
+                throw new ProcessingException("@MCElement(collapsed=true) must not declare @MCOtherAttributes.", ii.getElement());
+        }
+    }
+
+    private static boolean hasAttributeAndTextContent(int attrCount, ElementInfo ii) {
+        return (attrCount > 0 ? 1 : 0) + (ii.getTci() != null ? 1 : 0) != 1;
+    }
+
     private boolean isComponent(TypeElement type) {
         MCElement mcElement = type.getAnnotation(MCElement.class);
         return (mcElement != null) && mcElement.component();

annot/src/main/java/com/predic8/membrane/annot/yaml/GenericYamlParser.java

@@ -19,42 +19,32 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import com.networknt.schema.Error;
-import com.networknt.schema.Schema;
-import com.networknt.schema.SchemaLocation;
-import com.networknt.schema.SchemaRegistry;
 import com.predic8.membrane.annot.Grammar;
 import com.predic8.membrane.annot.MCAttribute;
-import com.predic8.membrane.annot.MCElement;
 import com.predic8.membrane.annot.MCTextContent;
 import com.predic8.membrane.annot.beanregistry.BeanDefinition;
 import com.predic8.membrane.annot.beanregistry.BeanLifecycleManager;
 import com.predic8.membrane.annot.beanregistry.BeanRegistry;
-import com.predic8.membrane.annot.beanregistry.BeanRegistryAware;
-import jakarta.annotation.PostConstruct;
-import jakarta.annotation.PreDestroy;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.util.ReflectionUtils;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 
-import static com.networknt.schema.SpecificationVersion.DRAFT_2020_12;
 import static com.predic8.membrane.annot.yaml.McYamlIntrospector.*;
 import static com.predic8.membrane.annot.yaml.MethodSetter.getMethodSetter;
 import static com.predic8.membrane.annot.yaml.NodeValidationUtils.*;
+import static com.predic8.membrane.annot.yaml.YamlParsingUtils.*;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.List.of;
 import static java.util.UUID.randomUUID;
-import static org.springframework.util.ReflectionUtils.doWithMethods;
 
 public class GenericYamlParser {
     private static final Logger log = LoggerFactory.getLogger(GenericYamlParser.class);
@@ -145,16 +135,6 @@ private static String getBeanType(JsonNode jsonNode) {
         return jsonNode.fieldNames().next();
     }
 
-    private static void validate(Grammar grammar, JsonNode input) throws YamlSchemaValidationException {
-        Schema schema = SchemaRegistry.withDefaultDialect(DRAFT_2020_12, builder -> {}).getSchema(SchemaLocation.of(grammar.getSchemaLocation()));
-        schema.initializeValidators();
-        List<Error> errors = schema.validate(input);
-        if (!errors.isEmpty()) {
-            throw new YamlSchemaValidationException("Invalid YAML.", errors);
-        }
-    }
-
-
     /**
      * Parse a top-level Membrane resource of the given {@code kind}.
      * <p>Ensures the node contains exactly one key (the kind), resolves the Java class via the
@@ -185,49 +165,27 @@ public static Class<?> decideClazz(String kind, Grammar grammar, JsonNode node)
     public static <T> T createAndPopulateNode(ParsingContext<?> ctx, Class<T> clazz, JsonNode node) throws ParsingException {
         try {
             T configObj = clazz.getConstructor().newInstance();
+
+            // when this is a list, we are on a @MCElement(..., noEnvelope=true)
             if (node.isArray()) {
-                // when this is a list, we are on a @MCElement(..., noEnvelope=true)
-                Method method = getSingleChildSetter(clazz);
-                method.invoke(configObj, parseListExcludingStartEvent(ctx, node));
-                return configObj;
+                return handlePostConstructAndPreDestroy(ctx, handleNoEnvelopeList(ctx, clazz, node, configObj));
             }
 
             // scalar inline form for @MCElement(collapsed=true)
             if (isCollapsed(clazz)) {
-                if (node.isNull()) {
-                    throw new ParsingException("Collapsed element must not be null.", node);
-                }
-                if (node.isArray() || node.isObject()) {
-                    throw new ParsingException("Element is collapsed; expected an inline scalar value, not " +
-                            (node.isArray() ? "an array" : "an object") + ".", node);
-                }
-                applyCollapsedScalar(clazz, node, configObj);
-                return handlePostConstructAndPreDestroy(ctx, configObj);
+                return handleCollapsed(ctx, clazz, node, configObj);
             }
             ensureMappingStart(node);
-            if (isNoEnvelope(clazz))
-                throw new RuntimeException("Class " + clazz.getName() + " is annotated with @MCElement(noEnvelope=true), but the YAML/JSON structure does not contain a list.");
+            if (isNoEnvelope(clazz)) throw new ParsingException("Class %s is annotated with @MCElement(noEnvelope=true), but the YAML/JSON structure does not contain a list.".formatted(clazz.getName()), node);
 
             JsonNode refNode = node.get("$ref");
             if (refNode != null) {
                 applyObjectLevelRef(ctx, clazz, node, refNode, configObj);
             }
 
             List<Method> required = findRequiredSetters(clazz);
+            populateObjectFields(ctx, clazz, node, required, configObj);
 
-            for (Iterator<String> it = node.fieldNames(); it.hasNext(); ) {
-                String key = it.next();
-                if ("$ref".equals(key))
-                    continue;
-
-                try {
-                    MethodSetter methodSetter = getMethodSetter(ctx, clazz, key);
-                    required.remove(methodSetter.getSetter());
-                    methodSetter.setSetter(configObj, ctx, node, key);
-                } catch (Throwable cause) {
-                    throw new ParsingException(cause, node.get(key));
-                }
-            }
             if (!required.isEmpty())
                 throw new ParsingException("Missing required fields: " + required.stream().map(McYamlIntrospector::getSetterName).toList(), node);
             return handlePostConstructAndPreDestroy(ctx, configObj);
@@ -244,6 +202,34 @@ public static <T> T createAndPopulateNode(ParsingContext<?> ctx, Class<T> clazz,
         }
     }
 
+    private static <T> void populateObjectFields(ParsingContext<?> ctx, Class<T> clazz, JsonNode node, List<Method> required, T configObj) {
+        for (Iterator<String> it = node.fieldNames(); it.hasNext(); ) {
+            String key = it.next();
+            if ("$ref".equals(key))
+                continue;
+
+            try {
+                MethodSetter methodSetter = getMethodSetter(ctx, clazz, key);
+                required.remove(methodSetter.getSetter());
+                methodSetter.setSetter(configObj, ctx, node, key);
+            } catch (Throwable cause) {
+                throw new ParsingException(cause, node.get(key));
+            }
+        }
+    }
+
+    private static <T> @NotNull T handleCollapsed(ParsingContext<?> ctx, Class<T> clazz, JsonNode node, T configObj) {
+        if (node.isNull()) throw new ParsingException("Collapsed element must not be null.", node);
+        if (node.isArray() || node.isObject()) throw new ParsingException("Element is collapsed; expected an inline scalar value, not an %s.".formatted((node.isArray() ? "array" : "object")), node);
+        applyCollapsedScalar(clazz, node, configObj);
+        return handlePostConstructAndPreDestroy(ctx, configObj);
+    }
+
+    private static <T> T handleNoEnvelopeList(ParsingContext<?> ctx, Class<T> clazz, JsonNode node, T configObj) throws IllegalAccessException, InvocationTargetException {
+        getSingleChildSetter(clazz).invoke(configObj, parseListExcludingStartEvent(ctx, node));
+        return configObj;
+    }
+
     private static List<BeanDefinition> extractComponentBeanDefinitions(JsonNode componentsNode) {
         if (componentsNode == null || componentsNode.isNull())
             return of();
@@ -341,54 +327,23 @@ private static Object parseMapToObj(ParsingContext<?> ctx, JsonNode node, String
         return createAndPopulateNode(ctx.updateContext(key), ctx.resolveClass(key), node);
     }
 
-    /**
-     * Calls the @PostConstruct method on the bean and returns it. If there are @PreDestroy methods, they will be
-     * registered within the registry.
-     */
-    private static <T> T handlePostConstructAndPreDestroy(ParsingContext<?> ctx, T bean) {
-        if (bean instanceof BeanRegistryAware beanRegistryAware) {
-            beanRegistryAware.setRegistry(ctx.registry());
-        }
-        doWithMethods(bean.getClass(), method -> {
-            if (method.isAnnotationPresent(PostConstruct.class)) {
-                try {
-                    method.setAccessible(true);
-                    method.invoke(bean);
-                } catch (InvocationTargetException e) {
-                    throw new RuntimeException(e.getTargetException());
-                } catch (IllegalAccessException | IllegalArgumentException e) {
-                    throw new RuntimeException(e);
-                }
-            }
-            if (method.isAnnotationPresent(PreDestroy.class)) {
-                method.setAccessible(true);
-                ctx.registry().addPreDestroyCallback(bean, method);
-            }
-        });
-        return bean;
-    }
-
     private static <T> void applyCollapsedScalar(Class<T> clazz, JsonNode node, T target) {
         if (node == null || node.isNull()) {
             throw new ParsingException("Collapsed element must not be null.", node);
         }
 
+        // Collapsed classes can only have one matching setter (ensured by SpringConfigurationXSDGeneratingAnnotationProcessor)
         Method attributeSetter = findSingleSetterOrNullForAnnotation(clazz, MCAttribute.class);
         Method textSetter = findSingleSetterOrNullForAnnotation(clazz, MCTextContent.class);
 
-        if ((attributeSetter == null) == (textSetter == null)) {
-            // both null or both non-null -> invalid
-            throw new ParsingException("@MCElement(collapsed=true) requires exactly one @MCAttribute setter OR exactly one @MCTextContent setter.", node);
-        }
-
         Method setter = (attributeSetter != null) ? attributeSetter : textSetter;
-        Class<?> paramType = setter.getParameterTypes()[0];
+        Class<?> paramType = Objects.requireNonNull(setter).getParameterTypes()[0];
 
         Object value;
         try {
             value = SCALAR_MAPPER.convertValue(node, paramType);
         } catch (IllegalArgumentException e) {
-            throw new ParsingException("Cannot convert inline value to " + paramType.getSimpleName() + ".", node);
+            throw new ParsingException("Cannot convert inline value to %s.".formatted(paramType.getSimpleName()), node);
         }
 
         try {
@@ -401,22 +356,6 @@ private static <T> void applyCollapsedScalar(Class<T> clazz, JsonNode node, T ta
         }
     }
 
-    private static Method findSingleSetterOrNullForAnnotation(Class<?> clazz, Class<? extends java.lang.annotation.Annotation> annotation) {
-        List<Method> setters = new ArrayList<>();
-        doWithMethods(clazz, m -> {
-            if (m.isAnnotationPresent(annotation) && m.getParameterCount() == 1) {
-                setters.add(m);
-            }
-        });
 
-        if (setters.isEmpty()) return null;
-        if (setters.size() != 1) {
-            throw new ParsingException(
-                    "Multiple @%s setters found for collapsed element.".formatted(annotation.getSimpleName()),
-                    JsonNodeFactory.instance.nullNode()
-            );
-        }
-        return setters.getFirst();
-    }
 
 }

annot/src/main/java/com/predic8/membrane/annot/yaml/YamlParsingUtils.java

@@ -0,0 +1,94 @@
+package com.predic8.membrane.annot.yaml;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.networknt.schema.Error;
+import com.networknt.schema.Schema;
+import com.networknt.schema.SchemaLocation;
+import com.networknt.schema.SchemaRegistry;
+import com.predic8.membrane.annot.Grammar;
+import com.predic8.membrane.annot.beanregistry.BeanRegistryAware;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static com.networknt.schema.SpecificationVersion.DRAFT_2020_12;
+import static org.springframework.util.ReflectionUtils.doWithMethods;
+
+public final class YamlParsingUtils {
+
+    private YamlParsingUtils() {
+    }
+
+    private record SchemaCacheKey(String schemaLocation, ClassLoader classLoader) {
+    }
+
+    private static final ConcurrentHashMap<SchemaCacheKey, Schema> SCHEMA_CACHE = new ConcurrentHashMap<>();
+
+    static void validate(Grammar grammar, JsonNode input) throws YamlSchemaValidationException {
+        List<Error> errors = loadSchema(grammar).validate(input);
+        if (!errors.isEmpty())
+            throw new YamlSchemaValidationException("Invalid YAML.", errors);
+    }
+
+    private static @NotNull Schema loadSchema(Grammar grammar) {
+        // Schema cache: prevents duplicate loads for multi-doc specs (---).
+        return SCHEMA_CACHE.computeIfAbsent(new SchemaCacheKey(grammar.getSchemaLocation(), Thread.currentThread().getContextClassLoader()), k -> {
+            Schema s = SchemaRegistry.withDefaultDialect(DRAFT_2020_12, b -> {
+                    })
+                    .getSchema(SchemaLocation.of(k.schemaLocation()));
+            s.initializeValidators();
+            return s;
+        });
+    }
+
+    /**
+     * Calls the @PostConstruct method on the bean and returns it. If there are @PreDestroy methods, they will be
+     * registered within the registry.
+     */
+    static <T> T handlePostConstructAndPreDestroy(ParsingContext<?> ctx, T bean) {
+        if (bean instanceof BeanRegistryAware beanRegistryAware) {
+            beanRegistryAware.setRegistry(ctx.registry());
+        }
+        doWithMethods(bean.getClass(), method -> {
+            if (method.isAnnotationPresent(PostConstruct.class)) invokeNoArg(bean, method);
+            if (method.isAnnotationPresent(PreDestroy.class)) {
+                method.setAccessible(true);
+                ctx.registry().addPreDestroyCallback(bean, method);
+            }
+        });
+        return bean;
+    }
+
+    private static void invokeNoArg(Object bean, Method m) {
+        try {
+            m.setAccessible(true);
+            m.invoke(bean);
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(e.getTargetException());
+        } catch (Throwable t) {
+            throw new RuntimeException(t);
+        }
+    }
+
+    /**
+     * Searches for a single setter method in the given class that is annotated with the specified annotation.
+     */
+    static Method findSingleSetterOrNullForAnnotation(Class<?> clazz, Class<? extends java.lang.annotation.Annotation> annotation) {
+        List<Method> setters = new ArrayList<>();
+        doWithMethods(clazz, m -> {
+            if (m.isAnnotationPresent(annotation) && m.getParameterCount() == 1) {
+                setters.add(m);
+            }
+        });
+
+        if (setters.isEmpty()) return null;
+        return setters.getFirst();
+    }
+
+}