Add mutiny support

README.md

@@ -33,12 +33,13 @@ You can provide the following query parameters to customize the project
 - `vertxDependencies`: a comma separated list of artifactIds of the vert.x modules
 - `packageName`: code package name, derived from `groupId` and `artifactId` by default
 - `jdkVersion`: which version of the JDK to use, defaults to `1.8`
+- `flavor`: `vert.x` or `mutiny`
 
 Full example:
 
 ```
 curl -X GET \
-  'http://start.vertx.io/starter.zip?artifactId=starter&buildTool=maven&groupId=io.vertx&language=java&vertxDependencies=&vertxVersion=4.1.1' \
+  'http://start.vertx.io/starter.zip?artifactId=starter&buildTool=maven&groupId=io.vertx&language=java&vertxDependencies=&vertxVersion=4.1.1&flavor=vert.x' \
   -o starter.zip
 ```
 
@@ -51,6 +52,7 @@ artitfactId==starter \
 language==java \
 buildTool==maven \
 vertxVersion==4.1.1 \
+flavor==vert.x \
 vertxDependencies==vertx-web,vertx-web-client \
 -o starter.zip
 ```

src/main/java/io/vertx/starter/ValidationHandler.java

@@ -43,9 +43,10 @@ public class ValidationHandler implements Handler<RoutingContext> {
   private final JsonObject defaults;
   private final Set<String> versions;
   private final Map<String, List<String>> exclusions;
-  private final Set<String> dependencies;
+  private final Map<String, Dependency> vertxStackDependencies;
+  private final Map<String, Dependency> mutinyStackDependencies;
 
-  public ValidationHandler(JsonObject defaults, JsonArray versions, JsonArray stack) {
+  public ValidationHandler(JsonObject defaults, JsonArray versions, JsonArray vertxStack, JsonArray mutinyStack) {
     this.defaults = defaults;
     this.versions = versions.stream()
       .map(JsonObject.class::cast)
@@ -57,12 +58,26 @@ public ValidationHandler(JsonObject defaults, JsonArray versions, JsonArray stac
         obj -> obj.getString("number"),
         obj -> obj.getJsonArray("exclusions", new JsonArray()).stream().map(String.class::cast).collect(toList()))
       );
-    dependencies = stack.stream()
+    vertxStackDependencies = vertxStack.stream()
       .map(JsonObject.class::cast)
       .flatMap(category -> category.getJsonArray("items").stream())
       .map(JsonObject.class::cast)
-      .map(item -> item.getString("artifactId"))
-      .collect(toSet());
+      .collect(toMap(
+        item -> item.getString("artifactId"),
+        item -> new Dependency()
+          .setGroupId(item.getString("groupId"))
+          .setArtifactId(item.getString("artifactId")))
+      );
+    mutinyStackDependencies = mutinyStack.stream()
+      .map(JsonObject.class::cast)
+      .flatMap(category -> category.getJsonArray("items").stream())
+      .map(JsonObject.class::cast)
+      .collect(toMap(
+        item -> item.getString("artifactId"),
+        item -> new Dependency()
+          .setGroupId(item.getString("groupId"))
+          .setArtifactId(item.getString("artifactId")))
+      );
   }
 
   @Override
@@ -86,6 +101,10 @@ public void handle(RoutingContext rc) {
       return;
     }
 
+    if (!validateAndSetEnum(rc, FLAVOR, ProjectFlavor::fromId, vertxProject::setFlavor)) {
+      return;
+    }
+
     String vertxVersion = getQueryParam(rc, VERTX_VERSION);
     if (isNotBlank(vertxVersion)) {
       if (!versions.contains(vertxVersion)) {
@@ -103,7 +122,21 @@ public void handle(RoutingContext rc) {
         .map(String::toLowerCase)
         .collect(toSet());
 
-      if (!dependencies.containsAll(vertxDependencies) ||
+      boolean areAllDependenciesSatisfiable;
+      if (vertxProject.getFlavor() == ProjectFlavor.VERTX) {
+        areAllDependenciesSatisfiable = vertxStackDependencies.keySet()
+          .containsAll(vertxDependencies);
+      } else if (vertxProject.getFlavor() == ProjectFlavor.MUTINY) {
+        areAllDependenciesSatisfiable = vertxDependencies.stream()
+          .allMatch(dependency ->
+            mutinyStackDependencies.keySet().stream()
+              .anyMatch(mutinyDependency -> mutinyDependency.endsWith(dependency))
+          );
+      } else {
+        throw new IllegalArgumentException("There's no stack for flavor " + vertxProject.getFlavor());
+      }
+
+      if (!areAllDependenciesSatisfiable ||
         !Collections.disjoint(exclusions.get(vertxProject.getVertxVersion()), vertxDependencies)) {
         fail(rc, VERTX_DEPENDENCIES, deps);
         return;
@@ -114,7 +147,25 @@ public void handle(RoutingContext rc) {
         return;
       }
 
-      vertxProject.setVertxDependencies(vertxDependencies);
+      Set<Dependency> flavoredDependencies;
+      if (vertxProject.getFlavor() == ProjectFlavor.VERTX) {
+        flavoredDependencies = vertxDependencies.stream()
+          .map(vertxStackDependencies::get)
+          .collect(toSet());
+      } else if (vertxProject.getFlavor() == ProjectFlavor.MUTINY) {
+        flavoredDependencies = vertxDependencies.stream()
+          .map(dependency -> mutinyStackDependencies.keySet().stream()
+            .filter(mutinyDependency -> mutinyDependency.endsWith(dependency))
+            .findFirst())
+          .filter(Optional::isPresent)
+          .map(Optional::get)
+          .map(mutinyStackDependencies::get)
+          .collect(toSet());
+      } else {
+        throw new IllegalArgumentException("Unknown project flavor " + vertxProject.getFlavor());
+      }
+
+      vertxProject.setVertxDependencies(flavoredDependencies);
     }
 
     ArchiveFormat archiveFormat = ArchiveFormat.fromFilename(rc.request().path());

src/main/java/io/vertx/starter/WebVerticle.java

@@ -56,11 +56,12 @@ public WebVerticle() {
 
       JsonObject defaults = starterData.getJsonObject("defaults");
       JsonArray versions = starterData.getJsonArray("versions");
-      JsonArray stack = starterData.getJsonArray("stack");
+      JsonArray vertxStack = starterData.getJsonArray("vertxStack");
+      JsonArray mutinyStack = starterData.getJsonArray("mutinyStack");
 
-      validationHandler = new ValidationHandler(defaults, versions, stack);
+      validationHandler = new ValidationHandler(defaults, versions, vertxStack, mutinyStack);
       generationHandler = new GenerationHandler();
-      metadataHandler = new MetadataHandler(defaults, versions, stack);
+      metadataHandler = new MetadataHandler(defaults, versions, vertxStack, mutinyStack);
 
     } catch (IOException e) {
       throw new RuntimeException(e);

src/main/java/io/vertx/starter/config/ProjectConstants.java

@@ -29,4 +29,7 @@ public interface ProjectConstants {
   String ARCHIVE_FORMAT = "archiveFormat";
   String PACKAGE_NAME = "packageName";
   String JDK_VERSION = "jdkVersion";
+  String FLAVOR = "flavor";
+  String MUTINY_FLAVOR = "mutiny";
+  String VERTX_FLAVOR = "vert.x";
 }

src/main/java/io/vertx/starter/model/Dependency.java

@@ -0,0 +1,54 @@
+package io.vertx.starter.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import java.util.Objects;
+
+public class Dependency {
+  private String groupId;
+  private String artifactId;
+
+  public String getGroupId() {
+    return groupId;
+  }
+
+  public Dependency setGroupId(String groupId) {
+    this.groupId = groupId;
+    return this;
+  }
+
+  public String getArtifactId() {
+    return artifactId;
+  }
+
+  public Dependency setArtifactId(String artifactId) {
+    this.artifactId = artifactId;
+    return this;
+  }
+
+  @JsonIgnore
+  public boolean isVertxDependency() {
+    return ProjectFlavor.VERTX.getGroupId().equals(groupId);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Dependency that = (Dependency) o;
+    return Objects.equals(groupId, that.groupId) && Objects.equals(artifactId, that.artifactId);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(groupId, artifactId);
+  }
+
+  @Override
+  public String toString() {
+    return "Dependency{" +
+      "groupId='" + groupId + '\'' +
+      ", artifactId='" + artifactId + '\'' +
+      '}';
+  }
+}

src/main/java/io/vertx/starter/model/ProjectFlavor.java

@@ -0,0 +1,42 @@
+package io.vertx.starter.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.Locale;
+
+import static io.vertx.starter.config.ProjectConstants.MUTINY_FLAVOR;
+import static io.vertx.starter.config.ProjectConstants.VERTX_FLAVOR;
+
+public enum ProjectFlavor {
+  @JsonProperty(VERTX_FLAVOR)
+  VERTX(VERTX_FLAVOR, "io.vertx"),
+  @JsonProperty(MUTINY_FLAVOR)
+  MUTINY(MUTINY_FLAVOR, "io.smallrye.reactive");
+
+  private final String id;
+  private final String groupId;
+
+  ProjectFlavor(String id, String groupId) {
+    this.id = id;
+    this.groupId = groupId;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public String getGroupId() {
+    return groupId;
+  }
+
+  public static ProjectFlavor fromId(String id) {
+    switch (id.toLowerCase(Locale.ROOT)) {
+      case MUTINY_FLAVOR:
+        return MUTINY;
+      case VERTX_FLAVOR:
+        return VERTX;
+      default:
+        return null;
+    }
+  }
+}

src/main/java/io/vertx/starter/model/VertxProject.java

@@ -27,12 +27,13 @@ public class VertxProject {
   private Language language;
   private BuildTool buildTool;
   private String vertxVersion;
-  private Set<String> vertxDependencies;
+  private Set<Dependency> vertxDependencies;
   private ArchiveFormat archiveFormat;
   private String packageName;
   private JdkVersion jdkVersion;
   private String operatingSystem;
   private Instant createdOn;
+  private ProjectFlavor flavor;
 
   public String getId() {
     return id;
@@ -88,11 +89,11 @@ public VertxProject setVertxVersion(String vertxVersion) {
     return this;
   }
 
-  public Set<String> getVertxDependencies() {
+  public Set<Dependency> getVertxDependencies() {
     return vertxDependencies;
   }
 
-  public VertxProject setVertxDependencies(Set<String> vertxDependencies) {
+  public VertxProject setVertxDependencies(Set<Dependency> vertxDependencies) {
     this.vertxDependencies = vertxDependencies;
     return this;
   }
@@ -142,6 +143,15 @@ public VertxProject setCreatedOn(Instant createdOn) {
     return this;
   }
 
+  public ProjectFlavor getFlavor() {
+    return flavor;
+  }
+
+  public VertxProject setFlavor(ProjectFlavor flavor) {
+    this.flavor = flavor;
+    return this;
+  }
+
   @Override
   public String toString() {
     // DO NOT RETURN USER RELATED-DATA (groupId, artifactId, packageName)

src/main/java/io/vertx/starter/service/GeneratorService.java

@@ -20,6 +20,7 @@
 import io.vertx.core.buffer.Buffer;
 import io.vertx.ext.web.templ.freemarker.FreeMarkerTemplateEngine;
 import io.vertx.starter.model.ArchiveFormat;
+import io.vertx.starter.model.Dependency;
 import io.vertx.starter.model.Language;
 import io.vertx.starter.model.VertxProject;
 import org.apache.commons.compress.archivers.ArchiveEntry;
@@ -117,26 +118,26 @@ private void createProject(VertxProject project, TempDir tempDir) throws IOExcep
     Language language = project.getLanguage();
     ctx.put("language", language.name().toLowerCase());
     ctx.put("vertxVersion", project.getVertxVersion());
-    Set<String> vertxDependencies = project.getVertxDependencies();
+    Set<Dependency> vertxDependencies = project.getVertxDependencies();
     if (vertxDependencies == null) {
       vertxDependencies = new HashSet<>();
     }
-    boolean hasVertxUnit = vertxDependencies.remove("vertx-unit");
+    boolean hasVertxUnit = vertxDependencies
+      .removeIf(dependency -> dependency.getArtifactId().equals("vertx-unit"));
     ctx.put("hasVertxUnit", hasVertxUnit);
-    boolean hasVertxJUnit5 = vertxDependencies.remove("vertx-junit5") || !hasVertxUnit;
+    boolean hasVertxJUnit5 = vertxDependencies
+      .removeIf(dependency -> dependency.getArtifactId().equals("vertx-junit5")) || !hasVertxUnit;
     ctx.put("hasVertxJUnit5", hasVertxJUnit5);
     if (hasVertxUnit && hasVertxJUnit5) {
       throw new RuntimeException("You cannot generate a project which depends on both vertx-unit and vertx-junit5.");
     }
-    vertxDependencies.addAll(language.getLanguageDependencies());
+    ctx.put("languageDependencies", language.getLanguageDependencies());
     ctx.put("vertxDependencies", vertxDependencies);
+    ctx.put("flavor", project.getFlavor().getId());
     String packageName = packageName(project);
     ctx.put("packageName", packageName);
     ctx.put("jdkVersion", project.getJdkVersion().getValue());
 
-    Path tempDirPath = tempDir.path();
-    String tempDirPathStr = tempDirPath.toString();
-
     copy(tempDir, "files", "_editorconfig");
     copy(tempDir, "files", "_gitignore");
 

src/main/java/io/vertx/starter/service/MetadataHandler.java

@@ -25,6 +25,7 @@
 import io.vertx.starter.model.BuildTool;
 import io.vertx.starter.model.JdkVersion;
 import io.vertx.starter.model.Language;
+import io.vertx.starter.model.ProjectFlavor;
 
 import java.util.Arrays;
 import java.util.function.Function;
@@ -36,15 +37,17 @@ public class MetadataHandler implements Handler<RoutingContext> {
 
   private final Buffer metadata;
 
-  public MetadataHandler(JsonObject defaults, JsonArray versions, JsonArray stack) {
+  public MetadataHandler(JsonObject defaults, JsonArray versions, JsonArray vertxStack, JsonArray mutinyStack) {
     metadata = new JsonObject()
       .put("defaults", defaults)
       .put("versions", versions)
-      .put("stack", stack)
+      .put("stack", vertxStack)
       .put("buildTools", values(BuildTool.values(), BuildTool::getValue))
       .put("languages", values(Language.values(), Language::getName))
       .put("jdkVersions", values(JdkVersion.values(), JdkVersion::getValue))
-      .put("vertxDependencies", stack) // deprecated
+      .put("flavors", values(ProjectFlavor.values(), ProjectFlavor::getId))
+      .put("vertxDependencies", vertxStack) // deprecated
+      .put("mutinyDependencies", mutinyStack) // deprecated
       .put("vertxVersions", versions.stream() // deprecated
         .map(JsonObject.class::cast)
         .map(obj -> obj.getString("number"))