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

//! URI Fragment Parsing

use crate::{error::FragmentError, Fragment};
use logos::{Lexer, Logos};

#[derive(Debug, Logos)]
pub(super) enum FragmentToken<'uri> {
    #[regex(r".+", |lex| lex.slice(), priority = 100)]
    MaybeFragment(&'uri str),
}

pub(super) fn parse_fragment<'uri>(
    lexer: &mut Lexer<'uri, FragmentToken<'uri>>,
) -> Result<(Option<Fragment<'uri>>, Option<&'uri str>), FragmentError<'uri>> {
    let mut res: Option<Fragment<'uri>> = None;
    let carry: Option<&'uri str> = None;

    while let Some(token) = lexer.next() {
        match token {
            Ok(FragmentToken::MaybeFragment(whatever)) => {
                res = Some(Fragment {
                    raw_fragment: whatever,
                });
            }
            _ => {
                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: "fragment",
                    span_start: lexer.span().start,
                    span_end: lexer.span().end,
                    source: lexer.source(),
                    clipped_span: cut_span,
                    clipped_remaining: cut_slice,
                };
                return Err(FragmentError::ParsingDetailed(detail));
            }
        }
    }

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

#[cfg(test)]
mod test {

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

    #[rstest]
    #[case("nn", "", Ok((Some(Fragment { raw_fragment: "nn" }), None)))]
    fn t_fragment(
        #[case] s: &'static str,
        #[case] remaining: &'static str,
        #[case] expected: Result<(Option<Fragment<'static>>, Option<&str>), FragmentError<'static>>,
    ) {
        let mut lexer = FragmentToken::lexer(s);
        let a = parse_fragment(&mut lexer);
        assert_eq!(expected, a);
        assert_eq!(remaining, lexer.remainder());
    }
}