rust-web-server 17.62.0

A dependency-minimal Rust web platform: HTTP/1.1, HTTP/2, and HTTP/3 server, reverse proxy, and application framework with routing, middleware (auth, rate limiting, tracing), an async ORM, background jobs, object storage, and a mailer. Runs as a zero-code config-driven proxy or as a library crate. No third-party HTTP dependencies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Path-pattern parsing and segment matching shared by [`super::Router`] and
//! `AsyncAppWithState` (`crate::async_state`).
//!
//! `AsyncAppWithState`'s handlers return `Future`s, which `Router`'s
//! `HandlerFn` type doesn't support, so it can't reuse `Router` itself — but
//! the underlying pattern-matching algorithm is identical, so it lives here
//! once instead of being duplicated.

use std::collections::HashMap;

#[derive(Clone)]
pub(crate) enum Segment {
    Literal(String),
    Param(String),
    Wildcard(String),
}

pub(crate) fn parse_pattern(pattern: &str) -> Vec<Segment> {
    if pattern == "/" {
        return vec![];
    }
    pattern
        .split('/')
        .filter(|s| !s.is_empty())
        .map(|seg| {
            if let Some(name) = seg.strip_prefix(':') {
                Segment::Param(name.to_string())
            } else if let Some(name) = seg.strip_prefix('*') {
                Segment::Wildcard(name.to_string())
            } else {
                Segment::Literal(seg.to_string())
            }
        })
        .collect()
}

/// Matches `path` (already split on `/`, empty segments filtered out)
/// against `pattern`. Returns the extracted named/wildcard values on a match.
pub(crate) fn try_match(pattern: &[Segment], path: &[&str]) -> Option<HashMap<String, String>> {
    let mut params = HashMap::new();
    let mut pi = 0;

    for (si, seg) in pattern.iter().enumerate() {
        match seg {
            Segment::Literal(lit) => {
                if pi >= path.len() || path[pi] != lit.as_str() {
                    return None;
                }
                pi += 1;
            }
            Segment::Param(name) => {
                if pi >= path.len() {
                    return None;
                }
                params.insert(name.clone(), path[pi].to_string());
                pi += 1;
            }
            Segment::Wildcard(name) => {
                if si != pattern.len() - 1 {
                    return None; // wildcard must be the last segment
                }
                params.insert(name.clone(), path[pi..].join("/"));
                pi = path.len();
            }
        }
    }

    if pi == path.len() { Some(params) } else { None }
}

/// Reconstructs the original `.get()`/`.post()`/etc. pattern string from
/// parsed segments — the inverse of [`parse_pattern`]. Used by both
/// `Router::route_entries` and `AsyncAppWithState::route_entries`.
pub(crate) fn segments_to_pattern(segs: &[Segment]) -> String {
    if segs.is_empty() {
        return "/".to_string();
    }
    let parts: Vec<String> = segs
        .iter()
        .map(|s| match s {
            Segment::Literal(l) => l.clone(),
            Segment::Param(n) => format!(":{}", n),
            Segment::Wildcard(n) => format!("*{}", n),
        })
        .collect();
    format!("/{}", parts.join("/"))
}