Merge pull request #246 from muehmar/149-inner-class-which-contains-a…

…ll-stages-of-the-builder

149 inner class which contains all stages of the builder

gradle.properties

@@ -1 +1 @@
-version=2.6.2-SNAPSHOT
+version=3.0.0-SNAPSHOT

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/JavaPojoGenerator.java

@@ -1,7 +1,7 @@
 package com.github.muehmar.gradle.openapi.generator.java;
 
-import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.compositioncontainer.anyof.AnyOfContainerGenerator.anyOfContainerGenerator;
-import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.compositioncontainer.oneof.OneOfContainerGenerator.oneOfContainerGenerator;
+import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.compositioncontainer.multipojo.MultiPojoContainerGenerator.multiPojoContainerGenerator;
+import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.compositioncontainer.singlepojo.SinglePojoContainerGenerator.singlePojoContainerGenerator;
 import static io.github.muehmar.codegenerator.writer.Writer.javaWriter;
 
 import ch.bluecare.commons.data.NonEmptyList;
@@ -15,13 +15,12 @@
 import com.github.muehmar.gradle.openapi.generator.java.model.pojo.JavaEnumPojo;
 import com.github.muehmar.gradle.openapi.generator.java.model.pojo.JavaObjectPojo;
 import com.github.muehmar.gradle.openapi.generator.java.model.pojo.JavaPojo;
-import com.github.muehmar.gradle.openapi.generator.java.model.pojo.auxiliaryy.AnyOfContainer;
-import com.github.muehmar.gradle.openapi.generator.java.model.pojo.auxiliaryy.OneOfContainer;
+import com.github.muehmar.gradle.openapi.generator.java.model.pojo.auxiliary.MultiPojoContainer;
+import com.github.muehmar.gradle.openapi.generator.java.model.pojo.auxiliary.SinglePojoContainer;
 import com.github.muehmar.gradle.openapi.generator.model.Pojo;
 import com.github.muehmar.gradle.openapi.generator.settings.PojoSettings;
 import com.github.muehmar.gradle.openapi.writer.GeneratedFile;
 import io.github.muehmar.codegenerator.writer.Writer;
