Fix cascade validation to Iterable

blackbox-test/src/main/java/example/avaje/cascade/ACrew.java

@@ -0,0 +1,8 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.Valid;
+
+@Valid
+public record ACrew (@NotBlank(max = 4) String name, String role) {
+}

blackbox-test/src/main/java/example/avaje/cascade/AShip.java

@@ -0,0 +1,12 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.Valid;
+
+import java.util.List;
+
+@Valid
+public record AShip(
+  @NotBlank String name,
+  @Valid List<ACrew> crew // cascade validation
+) { }

blackbox-test/src/main/java/example/avaje/cascade/AShip2.java

@@ -0,0 +1,13 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.NotEmpty;
+import io.avaje.validation.constraints.Valid;
+
+import java.util.List;
+
+@Valid
+public record AShip2(
+  @NotBlank String name,
+  @Valid @NotEmpty List<ACrew> crew // not empty + cascade
+) { }

blackbox-test/src/main/java/example/avaje/cascade/AShip3.java

@@ -0,0 +1,13 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.constraints.NotBlank;
+import io.avaje.validation.constraints.NotEmpty;
+import io.avaje.validation.constraints.Valid;
+
+import java.util.List;
+
+@Valid
+public record AShip3(
+  @NotBlank String name,
+  @NotEmpty List<ACrew> crew // not empty but no cascade validation
+) { }

blackbox-test/src/test/java/example/avaje/cascade/AShipTest.java

@@ -0,0 +1,98 @@
+package example.avaje.cascade;
+
+import io.avaje.validation.ConstraintViolation;
+import io.avaje.validation.ConstraintViolationException;
+import io.avaje.validation.Validator;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+class AShipTest {
+
+  Validator validator = Validator.builder().build();
+
+  @Test
+  void valid() {
+    var ship = new AShip("lollyPop", List.of(new ACrew("ok", null)));
+    validator.validate(ship);
+  }
+
+  @Test
+  void validAllowEmptyCollection() {
+    var ship = new AShip("lollyPop", List.of());
+    validator.validate(ship);
+  }
+
+  @Test
+  void validAllowNullCollection() {
+    var ship = new AShip("lollyPop", null);
+    validator.validate(ship);
+  }
+
+  @Test
+  void valid2() {
+    var ship = new AShip2("lollyPop", List.of(new ACrew("ok", null)));
+    validator.validate(ship);
+  }
+
+  @Test
+  void valid3_expect_noCascadeValidationToCrew() {
+    var ship = new AShip3("lollyPop", List.of(new ACrew("NotValid", null)));
+    validator.validate(ship);
+  }
+
+  @Test
+  void invalid() {
+    var ship = new AShip("", List.of(new ACrew("NotValid", null)));
+    List<ConstraintViolation> violations = violations(ship);
+
+    assertThat(violations).hasSize(2);
+    assertThat(violations.get(0).path()).isEqualTo("name");
+    assertThat(violations.get(0).message()).isEqualTo("must not be blank");
+    assertThat(violations.get(1).path()).isEqualTo("crew[0].name");
+    assertThat(violations.get(1).message()).isEqualTo("maximum length 4 exceeded");
+  }
+
+  @Test
+  void invalidShip2_expect_InvalidEmptyCollection() {
+    var ship = new AShip2("", List.of());
+    List<ConstraintViolation> violations = violations(ship);
+
+    assertThat(violations).hasSize(2);
+    assertThat(violations.get(0).path()).isEqualTo("name");
+    assertThat(violations.get(0).message()).isEqualTo("must not be blank");
+    assertThat(violations.get(1).path()).isEqualTo("crew");
+    assertThat(violations.get(1).message()).isEqualTo("must not be empty");
+  }
+
+  @Test
+  void invalidShip2_when_nullCollection_expect_InvalidEmptyCollection() {
+    var ship = new AShip2("", null);
+    List<ConstraintViolation> violations = violations(ship);
+
+    assertThat(violations).hasSize(2);
+    assertThat(violations.get(0).path()).isEqualTo("name");
+    assertThat(violations.get(0).message()).isEqualTo("must not be blank");
+    assertThat(violations.get(1).path()).isEqualTo("crew");
+    assertThat(violations.get(1).message()).isEqualTo("must not be empty");
+  }
+
+  List<ConstraintViolation> violations(Object any) {
+    return violations(any, Locale.ENGLISH);
+  }
+
+  List<ConstraintViolation> violations(Object any, Locale locale) {
+    try {
+      validator.validate(any, locale);
+      fail("not expected");
+      return null;
+    } catch (ConstraintViolationException e) {
+      return new ArrayList<>(e.violations());
+    }
+  }
+}

