Merge pull request #241 from muehmar/150-support-the-discriminator-wi…

…th-anyof

150 support the discriminator with anyof

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/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;
@@ -131,9 +130,7 @@ private static Generator<JavaObjectPojo, PojoSettings> customValidationMethods()
         .appendSingleBlankLine()
         .append(validCountValidationMethodGenerator())
         .appendSingleBlankLine()
-        .append(oneOfFoldValidationGenerator())
-        .appendSingleBlankLine()
-        .append(anyOfFoldValidationGenerator())
+        .append(foldValidationGenerator())
         .appendSingleBlankLine()
         .append(discriminatorValidationMethodGenerator())
         .appendSingleBlankLine()

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());
-    }
   }
 }