nidus-http 1.0.15

Axum and Tower HTTP integration, controllers, middleware, health, metrics, and server defaults for Nidus.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use crate::error::RoutePathError;

pub(crate) fn join_paths(prefix: &str, path: &str) -> Result<String, RoutePathError> {
    let prefix = normalize_mount_prefix(prefix)?;
    let path = normalize_path(path)?;
    Ok(join_normalized_paths(&prefix, &path))
}

pub(crate) fn normalize_mount_prefix(prefix: impl AsRef<str>) -> Result<String, RoutePathError> {
    let mut prefix = normalize_path(prefix)?;
    let trimmed_len = prefix.trim_end_matches('/').len();
    if trimmed_len == 0 {
        prefix.truncate(1);
    } else {
        prefix.truncate(trimmed_len);
    }
    Ok(prefix)
}

pub(crate) fn normalize_path(path: impl AsRef<str>) -> Result<String, RoutePathError> {
    let path = path.as_ref().trim();
    let parameter_count = validate_path(path)?;
    let leading_slash = usize::from(!path.starts_with('/'));
    let mut normalized = String::with_capacity(path.len() + leading_slash + parameter_count);
    if leading_slash == 1 {
        normalized.push('/');
    }

    for (index, segment) in path.split('/').enumerate() {
        if index > 0 {
            normalized.push('/');
        }
        if let Some(name) = segment.strip_prefix(':') {
            normalized.push('{');
            normalized.push_str(name);
            normalized.push('}');
        } else {
            normalized.push_str(segment);
        }
    }
    Ok(normalized)
}

pub(crate) fn join_normalized_paths(prefix: &str, path: &str) -> String {
    if prefix == "/" {
        return path.to_owned();
    }
    if path == "/" {
        return prefix.to_owned();
    }

    let mut full_path = String::with_capacity(prefix.len() + path.len());
    full_path.push_str(prefix);
    full_path.push_str(path);
    full_path
}

fn validate_path(path: &str) -> Result<usize, RoutePathError> {
    let mut parameter_count = 0;
    for segment in path.split('/') {
        if segment == ":" {
            return Err(RoutePathError::empty_parameter(path));
        }
        if segment.starts_with(':') {
            parameter_count += 1;
        }
    }
    Ok(parameter_count)
}

#[cfg(test)]
mod tests {
    use super::{join_normalized_paths, normalize_mount_prefix, normalize_path};

    #[test]
    fn normalize_path_preserves_structure_and_converts_parameters() {
        for (input, expected) in [
            ("", "/"),
            ("/", "/"),
            (
                " users/:id/posts/:post_id/ ",
                "/users/{id}/posts/{post_id}/",
            ),
            ("//users//:id", "//users//{id}"),
            ("/users/{id}", "/users/{id}"),
        ] {
            assert_eq!(normalize_path(input).unwrap(), expected, "{input}");
        }
    }

    #[test]
    fn normalized_path_join_handles_root_and_nested_routes() {
        assert_eq!(join_normalized_paths("/", "/users/{id}"), "/users/{id}");
        assert_eq!(normalize_mount_prefix("/health///").unwrap(), "/health");
        assert_eq!(join_normalized_paths("/health", "/"), "/health");
        assert_eq!(
            join_normalized_paths("/users", "/{id}/posts"),
            "/users/{id}/posts"
        );
    }
}