feat: add dynamic parameter map to Context

Co-authored-by: Bruno Thomas <bthomas@icij.org>

Author: caro3801

pom.xml

@@ -4,7 +4,7 @@
 
   <groupId>net.code-story</groupId>
   <artifactId>http</artifactId>
-  <version>2.106</version>
+  <version>2.106-SNAPSHOT</version>
   <packaging>jar</packaging>
 
   <name>CodeStory - Fluent-http</name>

src/main/java/net/codestory/http/Context.java

@@ -15,15 +15,20 @@
  */
 package net.codestory.http;
 
-import java.io.*;
-import java.lang.reflect.*;
-import java.util.*;
-
-import net.codestory.http.forms.*;
-import net.codestory.http.injection.*;
+import net.codestory.http.forms.Form;
+import net.codestory.http.injection.IocAdapter;
 import net.codestory.http.misc.Env;
-import net.codestory.http.security.*;
-import net.codestory.http.templating.*;
+import net.codestory.http.security.User;
+import net.codestory.http.templating.Site;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 public class Context {
   private final Request request;
@@ -33,6 +38,8 @@ public class Context {
   private final Site site;
   private User currentUser;
 
+  private Map<String, String> pathParams;
+
   public Context(Request request, Response response, IocAdapter iocAdapter, Env env, Site site) {
     this.request = request;
     this.response = response;
@@ -101,6 +108,26 @@ public User currentUser() {
     return currentUser;
   }
 
+  // Set path params for this context (used by router).
+  public void setPathParams(Map<String, String> pathParams) {
+    this.pathParams = pathParams;
+  }
+
+  // Get all path parameters as a map.
+  public Map<String, String> pathParams() {
+    return pathParams != null ? Collections.unmodifiableMap(pathParams) : Collections.emptyMap();
+  }
+
+  // Get a specific path parameter by name.
+  public String pathParam(String name) {
+    return pathParams != null ? pathParams.get(name) : null;
+  }
+
+  // Get all path parameter names.
+  public Set<String> pathParamNames() {
+    return pathParams != null ? Collections.unmodifiableSet(pathParams.keySet()) : Collections.emptySet();
+  }
+
   @SuppressWarnings("unchecked")
   public <T> T extract(Class<T> type) throws IOException {
     return (T) extract((Type) type);

src/main/java/net/codestory/http/routes/RouteWithPattern.java

@@ -19,6 +19,7 @@
 import static net.codestory.http.constants.Methods.HEAD;
 
 import java.util.Arrays;
+import java.util.Map;
 import java.util.Objects;
 
 import net.codestory.http.Context;
@@ -53,6 +54,7 @@ public boolean matchMethod(String method) {
   public Object body(Context context) throws Exception {
     try {
       String[] parameters = uriParser.params(context.uri(), context.request().query());
+      context.setPathParams(uriParser.paramsMap(context.uri(), context.request().query()));
       return route.body(context, parameters);
     } catch (Exception e) {
       Logs.unableToApplyRoute(context.method(), context.uri());

src/main/java/net/codestory/http/routes/UriParser.java

@@ -18,6 +18,9 @@
 import net.codestory.http.Query;
 import net.codestory.http.io.Strings;
 
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Objects;
 
 import static java.util.Arrays.asList;
@@ -43,16 +46,7 @@ public String[] params(String uri, Query query) {
     String[] uriParts = parts(uri);
     String[] params = new String[paramsCount];
 
-    int index = 0;
-    for (int i = 0; i < patternParts.length; i++) {
-      if (patternParts[i].startsWith(":")) {
-        if (i == patternParts.length - 1 && patternParts[i].startsWith(":") && patternParts[i].endsWith(":"))
-          params[index++] = String.join("/", asList(uriParts).subList(i, uriParts.length));
-        else {
-          params[index++] = uriParts[i];
-        }
-      }
-    }
+    int index = addPathParams(uriParts, params);
     for (int i = 0; i < queryParamsParts.length; i++) {
       if (queryParamsParts[i].startsWith(":")) {
         params[index++] = query.get(queryParamsParts[i - 1]);
@@ -62,6 +56,57 @@ public String[] params(String uri, Query query) {
     return params;
   }
 
+  private int addPathParams(String[] uriParts, String[] params) {
+    int index = 0;
+    for (int i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":")) {
+          params[index++] = paramValue(uriParts, i);
+      }
+    }
+    return index;
+  }
+
+  private String paramValue(String[] uriParts, int i) {
+    if (isGreedy(i)) {
+        return String.join("/", asList(uriParts).subList(i, uriParts.length));
+    }
+    return uriParts[i];
+  }
+
+  private boolean isGreedy(int i) {
+    return i == patternParts.length - 1 && patternParts[i].endsWith(":");
+  }
+
+  /**
+   * Utility to pair names and values into a map.
+   */
+  public static Map<String, String> toNameValueMap(String[] names, String[] values) {
+    Map<String, String> map = new LinkedHashMap<>();
+    for (int i = 0; i < names.length && i < values.length; i++) {
+      map.put(names[i], values[i]);
+    }
+    return map;
+  }
+
+  /**
+   * Returns the names of the path parameters in the pattern (e.g. ["index"] for /foo/:index)
+   */
+  public String[] paramNames() {
+    return Arrays.stream(patternParts)
+      .filter(part -> part.startsWith(":"))
+      .map(part -> part.substring(1))
+      .toArray(String[]::new);
+  }
+
+  /**
+   * Returns a map of param name to value for the given uri and query.
+   */
+  public Map<String, String> paramsMap(String uri, Query query) {
+    String[] names = paramNames();
+    String[] values = params(uri, query);
+    return toNameValueMap(names, values);
+  }
+
   public boolean matches(String uri) {
     String[] uriParts = parts(stripQueryParams(uri));
     if (patternParts.length != uriParts.length && !endsWithGreedyParameter(uriPattern)) {