use-route 0.0.1

Small route and path utilities for RustUse
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

/// A normalized route segment.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RouteSegment {
    pub value: String,
}

/// A captured route parameter.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RouteParam {
    pub name: String,
    pub value: String,
}

/// Normalizes repeated slashes and removes trailing slashes except for the root route.
#[must_use]
pub fn normalize_route(input: &str) -> String {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return String::from("/");
    }

    let absolute = trimmed.starts_with('/');
    let segments = trimmed
        .split('/')
        .filter(|segment| !segment.is_empty())
        .collect::<Vec<_>>();

    if segments.is_empty() {
        return String::from("/");
    }

    let joined = segments.join("/");
    if absolute {
        format!("/{joined}")
    } else {
        joined
    }
}

/// Joins two route fragments with exactly one slash.
#[must_use]
pub fn join_routes(a: &str, b: &str) -> String {
    let absolute = a.trim().starts_with('/');
    let segments = a
        .split('/')
        .chain(b.split('/'))
        .filter(|segment| !segment.trim().is_empty())
        .collect::<Vec<_>>();

    if segments.is_empty() {
        return if absolute {
            String::from("/")
        } else {
            String::new()
        };
    }

    let joined = segments.join("/");
    if absolute {
        format!("/{joined}")
    } else {
        joined
    }
}

/// Splits a route into normalized segments.
#[must_use]
pub fn split_route(input: &str) -> Vec<RouteSegment> {
    let normalized = normalize_route(input);
    normalized
        .split('/')
        .filter(|segment| !segment.is_empty())
        .map(|segment| RouteSegment {
            value: segment.to_string(),
        })
        .collect()
}

/// Returns `true` when the route is absolute.
#[must_use]
pub fn is_absolute_route(input: &str) -> bool {
    input.trim().starts_with('/')
}

/// Returns the number of non-empty route segments.
#[must_use]
pub fn route_depth(input: &str) -> usize {
    split_route(input).len()
}

/// Returns `true` when a simple `:param` pattern matches the path.
#[must_use]
pub fn matches_route_pattern(pattern: &str, path: &str) -> bool {
    let pattern_segments = split_route(pattern);
    let path_segments = split_route(path);
    if pattern_segments.len() != path_segments.len() {
        return false;
    }

    pattern_segments
        .iter()
        .zip(path_segments.iter())
        .all(|(pattern_segment, path_segment)| {
            pattern_segment.value.starts_with(':') || pattern_segment.value == path_segment.value
        })
}

/// Extracts named route parameters when a pattern matches.
#[must_use]
pub fn extract_route_params(pattern: &str, path: &str) -> Vec<RouteParam> {
    if !matches_route_pattern(pattern, path) {
        return Vec::new();
    }

    split_route(pattern)
        .into_iter()
        .zip(split_route(path))
        .filter_map(|(pattern_segment, path_segment)| {
            pattern_segment
                .value
                .strip_prefix(':')
                .filter(|name| !name.is_empty())
                .map(|name| RouteParam {
                    name: name.to_string(),
                    value: path_segment.value,
                })
        })
        .collect()
}