#63 - Add support for HttpResponse.BodyHandler with and without generic parameters

Author: rbygrave

http-generator-client/src/main/java/io/avaje/http/generator/client/ClientMethodWriter.java

@@ -21,6 +21,7 @@ class ClientMethodWriter {
   private final ProcessingContext ctx;
   private final UType returnType;
   private MethodParam bodyHandlerParam;
+  private String methodGenericParams = "";
 
   ClientMethodWriter(MethodReader method, Append writer, ProcessingContext ctx) {
     this.method = method;
@@ -43,7 +44,7 @@ private void methodStart(Append writer) {
     }
     writer.append("  // %s %s", webMethod, method.getWebMethodPath()).eol();
     writer.append("  @Override").eol();
-    writer.append("  public %s %s(", returnType.shortType(), method.simpleName());
+    writer.append("  public %s%s %s(", methodGenericParams, returnType.shortType(), method.simpleName());
     int count = 0;
     for (MethodParam param : method.getParams()) {
       if (count++ > 0) {
@@ -61,7 +62,7 @@ private void methodStart(Append writer) {
   private void checkBodyHandler(MethodParam param) {
     if (param.getRawType().startsWith(BODY_HANDLER)) {
       bodyHandlerParam = param;
-      param.getUType().param0();
+      methodGenericParams = param.getUType().genericParams();
     }
   }
 

http-generator-core/src/main/java/io/avaje/http/generator/core/UType.java

@@ -40,6 +40,10 @@ default String param1() {
    */
   String full();
 
+  default String genericParams() {
+    return "";
+  }
+
   class VoidType implements UType {
 
     @Override
@@ -129,13 +133,25 @@ public String full() {
     public Set<String> importTypes() {
       Set<String> set = new LinkedHashSet<>();
       for (String type : allTypes) {
-        if (!type.startsWith("java.lang.")) {
+        if (!type.startsWith("java.lang.") && type.indexOf('.') > -1) {
           set.add(type);
         }
       }
       return set;
     }
 
+    @Override
+    public String genericParams() {
+      final StringJoiner joiner = new StringJoiner(",");
+      for (String type : allTypes) {
+        if (type.indexOf('.') == -1) {
+          joiner.add(type);
+        }
+      }
+      final String commaDelim = joiner.toString();
+      return commaDelim.isEmpty() ? "" : "<" + commaDelim + "> ";
+    }
+
     @Override
     public String shortType() {
       return shortRawType;

http-generator-core/src/test/java/io/avaje/http/generator/core/UtilTest.java

@@ -129,4 +129,40 @@ void parse_CompletableFutureStreamBean() {
     assertThat(type.importTypes()).containsExactly("java.util.concurrent.CompletableFuture", "java.util.Stream", "org.example.Repo");
     assertThat(type.shortType()).isEqualTo("CompletableFuture<Stream<Repo>>");
   }
+
+  @Test
+  void parse_BodyHandler_E() {
+    UType type = Util.parse("java.net.http.HttpResponse.BodyHandler<E>");
+
+    assertThat(type.importTypes()).containsExactly("java.net.http.HttpResponse.BodyHandler");
+    assertThat(type.shortType()).isEqualTo("BodyHandler<E>");
+    assertThat(type.genericParams()).isEqualTo("<E> ");
+  }
+
+  @Test
+  void parse_BodyHandler_Path() {
+    UType type = Util.parse("java.net.http.HttpResponse.BodyHandler<java.util.Path>");
+
+    assertThat(type.importTypes()).containsExactly("java.net.http.HttpResponse.BodyHandler", "java.util.Path");
+    assertThat(type.shortType()).isEqualTo("BodyHandler<Path>");
+    assertThat(type.genericParams()).isEqualTo("");
+  }
+
+  @Test
+  void parse_BodyHandler_Multi() {
+    UType type = Util.parse("java.net.http.HttpResponse.BodyHandler<some.Foo<A,B>>");
+
+    assertThat(type.importTypes()).containsExactly("java.net.http.HttpResponse.BodyHandler", "some.Foo");
+    assertThat(type.shortType()).isEqualTo("BodyHandler<Foo<A,B>>");
+    assertThat(type.genericParams()).isEqualTo("<A,B> ");
+  }
+
+  @Test
+  void parse_BodyHandler_Multi2() {
+    UType type = Util.parse("java.net.http.HttpResponse.BodyHandler<some.Foo<AB,BC,some.Bar<D>>>");
+
+    assertThat(type.importTypes()).containsExactly("java.net.http.HttpResponse.BodyHandler", "some.Foo", "some.Bar");
+    assertThat(type.shortType()).isEqualTo("BodyHandler<Foo<AB,BC,Bar<D>>>");
+    assertThat(type.genericParams()).isEqualTo("<AB,BC,D> ");
+  }
 }

tests/test-client/src/main/java/org/example/JunkApi.java

@@ -1,11 +1,13 @@
 package org.example;
 
 import io.avaje.http.api.Client;
+import io.avaje.http.api.Get;
 import io.avaje.http.api.Post;
 import io.avaje.http.client.HttpCall;
 
 import java.io.InputStream;
 import java.net.http.HttpResponse;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Stream;
@@ -88,6 +90,22 @@ public interface JunkApi {
   @Post
   HttpCall<HttpResponse<Stream<String>>> callLines();
 
-//  @Get
-//  <E> HttpResponse<E> withH(HttpResponse.BodyHandler<E> handler);
+  @Get
+  <E> HttpResponse<E> withHandGeneric(HttpResponse.BodyHandler<E> handler);
+
+  @Get
+  HttpResponse<Path> withHandPath(HttpResponse.BodyHandler<Path> handler);
+
+  @Get
+  <E> CompletableFuture<HttpResponse<E>> cfWithHandGeneric(HttpResponse.BodyHandler<E> handler);
+
+  @Get
+  CompletableFuture<HttpResponse<Path>> cfWithHandPath(HttpResponse.BodyHandler<Path> handler);
+
+  @Get
+  <E> HttpCall<HttpResponse<E>> callWithHandGeneric(HttpResponse.BodyHandler<E> handler);
+
+  @Get
+  HttpCall<HttpResponse<Path>> callWithHandPath(HttpResponse.BodyHandler<Path> handler);
+
 }