udled_tokenizers/
bool.rs

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
use udled::{any, token::Or, Either, Error, Item, Reader, Tokenizer};

/// Match 'true' or 'false'
#[derive(Debug, Clone, Copy, Default)]
pub struct Bool;

impl Tokenizer for Bool {
    type Token<'a> = Item<bool>;

    fn to_token<'a>(&self, reader: &mut Reader<'_, 'a>) -> Result<Self::Token<'a>, Error> {
        let ret = reader.parse(Or("true", "false"))?;

        let item = match ret {
            Either::Left(span) => Item::new(true, span),
            Either::Right(span) => Item::new(false, span),
        };

        Ok(item)
    }

    fn eat(&self, reader: &mut Reader<'_, '_>) -> Result<(), Error> {
        reader.eat(Or("true", "false"))
    }

    fn peek<'a>(&self, reader: &mut Reader<'_, '_>) -> Result<bool, Error> {
        reader.peek(any!("true", "false"))
    }
}

#[cfg(test)]
mod test {
    use udled::{token::Ws, Input};

    use super::Bool;

    #[test]
    fn bool() {
        let mut input = Input::new("true false");

        let (a, _, b) = input.parse((Bool, Ws, Bool)).unwrap();

        assert_eq!(a.value, true);
        assert_eq!(b.value, false);
        assert!(input.eos())
    }
}