-import java.util.Optional;
 
 public class JavaPojoGenerator implements PojoGenerator {
 
@@ -63,29 +62,32 @@ private Writer generateArrayPojo(JavaArrayPojo pojo, Writer writer, PojoSettings
   }
 
   private PList<GeneratedFile> generateAuxiliaryPojoFiles(JavaPojo pojo, PojoSettings settings) {
-    final Optional<GeneratedFile> oneOfContainerFile =
+    final PList<GeneratedFile> singlePojoContainerFiles =
         pojo.asObjectPojo()
-            .flatMap(JavaObjectPojo::getOneOfContainer)
-            .map(container -> createOneOfContainerFile(container, settings));
-    final Optional<GeneratedFile> anyOfContainerFile =
+            .map(JavaObjectPojo::getSinglePojoContainers)
+            .orElseGet(PList::empty)
+            .map(container -> createSinglePojoContainerFile(container, settings));
+    final PList<GeneratedFile> multiPojoContainerFiles =
         pojo.asObjectPojo()
-            .flatMap(JavaObjectPojo::getAnyOfContainer)
-            .map(container -> createAnyOfContainerFile(container, settings));
-    return PList.fromOptional(oneOfContainerFile).concat(PList.fromOptional(anyOfContainerFile));
+            .map(JavaObjectPojo::getMultiPojoContainer)
+            .orElseGet(PList::empty)
+            .map(container -> createMultiPojoContainerFile(container, settings));
+    return singlePojoContainerFiles.concat(multiPojoContainerFiles);
   }
 
-  private static GeneratedFile createOneOfContainerFile(
-      OneOfContainer container, PojoSettings settings) {
-    final Writer writer = oneOfContainerGenerator().generate(container, settings, javaWriter());
+  private static GeneratedFile createSinglePojoContainerFile(
+      SinglePojoContainer container, PojoSettings settings) {
+    final Writer writer =
+        singlePojoContainerGenerator().generate(container, settings, javaWriter());
     final String content = writer.asString();
     final JavaFileName javaFileName =
         JavaFileName.fromSettingsAndClassname(settings, container.getContainerName());
     return new GeneratedFile(javaFileName.asPath(), content);
   }
 
-  private static GeneratedFile createAnyOfContainerFile(
-      AnyOfContainer container, PojoSettings settings) {
-    final Writer writer = anyOfContainerGenerator().generate(container, settings, javaWriter());
+  private static GeneratedFile createMultiPojoContainerFile(
+      MultiPojoContainer container, PojoSettings settings) {
+    final Writer writer = multiPojoContainerGenerator().generate(container, settings, javaWriter());
     final String content = writer.asString();
     final JavaFileName javaFileName =
         JavaFileName.fromSettingsAndClassname(settings, container.getContainerName());

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/generator/array/ValidatorClassGenerator.java

@@ -46,7 +46,7 @@ private static Generator<JavaArrayPojo, PojoSettings> isValidMethod() {
         .methodName("isValid")
         .noArguments()
         .doesNotThrow()
-        .content(isValidMethodContent(valueValidationCondition()))
+        .content(isValidMethodContent(itemsValidationCondition()))
         .build();
   }
 
@@ -61,15 +61,12 @@ private static Generator<JavaArrayPojo, PojoSettings> isValidMethodContent(
     };
   }
 
-  private static Condition valueValidationCondition() {
-    return Condition.constant("isValueValid()");
+  private static Condition itemsValidationCondition() {
+    return (pojo, settings, writer) ->
+        writer.print("is%sValid()", pojo.getArrayPojoMember().getName().startUpperCase());
   }
 
   private interface Condition extends Generator<JavaArrayPojo, PojoSettings> {
-    static Condition constant(String constant) {
-      return (p, s, w) -> w.print(constant);
-    }
-
     @Override
     default Condition filter(Predicate<JavaArrayPojo> predicate) {
       final Generator<JavaArrayPojo, PojoSettings> self = this;

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/generator/pojo/ObjectPojoGenerator.java

@@ -4,13 +4,12 @@
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.PojoPropertyCountMethod.pojoPropertyCountMethoGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.WitherGenerator.witherGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.builder.NormalBuilderGenerator.normalBuilderGenerator;
-import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.AnyOfFoldValidationGenerator.anyOfFoldValidationGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.CompositionGetterGenerator.compositionGetterGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.ConversionMethodGenerator.conversionMethodGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.DiscriminatorValidationMethodGenerator.discriminatorValidationMethodGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.FoldMethodGenerator.foldMethodGenerator;
+import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.FoldValidationGenerator.foldValidationGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.InvalidCompositionDtoGetterGenerator.invalidCompositionDtoGetterGenerator;
-import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.OneOfFoldValidationGenerator.oneOfFoldValidationGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.ValidCountMethodGenerator.validCountMethodGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.ValidCountValidationMethod.validCountValidationMethodGenerator;
 import static com.github.muehmar.gradle.openapi.generator.java.generator.pojo.composition.ValidationMethodGenerator.validationMethodGenerator;
@@ -35,7 +34,6 @@
 
 import com.github.muehmar.gradle.openapi.generator.java.generator.enumpojo.EnumGenerator;
 import com.github.muehmar.gradle.openapi.generator.java.generator.pojo.safebuilder.SafeBuilderGenerator;
-import com.github.muehmar.gradle.openapi.generator.java.generator.pojo.safebuilder.SafeBuilderVariant;
 import com.github.muehmar.gradle.openapi.generator.java.generator.shared.PackageGenerator;
 import com.github.muehmar.gradle.openapi.generator.java.generator.shared.jackson.JacksonAnnotationGenerator;
 import com.github.muehmar.gradle.openapi.generator.java.model.member.JavaPojoMember;
@@ -131,9 +129,7 @@ private static Generator<JavaObjectPojo, PojoSettings> customValidationMethods()
         .appendSingleBlankLine()
         .append(validCountValidationMethodGenerator())
         .appendSingleBlankLine()
-        .append(oneOfFoldValidationGenerator())
-        .appendSingleBlankLine()
-        .append(anyOfFoldValidationGenerator())
+        .append(foldValidationGenerator())
         .appendSingleBlankLine()
         .append(discriminatorValidationMethodGenerator())
         .appendSingleBlankLine()
@@ -167,8 +163,6 @@ private static Generator<JavaObjectPojo, PojoSettings> builders() {
     return Generator.<JavaObjectPojo, PojoSettings>emptyGen()
         .append(normalBuilderGenerator())
         .appendSingleBlankLine()
-        .append(new SafeBuilderGenerator(SafeBuilderVariant.FULL))
-        .appendSingleBlankLine()
-        .append(new SafeBuilderGenerator(SafeBuilderVariant.STANDARD));
+        .append(new SafeBuilderGenerator());
   }
 }

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/generator/pojo/builder/DtoSetterGenerator.java

@@ -7,7 +7,7 @@
 
 import ch.bluecare.commons.data.NonEmptyList;
 import ch.bluecare.commons.data.PList;
-import com.github.muehmar.gradle.openapi.generator.java.model.composition.JavaOneOfComposition;
+import com.github.muehmar.gradle.openapi.generator.java.model.composition.JavaDiscriminator;
 import com.github.muehmar.gradle.openapi.generator.java.model.member.JavaPojoMember;
 import com.github.muehmar.gradle.openapi.generator.java.model.name.JavaName;
 import com.github.muehmar.gradle.openapi.generator.java.model.pojo.JavaObjectPojo;
@@ -24,11 +24,7 @@ private DtoSetterGenerator() {}
 
   public static Generator<JavaObjectPojo, PojoSettings> dtoSetterGenerator() {
     return Generator.<JavaObjectPojo, PojoSettings>emptyGen()
-        .appendOptional(dtoSetters(), ParentPojoAndComposedPojos::forAllOfComposition)
-        .appendSingleBlankLine()
-        .appendOptional(dtoSetters(), ParentPojoAndComposedPojos::forOneOfComposition)
-        .appendSingleBlankLine()
-        .appendOptional(dtoSetters(), ParentPojoAndComposedPojos::forAnyOfComposition);
+        .appendList(dtoSetters(), ParentPojoAndComposedPojos::fromParentPojo, newLine());
   }
 
   private static Generator<ParentPojoAndComposedPojos, PojoSettings> dtoSetters() {
@@ -91,45 +87,41 @@ private static <B> Generator<ParentPojoAndComposedPojo, B> setAdditionalProperti
   @Value
   private static class ParentPojoAndComposedPojos {
     JavaObjectPojo parentPojo;
+    Optional<JavaDiscriminator> discriminator;
     NonEmptyList<JavaObjectPojo> composedPojos;
 
-    private static Optional<ParentPojoAndComposedPojos> forAllOfComposition(
-        JavaObjectPojo parentPojo) {
-      return parentPojo
-          .getAllOfComposition()
-          .map(
-              allOfComposition ->
-                  new ParentPojoAndComposedPojos(parentPojo, allOfComposition.getPojos()));
-    }
-
-    private static Optional<ParentPojoAndComposedPojos> forOneOfComposition(
-        JavaObjectPojo parentPojo) {
-      return parentPojo
-          .getOneOfComposition()
-          .map(
-              oneOfComposition ->
-                  new ParentPojoAndComposedPojos(parentPojo, oneOfComposition.getPojos()));
-    }
-
-    private static Optional<ParentPojoAndComposedPojos> forAnyOfComposition(
-        JavaObjectPojo parentPojo) {
-      return parentPojo
-          .getAnyOfComposition()
-          .map(
-              anyOfComposition ->
-                  new ParentPojoAndComposedPojos(parentPojo, anyOfComposition.getPojos()));
+    private static PList<ParentPojoAndComposedPojos> fromParentPojo(JavaObjectPojo parentPojo) {
+      final PList<ParentPojoAndComposedPojos> mappedAllOf =
+          PList.fromOptional(
+              parentPojo
+                  .getAllOfComposition()
+                  .map(
+                      composition ->
+                          new ParentPojoAndComposedPojos(
+                              parentPojo, Optional.empty(), composition.getPojos())));
+      final PList<ParentPojoAndComposedPojos> mappedOneOfAndAnyOf =
+          parentPojo
+              .getDiscriminatableCompositions()
+              .map(
+                  composition ->
+                      new ParentPojoAndComposedPojos(
+                          parentPojo, composition.getDiscriminator(), composition.getPojos()));
+      return mappedAllOf.concat(mappedOneOfAndAnyOf);
     }
 
     public PList<ParentPojoAndComposedPojo> getComposedPojos() {
       return composedPojos
           .toPList()
-          .map(composedPojo -> new ParentPojoAndComposedPojo(parentPojo, composedPojo));
+          .map(
+              composedPojo ->
+                  new ParentPojoAndComposedPojo(parentPojo, discriminator, composedPojo));
     }
   }
 
   @Value
   private static class ParentPojoAndComposedPojo {
     JavaObjectPojo parentPojo;
+    Optional<JavaDiscriminator> discriminator;
     JavaObjectPojo composedPojo;
 
     public JavaName prefixedClassNameForMethod(String prefix) {
@@ -139,13 +131,14 @@ public JavaName prefixedClassNameForMethod(String prefix) {
     private PList<PojosAndMember> getMembers() {
       return composedPojo
           .getAllMembers()
-          .map(member -> new PojosAndMember(parentPojo, composedPojo, member));
+          .map(member -> new PojosAndMember(parentPojo, discriminator, composedPojo, member));
     }
   }
 
   @Value
   private static class PojosAndMember {
     JavaObjectPojo parentPojo;
+    Optional<JavaDiscriminator> discriminator;
     JavaObjectPojo composedPojo;
     JavaPojoMember member;
 
@@ -157,14 +150,12 @@ public JavaName getGetterNameWithSuffix(PojoSettings settings) {
       return member.getGetterNameWithSuffix(settings);
     }
 
-    public String getDiscriminatorValue() {
+    String getDiscriminatorValue() {
       final Name schemaName = composedPojo.getSchemaName().getOriginalName();
-      return parentPojo
-          .getOneOfComposition()
-          .flatMap(JavaOneOfComposition::getDiscriminator)
+      return discriminator
           .map(
-              discriminator ->
-                  discriminator.getValueForSchemaName(
+              d ->
+                  d.getValueForSchemaName(
                       schemaName,
                       strValue -> String.format("\"%s\"", strValue),
                       enumName ->
@@ -175,16 +166,14 @@ public String getDiscriminatorValue() {
           .orElse("");
     }
 
+    private boolean isNotDiscriminatorMember() {
+      return not(isDiscriminatorMember());
+    }
+
     private boolean isDiscriminatorMember() {
-      return parentPojo
-          .getOneOfComposition()
-          .flatMap(JavaOneOfComposition::getDiscriminator)
+      return discriminator
           .filter(discriminator -> discriminator.getPropertyName().equals(member.getName()))
           .isPresent();
     }
-
-    private boolean isNotDiscriminatorMember() {
-      return not(isDiscriminatorMember());
-    }
   }
 }

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/generator/pojo/builder/MemberDeclarationGenerator.java

@@ -22,7 +22,8 @@ public static <B> Generator<JavaObjectPojo, B> memberDeclarationGenerator() {
   private static <B> Generator<JavaPojoMember, B> memberDeclaration() {
     return MemberDeclarationGenerator.<B>normalMemberDeclaration()
         .append(memberIsPresentFlagDeclaration())
-        .append(memberIsNullFlagDeclaration());
+        .append(memberIsNullFlagDeclaration())
+        .append(memberIsNotNullFlagDeclaration());
   }
 
   private static <B> Generator<JavaPojoMember, B> normalMemberDeclaration() {
@@ -45,6 +46,13 @@ private static <B> Generator<JavaPojoMember, B> memberIsNullFlagDeclaration() {
     return generator.filter(JavaPojoMember::isOptionalAndNullable);
   }
 
+  private static <B> Generator<JavaPojoMember, B> memberIsNotNullFlagDeclaration() {
+    final Generator<JavaPojoMember, B> generator =
+        (member, settings, writer) ->
+            writer.println("private boolean %s = true;", member.getIsNotNullFlagName());
+    return generator.filter(JavaPojoMember::isOptionalAndNotNullable);
+  }
+
   private static <B> Generator<JavaAdditionalProperties, B> additionalPropertiesDeclaration() {
     return Generator.<JavaAdditionalProperties, B>emptyGen()
         .append(

plugin/src/main/java/com/github/muehmar/gradle/openapi/generator/java/generator/pojo/builder/SetterGenerator.java

@@ -69,6 +69,11 @@ private static Generator<JavaPojoMember, PojoSettings> setterMethodContent() {
             (member, settings, writer) ->
                 writer.println("this.%s = true;", member.getIsPresentFlagName()),
             JavaPojoMember::isRequiredAndNullable)
+        .appendConditionally(
+            (member, settings, writer) ->
+                writer.println(
+                    "this.%s = %s != null;", member.getIsNotNullFlagName(), member.getName()),
+            JavaPojoMember::isOptionalAndNotNullable)
         .appendConditionally(
             (member, settings, writer) ->
                 writer.println(