validator-generator/src/main/java/io/avaje/validation/generator/AdapterHelper.java

@@ -1,85 +1,95 @@
 package io.avaje.validation.generator;
 
 import java.util.Map;
+
 import static io.avaje.validation.generator.ProcessingContext.isAssignable2Interface;
 
-public class AdapterHelper {
+class AdapterHelper {
 
-  static void writeAdapterWithValues(
-      Append writer, ElementAnnotationContainer elementAnnotations, String indent, String type) {
-    boolean first = true;
+  private final Append writer;
+  private final ElementAnnotationContainer elementAnnotations;
+  private final String indent;
+  private final String type;
+  private final GenericType topType;
+  private final GenericType genericType;
+
+  AdapterHelper(Append writer, ElementAnnotationContainer elementAnnotations, String indent) {
+    this(writer, elementAnnotations, indent,"Object", null);
+  }
+
+  AdapterHelper(Append writer, ElementAnnotationContainer elementAnnotations, String indent, String type, GenericType topType) {
+    this.writer = writer;
+    this.elementAnnotations = elementAnnotations;
+    this.indent = indent;
+    this.type = type;
+    this.topType = topType;
+    this.genericType = elementAnnotations.genericType();
+  }
+
+  void write() {
     final var annotations = elementAnnotations.annotations();
-    final var genericType = elementAnnotations.genericType();
     final var typeUse1 = elementAnnotations.typeUse1();
     final var typeUse2 = elementAnnotations.typeUse2();
     final var hasValid = elementAnnotations.hasValid();
+    boolean first = true;
     for (final var a : annotations.entrySet()) {
       if (first) {
-        writer.append(
-            "%sctx.<%s>adapter(%s.class, %s)", indent, type, a.getKey().shortName(), a.getValue());
+        writer.append("%sctx.<%s>adapter(%s.class, %s)", indent, type, a.getKey().shortName(), a.getValue());
         first = false;
         continue;
       }
-      writer
-          .eol()
-          .append(
-              "%s    .andThen(ctx.adapter(%s.class,%s))",
-              indent, a.getKey().shortName(), a.getValue());
+      writer.eol().append("%s    .andThen(ctx.adapter(%s.class,%s))", indent, a.getKey().shortName(), a.getValue());
     }
 
     if (annotations.isEmpty()) {
       writer.append("%sctx.<%s>noop()", indent, type);
     }
 
-    if (!typeUse1.isEmpty()
-        && (isAssignable2Interface(genericType.topType(), "java.lang.Iterable"))) {
+    if (!typeUse1.isEmpty() && (isAssignable2Interface(genericType.topType(), "java.lang.Iterable"))) {
       writer.eol().append("%s    .list()", indent);
-      final var t = genericType.firstParamType();
-      writeTypeUse(writer, indent, t, typeUse1, genericType);
+      writeTypeUse(genericType.firstParamType(), typeUse1);
+
+    } else if (isTopTypeIterable()) {
+      writer.eol().append("%s    .list()", indent);
+      if (hasValid) {
+        // cascade validate
+        writer.eol().append("%s    .andThenMulti(ctx.adapter(%s.class))", indent, Util.shortName(topType.firstParamType()));
+      }
 
     } else if ((!typeUse1.isEmpty() || !typeUse2.isEmpty())
         && "java.util.Map".equals(genericType.topType())) {
 
       writer.eol().append("%s    .mapKeys()", indent);
-      writeTypeUse(writer, indent, genericType.firstParamType(), typeUse1, genericType);
+      writeTypeUse(genericType.firstParamType(), typeUse1);
 
       writer.eol().append("%s    .mapValues()", indent);
-      writeTypeUse(writer, indent, genericType.secondParamType(), typeUse2, false, genericType);
+      writeTypeUse(genericType.secondParamType(), typeUse2, false);
 
     } else if (genericType.topType().contains("[]") && hasValid) {
-
       writer.eol().append("%s    .array()", indent);
-      writeTypeUse(writer, indent, genericType.firstParamType(), typeUse1, genericType);
+      writeTypeUse(genericType.firstParamType(), typeUse1);
+
     } else if (hasValid) {
-      writer
-          .eol()
-          .append(
-              "%s    .andThen(ctx.adapter(%s.class))",
-              indent, Util.shortName(genericType.topType()));
+      writer.eol().append("%s    .andThen(ctx.adapter(%s.class))", indent, Util.shortName(genericType.topType()));
+
     } else if (genericType.topType().contains("java.util.Optional")) {
       writer.eol().append("%s    .optional()", indent);
     }
   }
 
-  private static void writeTypeUse(
-      Append writer,
-      String indent,
-      String firstParamType,
-      Map<GenericType, String> typeUse12,
-      GenericType genericType) {
-    writeTypeUse(writer, indent, firstParamType, typeUse12, true, genericType);
+  private boolean isTopTypeIterable() {
+    if (topType != null && isAssignable2Interface(topType.topType(), "java.lang.Iterable")) {
+      return true;
+    }
+    return false;
   }
 
-  private static void writeTypeUse(
-      Append writer,
-      String indent,
-      String paramType,
-      Map<GenericType, String> typeUseMap,
-      boolean keys,
-      GenericType genericType) {
+  private void writeTypeUse(String firstParamType, Map<GenericType, String> typeUse12) {
+    writeTypeUse(firstParamType, typeUse12, true);
+  }
 
+  private void writeTypeUse(String paramType, Map<GenericType, String> typeUseMap, boolean keys) {
     for (final var a : typeUseMap.entrySet()) {
-
       if (Constants.VALID_ANNOTATIONS.contains(a.getKey().topType())) {
         continue;
       }

validator-generator/src/main/java/io/avaje/validation/generator/FieldReader.java

@@ -157,8 +157,9 @@ public GenericType type() {
   public void writeConstructor(Append writer) {
     writer.append("    this.%s = ", adapterFieldName).eol();
 
-    AdapterHelper.writeAdapterWithValues(
-        writer, elementAnnotations, "        ", PrimitiveUtil.wrap(genericType.shortType()));
+    new AdapterHelper(
+        writer, elementAnnotations, "        ", PrimitiveUtil.wrap(genericType.shortType()), genericType)
+      .write();
     writer.append(";").eol().eol();
   }
 }

validator-generator/src/main/java/io/avaje/validation/generator/ValidMethodReader.java

@@ -92,7 +92,7 @@ public List<ValidationAdapter<Object>> paramAdapters(ValidationContext ctx) {
     writer.append("    return List.of(");
     final var size = paramAnnotations.size();
     for (int i = 0; i < paramAnnotations.size(); i++) {
-      AdapterHelper.writeAdapterWithValues(writer, paramAnnotations.get(i), "\n        ", "Object");
+      new AdapterHelper(writer, paramAnnotations.get(i), "\n        ").write();
       if (i + 1 != size) {
         writer.append(",");
       }
@@ -107,7 +107,7 @@ public List<ValidationAdapter<Object>> paramAdapters(ValidationContext ctx) {
       public ValidationAdapter<Object> returnAdapter(ValidationContext ctx) {
     """);
     writer.append("    return ");
-    AdapterHelper.writeAdapterWithValues(writer, returnElementAnnotation, "", "Object");
+    new AdapterHelper(writer, returnElementAnnotation, "").write();
 
     writer.append(";").eol();
     writer.append("  }").eol();

validator/src/main/java/io/avaje/validation/adapter/AbstractContainerAdapter.java

@@ -7,7 +7,7 @@
 public abstract class AbstractContainerAdapter<T> implements ValidationAdapter<T> {
 
 	/**
-	 * Adapter placed on the the container type
+	 * Adapter placed on the container type
 	 */
   protected final ValidationAdapter<T> initalAdapter;
 
@@ -33,7 +33,7 @@ public AbstractContainerAdapter<T> andThenMulti(ValidationAdapter<?> adapter) {
 
   /** Execute validations for all items in the given iterable */
   protected boolean validateAll(Iterable<Object> value, ValidationRequest req, String propertyName) {
-    if (value == null) {
+    if (value == null || multiAdapter == null) {
       return true;
     }
     if (propertyName != null) {