Routing: remove instance of router matcher for static patterns

jknack · jknack · commit da49ece68187 · 2020-01-08T10:20:41.000-03:00
diff --git a/jooby/src/main/java/io/jooby/internal/Chi.java b/jooby/src/main/java/io/jooby/internal/Chi.java
@@ -31,9 +31,9 @@ class Chi implements RouteTree {
   static final char ZERO_CHAR = (char) 0;
 
   static class StaticRoute {
-    private final Map<String, Route> methods;
+    private final Map<String, StaticRouterMatch> methods;
 
-    public StaticRoute(Map<String, Route> methods) {
+    public StaticRoute(Map<String, StaticRouterMatch> methods) {
       this.methods = methods;
     }
 
@@ -42,7 +42,7 @@ public StaticRoute() {
     }
 
     public void put(String method, Route route) {
-      methods.put(method, route);
+      methods.put(method, new StaticRouterMatch(route));
     }
   }
 
@@ -807,14 +807,14 @@ public boolean find(String method, String path) {
     return true;
   }
 
-  public RouterMatch find(String method, String path, MessageEncoder encoder) {
-    Route route = staticPaths.getOrDefault(path, NO_MATCH).methods.get(method);
-    if (route == null) {
+  public Router.Match find(String method, String path, MessageEncoder encoder) {
+    StaticRouterMatch match = staticPaths.getOrDefault(path, NO_MATCH).methods.get(method);
+    if (match == null) {
       // use radix tree
       RouterMatch result = new RouterMatch();
-      route = root.findRoute(result, method, new ZeroCopyString(path));
+      Route route = root.findRoute(result, method, new ZeroCopyString(path));
       return route == null ? result.missing(method, path, encoder) : result.found(route);
     }
-    return new RouterMatch(route);
+    return match;
   }
 }
diff --git a/jooby/src/main/java/io/jooby/internal/RouteTree.java b/jooby/src/main/java/io/jooby/internal/RouteTree.java
@@ -7,13 +7,14 @@
 
 import io.jooby.MessageEncoder;
 import io.jooby.Route;
+import io.jooby.Router;
 
 interface RouteTree {
   void insert(String method, String pattern, Route route);
 
   boolean find(String method, String path);
 
-  RouterMatch find(String method, String path, MessageEncoder encoder);
+  Router.Match find(String method, String path, MessageEncoder encoder);
 
   void destroy();
 }
diff --git a/jooby/src/main/java/io/jooby/internal/RouteTreeForwarding.java b/jooby/src/main/java/io/jooby/internal/RouteTreeForwarding.java
@@ -7,6 +7,7 @@
 
 import io.jooby.MessageEncoder;
 import io.jooby.Route;
+import io.jooby.Router;
 
 public class RouteTreeForwarding implements RouteTree {
   private RouteTree tree;
@@ -23,7 +24,7 @@ public RouteTreeForwarding(RouteTree tree) {
     return tree.find(method, path);
   }
 
-  @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {
+  @Override public Router.Match find(String method, String path, MessageEncoder encoder) {
     return tree.find(method, path, encoder);
   }
 
diff --git a/jooby/src/main/java/io/jooby/internal/RouteTreeIgnoreTrailingSlash.java b/jooby/src/main/java/io/jooby/internal/RouteTreeIgnoreTrailingSlash.java
@@ -17,7 +17,7 @@ public RouteTreeIgnoreTrailingSlash(RouteTree tree) {
     return super.find(method, Router.noTrailingSlash(path));
   }
 
-  @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {
+  @Override public Router.Match find(String method, String path, MessageEncoder encoder) {
     return super.find(method, Router.noTrailingSlash(path), encoder);
   }
 }
diff --git a/jooby/src/main/java/io/jooby/internal/RouteTreeLowerCasePath.java b/jooby/src/main/java/io/jooby/internal/RouteTreeLowerCasePath.java
@@ -6,6 +6,7 @@
 package io.jooby.internal;
 
 import io.jooby.MessageEncoder;
+import io.jooby.Router;
 
 public class RouteTreeLowerCasePath extends RouteTreeForwarding {
   public RouteTreeLowerCasePath(RouteTree tree) {
@@ -16,7 +17,7 @@ public RouteTreeLowerCasePath(RouteTree tree) {
     return super.find(method, path.toLowerCase());
   }
 
-  @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {
+  @Override public Router.Match find(String method, String path, MessageEncoder encoder) {
     return super.find(method, path.toLowerCase(), encoder);
   }
 }
diff --git a/jooby/src/main/java/io/jooby/internal/RouteTreeNormPath.java b/jooby/src/main/java/io/jooby/internal/RouteTreeNormPath.java
@@ -17,7 +17,7 @@ public RouteTreeNormPath(RouteTree tree) {
     return super.find(method, Router.normalizePath(path));
   }
 
-  @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {
+  @Override public Router.Match find(String method, String path, MessageEncoder encoder) {
     return super.find(method, Router.normalizePath(path), encoder);
   }
 }
diff --git a/jooby/src/main/java/io/jooby/internal/RouterImpl.java b/jooby/src/main/java/io/jooby/internal/RouterImpl.java
@@ -582,8 +582,8 @@ public void destroy() {
     if (predicateMap != null) {
       for (Map.Entry<Predicate<Context>, RouteTree> e : predicateMap.entrySet()) {
         if (e.getKey().test(ctx)) {
-          RouterMatch match = e.getValue().find(ctx.getMethod(), ctx.getRequestPath(), encoder);
-          if (match.matches) {
+          Router.Match match = e.getValue().find(ctx.getMethod(), ctx.getRequestPath(), encoder);
+          if (match.matches()) {
             return match;
           }
         }
diff --git a/jooby/src/main/java/io/jooby/internal/StaticRouterMatch.java b/jooby/src/main/java/io/jooby/internal/StaticRouterMatch.java
@@ -0,0 +1,43 @@
+/**
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal;
+
+import io.jooby.Context;
+import io.jooby.Route;
+import io.jooby.Router;
+
+import javax.annotation.Nonnull;
+import java.util.Collections;
+import java.util.Map;
+
+public class StaticRouterMatch implements Router.Match {
+  private final Route route;
+
+  public StaticRouterMatch(Route route) {
+    this.route = route;
+  }
+
+  @Override public boolean matches() {
+    return true;
+  }
+
+  @Nonnull @Override public Route route() {
+    return route;
+  }
+
+  @Override public void execute(@Nonnull Context context) {
+    context.setRoute(route);
+    try {
+      route.getPipeline().apply(context);
+    } catch (Throwable x) {
+      context.sendError(x);
+    }
+  }
+
+  @Nonnull @Override public Map<String, String> pathMap() {
+    return Collections.emptyMap();
+  }
+}
diff --git a/jooby/src/test/java/io/jooby/internal/ChiTest.java b/jooby/src/test/java/io/jooby/internal/ChiTest.java
@@ -3,6 +3,7 @@
 import io.jooby.Context;
 import io.jooby.MessageEncoder;
 import io.jooby.Route;
+import io.jooby.Router;
 import io.jooby.SneakyThrows;
 import org.junit.jupiter.api.Test;
 
@@ -21,9 +22,9 @@ public void routeOverride() {
     router.insert(foo);
     router.insert(bar);
 
-    RouterMatch result = router
+    Router.Match result = router
         .find("GET", "/abcd", MessageEncoder.TO_STRING);
-    assertTrue(result.matches);
+    assertTrue(result.matches());
     assertEquals(bar, result.route());
   }
 
@@ -35,9 +36,9 @@ public void routeCase() {
     router.insert(foo);
     router.insert(foos);
 
-    RouterMatch result = router
+    Router.Match result = router
         .find("GET", "/abcd/", MessageEncoder.TO_STRING);
-    assertTrue(result.matches);
+    assertTrue(result.matches());
     assertEquals(foos, result.route());
   }
 
@@ -50,37 +51,37 @@ public void wildOnRoot() throws Exception {
     router.insert(route("GET", "/*", stringHandler("root")));
 
     find(router, "/", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("root", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/foo", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("foo", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/bar", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("root", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/foox", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("root", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/foo/", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("foo", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/foo/x", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("foo", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/bar/x", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("bar", result.route().getPipeline().apply(ctx));
     });
   }
@@ -97,17 +98,17 @@ public void searchString() throws Exception {
     router.insert(route("GET", "/articles/*", stringHandler("*")));
 
     find(router, "/regex/678/edit", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("zid", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/articles/tail/match", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("*", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/articles/123", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("id", result.route().getPipeline().apply(ctx));
     });
   }
@@ -120,19 +121,19 @@ public void searchParam() throws Exception {
     router.insert(route("GET", "/articles/*", stringHandler("catchall")));
 
     find(router, "/articles/123", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("id", result.route().getPipeline().apply(ctx));
     });
 
     find(router, "/articles/a/b", (ctx, result) -> {
-      assertTrue(result.matches);
+      assertTrue(result.matches());
       assertEquals("catchall", result.route().getPipeline().apply(ctx));
     });
   }
 
   private void find(Chi router, String pattern,
-      SneakyThrows.Consumer2<Context, RouterMatch> consumer) {
-    RouterMatch result = router
+      SneakyThrows.Consumer2<Context, Router.Match> consumer) {
+    Router.Match result = router
         .find("GET", pattern, MessageEncoder.TO_STRING);
     consumer.accept(ctx(pattern), result);
   }

Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,9 @@ class Chi implements RouteTree {`
`31`	`31`	`static final char ZERO_CHAR = (char) 0;`
`32`	`32`
`33`	`33`	`static class StaticRoute {`
`34`		`- private final Map<String, Route> methods;`
	`34`	`+ private final Map<String, StaticRouterMatch> methods;`
`35`	`35`
`36`		`- public StaticRoute(Map<String, Route> methods) {`
	`36`	`+ public StaticRoute(Map<String, StaticRouterMatch> methods) {`
`37`	`37`	`this.methods = methods;`
`38`	`38`	`}`
`39`	`39`
`@@ -42,7 +42,7 @@ public StaticRoute() {`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public void put(String method, Route route) {`
`45`		`- methods.put(method, route);`
	`45`	`+ methods.put(method, new StaticRouterMatch(route));`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -807,14 +807,14 @@ public boolean find(String method, String path) {`
`807`	`807`	`return true;`
`808`	`808`	`}`
`809`	`809`
`810`		`- public RouterMatch find(String method, String path, MessageEncoder encoder) {`
`811`		`- Route route = staticPaths.getOrDefault(path, NO_MATCH).methods.get(method);`
`812`		`- if (route == null) {`
	`810`	`+ public Router.Match find(String method, String path, MessageEncoder encoder) {`
	`811`	`+ StaticRouterMatch match = staticPaths.getOrDefault(path, NO_MATCH).methods.get(method);`
	`812`	`+ if (match == null) {`
`813`	`813`	`// use radix tree`
`814`	`814`	`RouterMatch result = new RouterMatch();`
`815`		`- route = root.findRoute(result, method, new ZeroCopyString(path));`
	`815`	`+ Route route = root.findRoute(result, method, new ZeroCopyString(path));`
`816`	`816`	`return route == null ? result.missing(method, path, encoder) : result.found(route);`
`817`	`817`	`}`
`818`		`- return new RouterMatch(route);`
	`818`	`+ return match;`
`819`	`819`	`}`
`820`	`820`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`
`8`	`8`	`import io.jooby.MessageEncoder;`
`9`	`9`	`import io.jooby.Route;`
	`10`	`+import io.jooby.Router;`
`10`	`11`
`11`	`12`	`public class RouteTreeForwarding implements RouteTree {`
`12`	`13`	`private RouteTree tree;`
`@@ -23,7 +24,7 @@ public RouteTreeForwarding(RouteTree tree) {`
`23`	`24`	`return tree.find(method, path);`
`24`	`25`	`}`
`25`	`26`
`26`		`- @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {`
	`27`	`+ @Override public Router.Match find(String method, String path, MessageEncoder encoder) {`
`27`	`28`	`return tree.find(method, path, encoder);`
`28`	`29`	`}`
`29`	`30`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public RouteTreeIgnoreTrailingSlash(RouteTree tree) {`
`17`	`17`	`return super.find(method, Router.noTrailingSlash(path));`
`18`	`18`	`}`
`19`	`19`
`20`		`- @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {`
	`20`	`+ @Override public Router.Match find(String method, String path, MessageEncoder encoder) {`
`21`	`21`	`return super.find(method, Router.noTrailingSlash(path), encoder);`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`package io.jooby.internal;`
`7`	`7`
`8`	`8`	`import io.jooby.MessageEncoder;`
	`9`	`+import io.jooby.Router;`
`9`	`10`
`10`	`11`	`public class RouteTreeLowerCasePath extends RouteTreeForwarding {`
`11`	`12`	`public RouteTreeLowerCasePath(RouteTree tree) {`
`@@ -16,7 +17,7 @@ public RouteTreeLowerCasePath(RouteTree tree) {`
`16`	`17`	`return super.find(method, path.toLowerCase());`
`17`	`18`	`}`
`18`	`19`
`19`		`- @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {`
	`20`	`+ @Override public Router.Match find(String method, String path, MessageEncoder encoder) {`
`20`	`21`	`return super.find(method, path.toLowerCase(), encoder);`
`21`	`22`	`}`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public RouteTreeNormPath(RouteTree tree) {`
`17`	`17`	`return super.find(method, Router.normalizePath(path));`
`18`	`18`	`}`
`19`	`19`
`20`		`- @Override public RouterMatch find(String method, String path, MessageEncoder encoder) {`
	`20`	`+ @Override public Router.Match find(String method, String path, MessageEncoder encoder) {`
`21`	`21`	`return super.find(method, Router.normalizePath(path), encoder);`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -582,8 +582,8 @@ public void destroy() {`
`582`	`582`	`if (predicateMap != null) {`
`583`	`583`	`for (Map.Entry<Predicate<Context>, RouteTree> e : predicateMap.entrySet()) {`
`584`	`584`	`if (e.getKey().test(ctx)) {`
`585`		`- RouterMatch match = e.getValue().find(ctx.getMethod(), ctx.getRequestPath(), encoder);`
`586`		`- if (match.matches) {`
	`585`	`+ Router.Match match = e.getValue().find(ctx.getMethod(), ctx.getRequestPath(), encoder);`
	`586`	`+ if (match.matches()) {`
`587`	`587`	`return match;`
`588`	`588`	`}`
`589`	`589`	`}`