Add URL redirect filter (301/302) (#64)

* Add `RedirectRule` class to handle URL redirection logic with support for exact and wildcard path matching

* Add `RedirectFilter` to handle HTTP URL redirection logic using configurable rules

* WIP: Save current work

* Fix HttpResponse empty constructor to initialize fields

Initialize headers map and body array in empty constructor to prevent
NullPointerException when setHeader() or setBody() are called.

Before:
  HttpResponse() {}  // headers = null, body = null

After:
  HttpResponse() {
      this.headers = new LinkedHashMap<>();
      this.body = new byte[0];
  }

This fix is required for RedirectFilter and any other code that creates
empty HttpResponse objects and modifies them using setters.

Fixes crashes in RedirectFilterTest.

* Improve wildcard matching in `RedirectRule` by using `Pattern.quote` for safer and more precise regex generation.

* Update `RedirectFilterTest` to include client IP address in test request creation

---------

Co-authored-by: Kristina M <kristina0x7@gmail.com>

Author: annikaholmqvist94

src/main/java/org/juv25d/App.java

@@ -9,6 +9,9 @@
 import org.juv25d.plugin.StaticFilesPlugin;
 import org.juv25d.router.SimpleRouter; // New import
 import org.juv25d.util.ConfigLoader;
+import org.juv25d.filter.RedirectFilter;
+import org.juv25d.filter.RedirectRule;
+import java.util.List;
 
 import java.util.Set;
 import java.util.logging.Logger;
@@ -20,6 +23,14 @@ public static void main(String[] args) {
         HttpParser httpParser = new HttpParser();
 
         Pipeline pipeline = new Pipeline();
+        // Configure redirect rules
+        List<RedirectRule> redirectRules = List.of(
+            new RedirectRule("/old-page", "/new-page", 301),
+            new RedirectRule("/temp", "https://example.com/temporary", 302),
+            new RedirectRule("/docs/*", "/documentation/", 301)
+        );
+        pipeline.addGlobalFilter(new RedirectFilter(redirectRules), 0);
+
 
         // IP filter is enabled but configured with open access during development
         // White/blacklist can be tightened when specific IP restrictions are decided

src/main/java/org/juv25d/filter/RedirectFilter.java

@@ -0,0 +1,83 @@
+package org.juv25d.filter;
+
+import org.juv25d.http.HttpRequest;
+import org.juv25d.http.HttpResponse;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Logger;
+
+/**
+ * Filter that handles URL redirects based on configurable rules.
+ *
+ * When a request matches a redirect rule:
+ * - The pipeline is stopped (no further processing)
+ * - A redirect response is returned with the appropriate Location header
+ * - Status code is either 301 (Moved Permanently) or 302 (Found/Temporary)
+ *
+ * Rules are evaluated in order - the first matching rule wins.
+ *
+ * Example usage:
+ * <pre>
+ * List<RedirectRule> rules = List.of(
+ *     new RedirectRule("/old-page", "/new-page", 301),
+ *     new RedirectRule("/temp", "https://example.com", 302),
+ *     new RedirectRule("/docs/*", "/documentation/", 301)
+ * );
+ * pipeline.addFilter(new RedirectFilter(rules));
+ * </pre>
+ */
+public class RedirectFilter implements Filter {
+    private final List<RedirectRule> rules;
+    private final Logger logger;
+
+    /**
+     * Creates a redirect filter with the given rules.
+     *
+     * @param rules List of redirect rules (evaluated in order)
+     */
+    public RedirectFilter(List<RedirectRule> rules) {
+        this.rules = rules;
+        this.logger = Logger.getLogger(RedirectFilter.class.getName());
+    }
+
+    @Override
+    public void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) throws IOException {
+        String requestPath = request.path();
+
+        // Check each rule in order - first match wins
+        for (RedirectRule rule : rules) {
+            if (rule.matches(requestPath)) {
+                logger.info("Redirecting: " + requestPath + " -> " + rule.getTargetUrl()
+                    + " (" + rule.getStatusCode() + ")");
+
+                performRedirect(response, rule);
+
+                // Stop pipeline - don't call chain.doFilter()
+                return;
+            }
+        }
+
+        // No matching rule - continue pipeline
+        chain.doFilter(request, response);
+    }
+
+    /**
+     * Sets up the redirect response with appropriate headers.
+     *
+     * @param response The HTTP response to modify
+     * @param rule The redirect rule to apply
+     */
+    private void performRedirect(HttpResponse response, RedirectRule rule) {
+        int statusCode = rule.getStatusCode();
+        String statusText = statusCode == 301 ? "Moved Permanently" : "Found";
+
+        response.setStatusCode(statusCode);
+        response.setStatusText(statusText);
+        response.setHeader("Location", rule.getTargetUrl());
+        response.setHeader("Content-Length", "0");
+
+        // Empty body for redirects
+        response.setBody(new byte[0]);
+    }
+}

src/main/java/org/juv25d/filter/RedirectRule.java

@@ -0,0 +1,98 @@
+package org.juv25d.filter;
+
+import java.util.regex.Pattern;
+
+/**
+ * Represents a URL redirect rule.
+ *
+ * A redirect rule consists of:
+ * - sourcePath: The path to match (supports exact match or wildcards with *)
+ * - targetUrl: The URL to redirect to
+ * - statusCode: HTTP status code (301 for permanent, 302 for temporary)
+ *
+ * Examples:
+ * - new RedirectRule("/old-page", "/new-page", 301)
+ * - new RedirectRule("/temp", "https://example.com", 302)
+ * - new RedirectRule("/docs/*", "/documentation/", 301)
+ */
+public class RedirectRule {
+    private final String sourcePath;
+    private final String targetUrl;
+    private final int statusCode;
+
+    /**
+     * Creates a redirect rule with exact path matching.
+     *
+     * @param sourcePath The path to match (e.g., "/old-page" or "/docs/*" for wildcard)
+     * @param targetUrl The URL to redirect to
+     * @param statusCode HTTP status code (301 or 302)
+     */
+    public RedirectRule(String sourcePath, String targetUrl, int statusCode) {
+        validateStatusCode(statusCode);
+        this.sourcePath = sourcePath;
+        this.targetUrl = targetUrl;
+        this.statusCode = statusCode;
+    }
+
+    /**
+     * Checks if the given request path matches this rule.
+     *
+     * Supports:
+     * - Exact matching: "/old-page" matches exactly "/old-page"
+     * - Wildcard matching: "/docs/*" matches "/docs/api", "/docs/guide", etc.
+     *
+     * @param requestPath The request path to check
+     * @return true if the path matches this rule
+     */
+    public boolean matches(String requestPath) {
+        if (requestPath == null) {
+            return false;
+        }
+
+        // Check for wildcard matching
+        if (sourcePath.contains("*")) {
+            // Split on wildcard, escape each literal segment, then rejoin with ".*"
+            String[] parts = sourcePath.split("\\*", -1);
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < parts.length; i++) {
+                sb.append(Pattern.quote(parts[i]));
+                if (i < parts.length - 1) {
+                    sb.append(".*");
+                }
+            }
+            return requestPath.matches(sb.toString());
+        }
+
+        // Exact match
+        return requestPath.equals(sourcePath);
+    }
+
+    public String getSourcePath() {
+        return sourcePath;
+    }
+
+    public String getTargetUrl() {
+        return targetUrl;
+    }
+
+    public int getStatusCode() {
+        return statusCode;
+    }
+
+    private void validateStatusCode(int statusCode) {
+        if (statusCode != 301 && statusCode != 302) {
+            throw new IllegalArgumentException(
+                "Status code must be 301 (Moved Permanently) or 302 (Found). Got: " + statusCode
+            );
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "RedirectRule{" +
+            "sourcePath='" + sourcePath + '\'' +
+            ", targetUrl='" + targetUrl + '\'' +
+            ", statusCode=" + statusCode +
+            '}';
+    }
+}

src/main/java/org/juv25d/http/HttpResponse.java

@@ -14,7 +14,10 @@ public class HttpResponse {
     private Map<String, String> headers;
     private byte[] body;
 
-    public HttpResponse(){}
+    public HttpResponse(){
+        this.headers = new LinkedHashMap<>();
+        this.body = new byte[0];
+    }
 
     public HttpResponse(int statusCode, String statusText, Map<String, String> headers, byte[] body) {
         this.statusCode = statusCode;