Route reverse path

jknack · jknack · commit a1bf0982fc6b · 2020-01-09T11:36:25.000-03:00
diff --git a/jooby/src/main/java/io/jooby/Route.java b/jooby/src/main/java/io/jooby/Route.java
@@ -437,6 +437,30 @@ public Route(@Nonnull String method, @Nonnull String pattern, @Nonnull Handler h
     return pipeline;
   }
 
+  /**
+   * Recreate a path pattern using the given variables.
+   *
+   * <code>reserve(/{k1}/{k2}, {"k1": ""foo", "k2": "bar"}) => /foo/bar</code>
+   *
+   * @param keys Path keys.
+   * @return Path.
+   */
+  public @Nonnull String reverse(@Nonnull Map<String, Object> keys) {
+    return Router.reverse(getPattern(), keys);
+  }
+
+  /**
+   * Recreate a path pattern using the given variables.
+   *
+   * <code>reserve(/{k1}/{k2}, "foo", "bar") => /foo/bar</code>
+   *
+   * @param values Values.
+   * @return Path.
+   */
+  public @Nonnull String reverse(Object... values) {
+    return Router.reverse(getPattern(), values);
+  }
+
   /**
    * Handler instance which might or might not be the same as {@link #getHandler()}.
    *
diff --git a/jooby/src/main/java/io/jooby/Router.java b/jooby/src/main/java/io/jooby/Router.java
@@ -17,15 +17,18 @@
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.function.Predicate;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.unmodifiableList;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Routing DSL functions.
@@ -870,4 +873,70 @@ default Router error(@Nonnull Predicate<StatusCode> predicate,
         return unmodifiableList(result);
     }
   }
+
+  /**
+   * Recreate a path pattern using the given variables. Variable replacement is done using the
+   * current index.
+   *
+   * @param pattern Path pattern.
+   * @param values Path keys.
+   * @return Path.
+   */
+  static @Nonnull String reverse(@Nonnull String pattern, @Nonnull Object... values) {
+    Map<String, Object> keys = new HashMap<>();
+    IntStream.range(0, values.length).forEach(k -> keys.put(Integer.toString(k), values[k]));
+    return reverse(pattern, keys);
+  }
+
+  /**
+   * Recreate a path pattern using the given variables.
+   *
+   * @param pattern Path pattern.
+   * @param keys Path keys.
+   * @return Path.
+   */
+  static @Nonnull String reverse(@Nonnull String pattern, @Nonnull Map<String, Object> keys) {
+    StringBuilder path = new StringBuilder();
+    int start = 0;
+    int end = Integer.MAX_VALUE;
+    int len = pattern.length();
+    int keyIdx = 0;
+    for (int i = 0; i < len; i++) {
+      char ch = pattern.charAt(i);
+      if (ch == '{') {
+        path.append(pattern, start, i);
+        start = i + 1;
+        end = Integer.MAX_VALUE;
+      } else if (ch == ':') {
+        end = i;
+      } else if (ch == '}') {
+        String id = pattern.substring(start, Math.min(i, end));
+        Object value = keys.getOrDefault(id, keys.get(Integer.toString(keyIdx++)));
+        requireNonNull(value, "Missing key: '" + id + "'");
+        path.append(value);
+        start = i + 1;
+        end = Integer.MAX_VALUE;
+      } else if (ch == '*') {
+        path.append(pattern, start, i);
+        String id;
+        if (i == len - 1) {
+          id = "*";
+        } else {
+          id = pattern.substring(i + 1);
+        }
+        Object value = keys.getOrDefault(id, keys.get(Integer.toString(keyIdx++)));
+        requireNonNull(value, "Missing key: '" + id + "'");
+        path.append(value);
+        start = len;
+        i = len;
+      }
+    }
+    if (path.length() == 0) {
+      return pattern;
+    }
+    if (start > 0) {
+      path.append(pattern, start, len);
+    }
+    return path.toString();
+  }
 }
diff --git a/jooby/src/test/java/io/jooby/RouterTest.java b/jooby/src/test/java/io/jooby/RouterTest.java
@@ -2,7 +2,10 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Consumer;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -20,10 +23,52 @@ public void pathKeys() {
     pathKeys("/", keys -> assertEquals(0, keys.size()));
     pathKeys("/foo/bar", keys -> assertEquals(0, keys.size()));
     pathKeys("/foo/*", keys -> assertEquals(1, keys.size()));
+    pathKeys("/foo/*name", keys -> assertEquals(1, keys.size()));
     pathKeys("/foo/{x}", keys -> assertEquals(1, keys.size()));
   }
 
+  @Test
+  public void reverseByPosition() {
+    assertEquals("/foo", Router.reverse("/{k}", "foo"));
+    assertEquals("/foo/bar", Router.reverse("/{k1}/{k2}", "foo", "bar"));
+  }
+
+  @Test
+  public void reverse() {
+    assertEquals("foo", Router.reverse("{foo}", map("foo", "foo")));
+
+    assertEquals("/tail", Router.reverse("/*", map("*", "tail")));
+
+    assertEquals("/file/video.mpg", Router.reverse("/file/*", map("*", "video.mpg")));
+    assertEquals("/file/video.mpg", Router.reverse("/file/*video", map("video", "video.mpg")));
+
+    assertEquals("/123", Router.reverse("/{regex:\\d+}", map("regex", 123)));
+
+    assertEquals("/resources/123/edit", Router.reverse("/resources/{num:\\d+}/edit", map("num", 123)));
+
+    assertEquals("/prefix/v1/v2", Router.reverse("/prefix/{k1}/{k2}", map("k1", "v1", "k2", "v2")));
+
+    assertEquals("/v1/suffix", Router.reverse("/{k1}/suffix", map("k1", "v1", "k2", "v2")));
+
+    assertEquals("/foo/v", Router.reverse("/{name}/{k}", map("name", "foo", "k", "v")));
+
+    assertEquals("/foo", Router.reverse("/{name}", map("name", "foo")));
+
+    assertEquals("/", Router.reverse("/", Collections.emptyMap()));
+    assertEquals("/path", Router.reverse("/path", Collections.emptyMap()));
+    assertEquals("/path", Router.reverse("/path", map("k", "v")));
+
+  }
+
   private void pathKeys(String pattern, Consumer<List<String>> consumer) {
     consumer.accept(Router.pathKeys(pattern));
   }
+
+  public Map<String, Object> map(Object... values) {
+    Map<String, Object> map = new HashMap<>();
+    for (int i = 0; i < values.length; i += 2) {
+      map.put(values[i].toString(), values[i + 1]);
+    }
+    return map;
+  }
 }
