Fix: inconsistent naming of contract parts in javadoc

lukasjelonek · lukasjelonek · commit e7495aa295db · 2025-07-01T08:08:42.000+02:00
diff --git a/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java b/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java
@@ -19,6 +19,7 @@
 import io.vertx.core.http.HttpMethod;
 import io.vertx.core.json.JsonObject;
 import io.vertx.json.schema.SchemaRepository;
+
 import java.util.List;
 import java.util.Map;
 
@@ -55,8 +56,8 @@ static Future<OpenAPIContract> from(Vertx vertx, String contractPath) {
    */
   static Future<OpenAPIContract> from(Vertx vertx, JsonObject contract) {
     return builder(vertx)
-        .setContract(contract)
-        .build();
+      .setContract(contract)
+      .build();
   }
 
   /**
@@ -71,12 +72,12 @@ static Future<OpenAPIContract> from(Vertx vertx, JsonObject contract) {
    * @return A succeeded {@link Future} holding an {@link OpenAPIContract} instance, otherwise a failed {@link Future}.
    */
   static Future<OpenAPIContract> from(Vertx vertx, String contract,
-      Map<String, String> additionalContractPartPaths) {
+                                      Map<String, String> additionalContractPartPaths) {
 
     return builder(vertx)
-        .setContractPath(contract)
-        .setAdditionalContractPartPaths(additionalContractPartPaths)
-        .build();
+      .setContractPath(contract)
+      .setAdditionalContractPartPaths(additionalContractPartPaths)
+      .build();
   }
 
   /**
@@ -85,17 +86,17 @@ static Future<OpenAPIContract> from(Vertx vertx, String contract,
    * This method can be used in case that the contract is split into several files. These files can be passed in a
    * Map that has the reference as key and the path to the file as value.
    *
-   * @param vertx                       The related Vert.x instance.
-   * @param contract                    The unresolved contract.
-   * @param additionalContractPartPaths The additional contract part paths
+   * @param vertx                   The related Vert.x instance.
+   * @param contract                The unresolved contract.
+   * @param additionalContractParts The additional contract parts
    * @return A succeeded {@link Future} holding an {@link OpenAPIContract} instance, otherwise a failed {@link Future}.
    */
   static Future<OpenAPIContract> from(Vertx vertx, JsonObject contract,
-      Map<String, JsonObject> additionalContractPartPaths) {
+                                      Map<String, JsonObject> additionalContractParts) {
     return builder(vertx)
-        .setContract(contract)
-        .setAdditionalContractParts(additionalContractPartPaths)
-        .build();
+      .setContract(contract)
+      .setAdditionalContractParts(additionalContractParts)
+      .build();
 
   }
 
diff --git a/src/main/java/io/vertx/openapi/contract/OpenAPIContractBuilder.java b/src/main/java/io/vertx/openapi/contract/OpenAPIContractBuilder.java
@@ -11,9 +11,6 @@
  */
 package io.vertx.openapi.contract;
 
-import static io.vertx.core.Future.failedFuture;
-import static io.vertx.openapi.contract.OpenAPIContractException.createInvalidContract;
-
 import io.vertx.codegen.annotations.GenIgnore;
 import io.vertx.core.Future;
 import io.vertx.core.Promise;
@@ -24,13 +21,17 @@
 import io.vertx.json.schema.JsonSchemaValidationException;
 import io.vertx.openapi.contract.impl.OpenAPIContractImpl;
 import io.vertx.openapi.impl.Utils;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import static io.vertx.core.Future.failedFuture;
+import static io.vertx.openapi.contract.OpenAPIContractException.createInvalidContract;
+
 /**
  * Builder for OpenAPIContracts.<br>
- *
+ * <p>
  * In the simplest case (you only have one contract) you must either provide a path to your openapi-contract in json
  * or yaml format or an already parsed openapi-spec as a {@link JsonObject}.
  * See {@link OpenAPIContractBuilder#setContractPath(String)} and {@link OpenAPIContractBuilder#setContract(JsonObject)}.
@@ -89,8 +90,8 @@ public OpenAPIContractBuilder setContract(JsonObject contract) {
 
   /**
    * Puts a contract that is referenced by the main contract. This method can be
-   * called multiple times to add multiple referenced contracts. Overrides a previously
-   * added contract when the same key is used.
+   * called multiple times to add multiple referenced additional contract parts. Overrides a previously
+   * added additional contract part when the same key is used.
    *
    * @param key  The unique key for the contract.
    * @param path The path to the contract.
@@ -121,11 +122,11 @@ public OpenAPIContractBuilder setAdditionalContractPartPaths(Map<String, String>
   }
 
   /**
-   * Puts a contract that is referenced by the main contract. This method can be
+   * Puts aa additional contract part that is referenced by the main contract. This method can be
    * called multiple times to add multiple referenced contracts.
    *
    * @param key          The unique key for the contract.
-   * @param contractPart The contract object.
+   * @param contractPart The additional contract part.
    * @return The builder, for a fluent interface
    */
   public OpenAPIContractBuilder putAdditionalContractPart(String key, JsonObject contractPart) {
@@ -135,9 +136,9 @@ public OpenAPIContractBuilder putAdditionalContractPart(String key, JsonObject c
   }
 
   /**
-   * Uses the contracts from the provided map to resolve referenced contracts.
-   * Replaces all previously put contracts by {@link #putAdditionalContractPart(String, JsonObject)}.
-   * If the same key is used also replaces the contracts set by {@link #putAdditionalContractPartPath(String, String)}
+   * Uses the addtitional contract parts from the provided map to resolve referenced additional contract parts.
+   * Replaces all previously put additional contract parts by {@link #putAdditionalContractPart(String, JsonObject)}.
+   * If the same key is used also replaces the addtional contract part paths set by {@link #putAdditionalContractPartPath(String, String)}
    * and {@link #setAdditionalContractPartPaths(Map)}.
    *
    * @param contractParts A map that contains additional contract parts.
@@ -161,62 +162,62 @@ public Future<OpenAPIContract> build() {
 
     if (contractPath == null && contract == null) {
       return Future.failedFuture(new OpenAPIContractBuilderException(
-          "Neither a contract path or a contract is set. One of them must be set."));
+        "Neither a contract path or a contract is set. One of them must be set."));
     }
 
     Future<JsonObject> readContract = contractPath == null
-        ? Future.succeededFuture(contract)
-        : Utils.readYamlOrJson(vertx, contractPath);
+      ? Future.succeededFuture(contract)
+      : Utils.readYamlOrJson(vertx, contractPath);
 
     var resolvedContractParts = readContractPaths()
-        .map(r -> {
-          var all = new HashMap<>(additionalContractParts);
-          all.putAll(r);
-          return all;
-        });
+      .map(r -> {
+        var all = new HashMap<>(additionalContractParts);
+        all.putAll(r);
+        return all;
+      });
 
     return Future.all(readContract, resolvedContractParts)
-        .compose(composite -> {
-          JsonObject contract = composite.resultAt(0);
-          Map<String, JsonObject> contractParts = composite.resultAt(1);
-          return buildOpenAPIContract(contract, contractParts);
-        });
+      .compose(composite -> {
+        JsonObject contract = composite.resultAt(0);
+        Map<String, JsonObject> contractParts = composite.resultAt(1);
+        return buildOpenAPIContract(contract, contractParts);
+      });
   }
 
   private Future<OpenAPIContract> buildOpenAPIContract(JsonObject resolvedContract,
-      Map<String, JsonObject> additionalContractParts) {
+                                                       Map<String, JsonObject> additionalContractParts) {
     OpenAPIVersion version = OpenAPIVersion.fromContract(resolvedContract);
     String baseUri = "app://";
 
     ContextInternal ctx = (ContextInternal) vertx.getOrCreateContext();
     Promise<OpenAPIContract> promise = ctx.promise();
 
     version.getRepository(vertx, baseUri)
-        .compose(repository -> {
-          var validationFutures = additionalContractParts.entrySet()
-              .stream()
-              .map(entry -> version.validateAdditionalContractPart(vertx, repository, entry.getValue())
-                  .compose(v -> vertx.executeBlocking(
-                      () -> repository.dereference(entry.getKey(), JsonSchema.of(entry.getKey(), entry.getValue())))))
-              .collect(Collectors.toList());
-          return Future.all(validationFutures).map(repository);
-        }).compose(repository -> version.validateContract(vertx, repository, resolvedContract).compose(res -> {
+      .compose(repository -> {
+        var validationFutures = additionalContractParts.entrySet()
+          .stream()
+          .map(entry -> version.validateAdditionalContractPart(vertx, repository, entry.getValue())
+            .compose(v -> vertx.executeBlocking(
+              () -> repository.dereference(entry.getKey(), JsonSchema.of(entry.getKey(), entry.getValue())))))
+          .collect(Collectors.toList());
+        return Future.all(validationFutures).map(repository);
+      }).compose(repository -> version.validateContract(vertx, repository, resolvedContract).compose(res -> {
           try {
             res.checkValidity();
             return version.resolve(vertx, repository, resolvedContract);
           } catch (JsonSchemaValidationException | UnsupportedOperationException e) {
             return failedFuture(createInvalidContract(null, e));
           }
         })
-            .map(resolvedSpec -> new OpenAPIContractImpl(resolvedSpec, version, repository)))
-        .recover(e -> {
-          // Convert any non-openapi exceptions into an OpenAPIContractException
-          if (e instanceof OpenAPIContractException) {
-            return failedFuture(e);
-          }
-          return failedFuture(
-              createInvalidContract("Found issue in specification for reference: " + e.getMessage(), e));
-        }).onComplete(promise);
+        .map(resolvedSpec -> new OpenAPIContractImpl(resolvedSpec, version, repository)))
+      .recover(e -> {
+        // Convert any non-openapi exceptions into an OpenAPIContractException
+        if (e instanceof OpenAPIContractException) {
+          return failedFuture(e);
+        }
+        return failedFuture(
+          createInvalidContract("Found issue in specification for reference: " + e.getMessage(), e));
+      }).onComplete(promise);
 
     return promise.future();
   }
@@ -228,9 +229,9 @@ private Future<Map<String, JsonObject>> readContractPaths() {
     var read = new HashMap<String, JsonObject>();
     return Future.all(additionalContractPartPaths.entrySet().stream()
         .map(e -> Utils.readYamlOrJson(vertx, e.getValue())
-            .map(c -> read.put(e.getKey(), c)))
+          .map(c -> read.put(e.getKey(), c)))
         .collect(Collectors.toList()))
-        .map(ign -> read);
+      .map(ign -> read);
   }
 
 }
