apitool: add support for use("/path", MvcRoutes.class) fix #947

Author: jknack

modules/jooby-apitool/src/main/java/org/jooby/internal/apitool/BytecodeRouteParser.java

@@ -502,18 +502,7 @@ private List<Object> lambdas(final ClassLoader loader, final ClassNode owner, Me
           result.addAll(pathOperator(owner, owner.methods, it));
         })
         // use(Mvc class)
-        .on(use(loader, owner.name), it -> {
-          log.debug("found mvc: " + it);
-          it.prev()
-              .filter(is(LdcInsnNode.class))
-              .findFirst()
-              .map(LdcInsnNode.class::cast)
-              .filter(ldc -> ldc.cst instanceof Type)
-              .map(ldc -> ((Type) ldc.cst).getClassName())
-              .ifPresent(mvcClass ->
-                  mvcRoutes((Class) loadType(loader, mvcClass), result::add)
-              );
-        })
+        .on(use(loader, owner.name), it -> mvc(it, result::add))
         // use(new App());
         .on(mount(loader, owner.name), it -> {
           log.debug("found mount: " + it);
@@ -597,13 +586,16 @@ private List<Object> lambdas(final ClassLoader loader, final ClassNode owner) {
     }
   }
 
-  private void mvcRoutes(final Class type, Consumer<RouteMethod> callback) {
+  private void mvcRoutes(String path, final Class type, Consumer<RouteMethod> callback) {
     Env env = Env.DEFAULT.build(ConfigFactory.empty()
         .withValue("application.env", ConfigValueFactory.fromAnyRef("dev")));
     MvcRoutes.routes(env, new RouteMetadata(env), "", true, type)
         .forEach(r -> {
           RouteMethod method = toRouteMethod(r);
           javadoc(method, javadoc.pop(type.getName(), r.method(), r.pattern()));
+          if (path.length() >0) {
+            method.pattern(Route.normalize(path) + method.pattern());
+          }
           callback.accept(method);
         });
   }
@@ -687,17 +679,7 @@ private List<Object> kotlinLambda(final ClassLoader loader, final ClassNode owne
               });
         })
         // use(Mvc class)
