yuri 0.1.0

no_std alloc-free URI Parser
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

//! URI Query Parsing

use crate::{error::QueryError, Query};
use logos::{Lexer, Logos};

#[derive(Debug, Logos)]
pub(super) enum QueryToken<'uri> {
    #[regex(r"[#]", priority = 200)]
    MaybeLocationStart(&'uri str),

    #[regex(r"[^#]+", |lex| lex.slice(), priority = 100)]
    MaybeSomethingElse(&'uri str),
}

pub(super) fn parse_query<'uri>(
    lexer: &mut Lexer<'uri, QueryToken<'uri>>,
) -> Result<(Option<Query<'uri>>, Option<&'uri str>), QueryError<'uri>> {
    let mut res: Option<Query<'uri>> = None;
    let mut carry: Option<&'uri str> = None;

    while let Some(token) = lexer.next() {
        match token {
            Ok(QueryToken::MaybeSomethingElse(whatever)) => {
                res = Some(Query {
                    raw_query: whatever,
                });
            }
            Ok(QueryToken::MaybeLocationStart(start)) => {
                carry = Some(start);
                break;
            }
            _ => {
                let cut_slice = &lexer.source()[lexer.span().start..];
                let cut_span = &lexer.source()[lexer.span().start..lexer.span().end];

                let detail = crate::error::ParsingDetail {
                    component: "query",
                    span_start: lexer.span().start,
                    span_end: lexer.span().end,
                    source: lexer.source(),
                    clipped_span: cut_span,
                    clipped_remaining: cut_slice,
                };
                return Err(QueryError::ParsingDetailed(detail));
            }
        }
    }

    // Query is optional
    Ok((res, carry))
}

#[cfg(test)]
mod test {

    use super::*;
    use rstest::rstest;

    #[rstest]
    #[case("baz=nn#nn", "nn", Ok((Some(Query { raw_query: "baz=nn" }), Some("#"))))]
    #[case("foo=bar&baz=foo#nn", "nn", Ok((Some(Query { raw_query: "foo=bar&baz=foo" }), Some("#"))))]
    #[case("foo=bar", "", Ok((Some(Query { raw_query: "foo=bar" }), None)))]
    fn t_query(
        #[case] s: &'static str,
        #[case] remaining: &'static str,
        #[case] expected: Result<(Option<Query<'static>>, Option<&str>), QueryError<'static>>,
    ) {
        let mut lexer = QueryToken::lexer(s);
        let a = parse_query(&mut lexer);
        assert_eq!(expected, a);
        assert_eq!(remaining, lexer.remainder());
    }
}