extends route attr to mvc routes fix #346

Author: jknack

coverage-report/src/test/java/org/jooby/issues/Issue346.java

@@ -0,0 +1,85 @@
+package org.jooby.issues;
+
+import static org.junit.Assert.assertEquals;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.jooby.Request;
+import org.jooby.mvc.GET;
+import org.jooby.mvc.Path;
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+public class Issue346 extends ServerFeature {
+
+  @Target({ElementType.METHOD, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
+  @Retention(RetentionPolicy.RUNTIME)
+  public static @interface SitemapUrl {
+    double priority() default 0.5d;
+
+    String changefreq() default "always";
+  }
+
+  @Target({ElementType.METHOD, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
+  @Retention(RetentionPolicy.RUNTIME)
+  public static @interface Role {
+    String value();
+  }
+
+  @Path("/")
+  @SitemapUrl
+  public static class Resource {
+
+    @GET
+    @SitemapUrl(priority = 1.0)
+    @Path("/1")
+    public Object sitemap1(final Request req) {
+      return req.route().attributes();
+    }
+
+    @GET
+    @Path("/2")
+    public Object sitemap2(final Request req) {
+      return req.route().attributes();
+    }
+
+    @GET
+    @Role("admin")
+    @Path("/3")
+    public Object admin(final Request req) {
+      return req.route().attributes();
+    }
+  }
+
+  {
+    use("/1", (req, rsp) -> {
+      assertEquals("{priority=1.0, changefreq=always}", req.route().attributes().toString());
+    });
+
+    use("/2", (req, rsp) -> {
+      assertEquals("{priority=0.5, changefreq=always}", req.route().attributes().toString());
+    });
+
+    use("/3", (req, rsp) -> {
+      assertEquals("{role=admin, priority=0.5, changefreq=always}",
+          req.route().attributes().toString());
+    });
+    use(Resource.class);
+  }
+
+  @Test
+  public void mvcAttrs() throws Exception {
+    request().get("/1")
+        .expect("{priority=1.0, changefreq=always}");
+
+    request().get("/2")
+        .expect("{priority=0.5, changefreq=always}");
+
+    request().get("/3")
+        .expect("{role=admin, priority=0.5, changefreq=always}");
+  }
+
+}

jooby/src/main/java/org/jooby/Route.java

@@ -1812,7 +1812,6 @@ interface Chain {
     default void next(final Request req, final Response rsp) throws Throwable {
       next(null, req, rsp);
     }
-
   }
 
   /** Renderer key. */
@@ -1917,7 +1916,7 @@ default boolean apply(final String prefix) {
   }
 
   /**
-   * @return All the available attributes.
+   * @return All the available attributes in the execution chain.
    */
   Map<String, String> attributes();
 

jooby/src/main/java/org/jooby/internal/RouteChain.java

@@ -19,11 +19,14 @@
 package org.jooby.internal;
 
 import java.util.List;
+import java.util.Map;
 
 import org.jooby.Request;
 import org.jooby.Response;
 import org.jooby.Route;
 
+import com.google.common.collect.ImmutableMap;
+
 public class RouteChain implements Route.Chain {
 
   private List<Route> routes;
@@ -36,10 +39,17 @@ public class RouteChain implements Route.Chain {
 
   private ResponseImpl rrsp;
 
+  private boolean hasAttrs;
+
   public RouteChain(final RequestImpl req, final ResponseImpl rsp, final List<Route> routes) {
     this.routes = routes;
     this.rreq = req;
     this.rrsp = rsp;
+
+    // eager decision if we need to wrap a route to get all the attrs within the change.
+    ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
+    routes.forEach(r -> builder.putAll(r.attributes()));
+    this.hasAttrs = builder.build().size() > 0;
   }
 
   @Override
@@ -52,12 +62,12 @@ public void next(final String prefix, final Request req, final Response rsp) thr
       this.prefix = prefix;
     }
 
-    RouteImpl route = get(next(this.prefix));
+    Route route = next(this.prefix);
     // set route
-    rreq.route(route);
+    rreq.route(hasAttrs ? attrs(route, routes, i - 1) : route);
     rrsp.route(route);
 
-    route.handle(req, rsp, this);
+    get(route).handle(req, rsp, this);
   }
 
   private Route next(final String prefix) {
@@ -75,4 +85,18 @@ private RouteImpl get(final Route next) {
     return (RouteImpl) Route.Forwarding.unwrap(next);
   }
 
+  private static Route attrs(final Route route, final List<Route> routes, final int i) {
+    ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
+    for (int t = i; t < routes.size(); t++) {
+      builder.putAll(routes.get(t).attributes());
+    }
+    Map<String, String> attrs = builder.build();
+    return new Route.Forwarding(route) {
+      @Override
+      public Map<String, String> attributes() {
+        return attrs;
+      }
+    };
+  }
+
 }

jooby/src/main/java/org/jooby/internal/mvc/MvcRoutes.java

@@ -24,6 +24,7 @@
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -48,8 +49,11 @@
 import org.jooby.mvc.Produces;
 import org.jooby.mvc.TRACE;
 
+import com.google.common.base.CaseFormat;
 import com.google.common.collect.ImmutableSet;
 
+import javaslang.control.Try;
+
 public class MvcRoutes {
 
   private static final String[] EMPTY = new String[0];
@@ -59,6 +63,14 @@ public class MvcRoutes {
       POST.class, PUT.class, DELETE.class, PATCH.class, HEAD.class, OPTIONS.class, TRACE.class,
       CONNECT.class);
 
+  private static final Set<Class<? extends Annotation>> IGNORE = ImmutableSet
+      .<Class<? extends Annotation>> builder()
+      .addAll(VERBS)
+      .add(Path.class)
+      .add(Produces.class)
+      .add(Consumes.class)
+      .build();
+
   @SuppressWarnings({"unchecked", "rawtypes" })
   public static List<Route.Definition> routes(final Env env, final RouteMetadata classInfo,
       final String rpath, final Class<?> routeClass) {
@@ -87,7 +99,7 @@ public static List<Route.Definition> routes(final Env env, final RouteMetadata c
     }
 
     List<Definition> definitions = new ArrayList<>();
-
+    Map<String, String> attrs = attrs(routeClass.getAnnotations());
     methods
         .keySet()
         .stream()
@@ -109,6 +121,8 @@ public static List<Route.Definition> routes(final Env env, final RouteMetadata c
           List<Class<?>> verbs = methods.get(method);
           List<MediaType> produces = produces(method);
           List<MediaType> consumes = consumes(method);
+          Map<String, String> localAttrs = new HashMap<>(attrs);
+          localAttrs.putAll(attrs(method.getAnnotations()));
 
           for (String path : expandPaths(rootPaths, method)) {
             for (Class<?> verb : verbs) {
@@ -123,6 +137,7 @@ public static List<Route.Definition> routes(final Env env, final RouteMetadata c
                       .excludes(excludes)
                       .name(name);
 
+              localAttrs.forEach((n, v) -> definition.attr(n, v));
               definitions.add(definition);
             }
           }
@@ -131,6 +146,36 @@ public static List<Route.Definition> routes(final Env env, final RouteMetadata c
     return definitions;
   }
 
+  private static Map<String, String> attrs(final Annotation[] annotations) {
+    Map<String, String> result = new LinkedHashMap<>();
+    for (Annotation annotation : annotations) {
+      result.putAll(attrs(annotation));
+    }
+    return result;
+  }
+
+  private static Map<String, String> attrs(final Annotation annotation) {
+    Map<String, String> result = new LinkedHashMap<>();
+    Class<? extends Annotation> annotationType = annotation.annotationType();
+    if (!IGNORE.contains(annotationType)) {
+      Method[] attrs = annotation.annotationType().getDeclaredMethods();
+      for (Method attr : attrs) {
+        Try.of(() -> attr.invoke(annotation))
+            .onSuccess(value -> result.put(attrName(annotation, attr), value.toString()));
+      }
+    }
+    return result;
+  }
+
+  private static String attrName(final Annotation annotation, final Method attr) {
+    String name = attr.getName();
+    if (name.equals("value")) {
+      return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL,
+          annotation.annotationType().getSimpleName());
+    }
+    return name;
+  }
+
   private static List<MediaType> produces(final Method method) {
     Function<AnnotatedElement, Optional<List<MediaType>>> fn = (element) -> {
       Produces produces = element.getAnnotation(Produces.class);

md/doc/index.md

@@ -24,6 +24,8 @@ documentation
 
 {{dynamic-routing.md}}
 
+{{route-attrs.md}}
+
 {{req.md}}
 
 {{rsp.md}}

md/route-attrs.md

@@ -15,7 +15,7 @@ You can add as many attributes as you need. They can be accessed later and use i
 {
   use((req, rsp, chain) -> {
     User user = ...;
-    String role = req.route.attr("role");
+    String role = req.route().attr("role");
     if (user.hasRole(role)) {
       chain.next(req, rsp);
     }
@@ -25,6 +25,40 @@ You can add as many attributes as you need. They can be accessed later and use i
 }
 ```
 
+In MVC routes we use ```annotations``` to define route attributes:
+
+```java
+@Target({ElementType.METHOD, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+public static @interface Role {
+  String value();
+}
+
+@Path("/path")
+public class AdminResource {
+
+  @Role("admin")
+  public Object doSomething() {
+    ...
+  }
+
+}
+
+{
+  use("*", (req, rsp) -> {
+    System.out.println(req.route().attributes())
+  });
+}
+
+```
+
+The previous example will print: ```{role = admin}```.
+
+Any runtime annotations are automatically added as route attributes. Following these rules:
+
+* If the annotation has a ```value``` method, then we use the annotation's name as attribute name.
+* Otherwise, we use the method name as attribute name.
+
 ### excludes
 
 The excludes attribute skip/ignore a route path match:

md/routes.md

@@ -66,8 +66,6 @@ get("/", (req, rsp, chain) -> {
 });
 ```
 
-{{route-attrs.md}}
-
 ## path patterns
 
 ### static patterns