-        .on(use(loader, "org.jooby.Kooby"), it -> {
-          it.prev()
-              .filter(is(LdcInsnNode.class))
-              .findFirst()
-              .map(LdcInsnNode.class::cast)
-              .filter(ldc -> ldc.cst instanceof Type)
-              .map(ldc -> ((Type) ldc.cst).getClassName())
-              .ifPresent(mvcClass ->
-                  mvcRoutes((Class) loadType(loader, mvcClass), result::add)
-              );
-        })
+        .on(use(loader, "org.jooby.Kooby"), it -> mvc(it, result::add))
         // route ("...") {...}
         .on(call(loader, "org.jooby.Kooby", "route", String.class,
             "kotlin.jvm.functions.Function1"), it -> {
@@ -748,6 +730,30 @@ private List<Object> kotlinLambda(final ClassLoader loader, final ClassNode owne
     return result;
   }
 
+  private void mvc(Insn<MethodInsnNode> it, Consumer<Object> consumer) {
+    log.debug("found mvc {}", it);
+    it.prev()
+        .filter(is(LdcInsnNode.class))
+        .findFirst()
+        .map(LdcInsnNode.class::cast)
+        .filter(ldc -> ldc.cst instanceof Type)
+        .ifPresent(ldc -> {
+          String arg0 = Type.getArgumentTypes(it.node.desc)[0].getClassName();
+          String prefix = "";
+          if (arg0.equals(String.class.getName())) {
+            prefix = new Insn<>(it.method, ldc.getPrevious())
+                .prev()
+                .filter(is(LdcInsnNode.class))
+                .findFirst()
+                .map(LdcInsnNode.class::cast)
+                .map(n -> n.cst.toString())
+                .orElse("");
+          }
+          String mvcClass = ((Type) ldc.cst).getClassName();
+          mvcRoutes(prefix, (Class) loadType(loader, mvcClass), consumer::accept);
+        });
+  }
+
   private List<Object> kotlinLambda(final ClassLoader loader, final ClassNode owner) {
     List<Object> result = new ArrayList<>();
     log.debug("visiting lambda class: {}", owner.name);
@@ -1200,7 +1206,8 @@ private static class TypeWithStatus implements java.lang.reflect.Type {
     }
 
     public java.lang.reflect.Type type() {
-      if (status != null && status == 204 && forwarding.getTypeName().equals(Result.class.getName())) {
+      if (status != null && status == 204 && forwarding.getTypeName()
+          .equals(Result.class.getName())) {
         return void.class;
       }
       return forwarding;

modules/jooby-apitool/src/main/java/org/jooby/internal/apitool/Filters.java

@@ -263,7 +263,8 @@ public static Predicate<MethodInsnNode> call(final Class owner, final String nam
   }
 
   @SuppressWarnings("rawtypes")
-  public static Predicate<MethodInsnNode> call(final ClassLoader loader,final String owner, final String name,
+  public static Predicate<MethodInsnNode> call(final ClassLoader loader, final String owner,
+      final String name,
       final Object... args) {
     return is(MethodInsnNode.class).and(m -> {
       return new Signature(loader, owner, name, args).matches(m);
@@ -294,11 +295,14 @@ public static Predicate<MethodInsnNode> mount(final ClassLoader loader, final St
 
   public static Predicate<MethodInsnNode> use(final ClassLoader loader, final String owner) {
     Signature use = new Signature(loader, owner, "use", Class.class);
+    Signature usepath = new Signature(loader, owner, "use", String.class, Class.class);
     Signature kuse = new Signature(loader, owner, "use", "kotlin.reflect.KClass");
-    return is(MethodInsnNode.class).and(m -> use.matches(m) || kuse.matches(m));
+    Signature kusepath = new Signature(loader, owner, "use", String.class, "kotlin.reflect.KClass");
+    return is(MethodInsnNode.class)
+        .and(m -> use.matches(m) || usepath.matches(m) || kuse.matches(m) || kusepath.matches(m));
   }
 
-  public static Predicate<MethodInsnNode> path(final ClassLoader loader,final String owner) {
+  public static Predicate<MethodInsnNode> path(final ClassLoader loader, final String owner) {
     Signature path = new Signature(loader, owner, "path", String.class, Runnable.class);
     return is(MethodInsnNode.class).and(m -> path.matches(m));
   }

modules/jooby-apitool/src/test/java/apps/App947.java

@@ -0,0 +1,9 @@
+package apps;
+
+import org.jooby.Jooby;
+
+public class App947 extends Jooby {
+  {
+    use("/path", Routes947.class);
+  }
+}

modules/jooby-apitool/src/test/java/apps/Routes947.java

@@ -0,0 +1,26 @@
+package apps;
+
+import org.jooby.mvc.Body;
+import org.jooby.mvc.Header;
+import org.jooby.mvc.POST;
+import org.jooby.mvc.Path;
+
+import javax.inject.Named;
+
+/**
+ * MVC API.
+ */
+@Path("/mvc")
+public class Routes947 {
+
+  /**
+   * MVC doIt.
+   *
+   * @param q Query string. Like: <code>q=foo</code>
+   * @return Sterinv value.
+   */
+  @POST
+  public String doIt(final String q) {
+    return "dot";
+  }
+}

modules/jooby-apitool/src/test/java/kt/Kt947.kt

@@ -0,0 +1,8 @@
+package kt
+
+import apps.Routes947
+import org.jooby.Kooby
+
+class Kt947: Kooby( {
+    use("/kpath", Routes947::class)
+})

modules/jooby-apitool/src/test/java/org/jooby/apitool/Issue947.java

@@ -0,0 +1,50 @@
+package org.jooby.apitool;
+
+import apps.App947;
+import org.junit.Test;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class Issue947 {
+
+  @Test
+  public void shouldProcessMvcWithPath() throws Exception {
+    new RouteMethodAssert(new ApiParser(dir()).parseFully(new App947()))
+        .next(r -> {
+          r.returnType(String.class);
+          r.pattern("/path/mvc");
+          r.description("MVC doIt.");
+          r.summary("MVC API.");
+          r.param(p -> {
+            p.name("q");
+            p.type(String.class);
+            p.description("Query string. Like: <code>q=foo</code>");
+          });
+        }).done();
+  }
+
+  @Test
+  public void shouldProcessMvcWithPathFromKotlin() throws Exception {
+    new RouteMethodAssert(new ApiParser(dir()).parse("kt.Kt947"))
+        .next(r -> {
+          r.returnType(String.class);
+          r.pattern("/kpath/mvc");
+          r.description("MVC doIt.");
+          r.summary("MVC API.");
+          r.param(p -> {
+            p.name("q");
+            p.type(String.class);
+            p.description("Query string. Like: <code>q=foo</code>");
+          });
+        }).done();
+  }
+
+  private Path dir() {
+    Path userdir = Paths.get(System.getProperty("user.dir"));
+    if (!userdir.toString().endsWith("jooby-apitool")) {
+      userdir = userdir.resolve("modules").resolve("jooby-apitool");
+    }
+    return userdir;
+  }
+}

modules/jooby-lang-kotlin/src/main/kotlin/org/jooby/Jooby.kt

@@ -217,6 +217,10 @@ open class Kooby constructor(): Jooby() {
     return use(klass.java)
   }
 
+  fun <T:Any> use(path: String, klass: KClass<T>): Route.Collection {
+    return use(path, klass.java)
+  }
+
   fun <T:Session.Store> session(klass: KClass<T>): Session.Definition {
     return session(klass.java)
   }