pddlp 0.1.7

A PDDL 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

use super::{token::Token, Object, Result};
use logos::Lexer;

pub(super) fn parse<'a>(
    lexer: &mut Lexer<'a, Token<'a>>,
) -> Result<Vec<Object<'a>>> {
    let mut objects = Vec::new();

    let mut object_names: Vec<&'a str> = Vec::new();
    let mut awaiting_type = false;
    while let Some(token) = lexer.next() {
        match token {
            Ok(Token::Name(name)) => match awaiting_type {
                true => {
                    for object in object_names.iter() {
                        objects.push(Object {
                            name: object,
                            type_name: Some(name),
                        });
                    }
                    object_names.clear();
                    awaiting_type = false;
                }
                false => object_names.push(name),
            },
            Ok(Token::TypeSeparator) => awaiting_type = true,
            Ok(Token::RParen) => break,
            Ok(_) => return Err(("unexpected token", lexer.span())),
            Err(_) => return Err(("invalid token", lexer.span())),
        }
    }

    match awaiting_type {
        true => return Err(("erroneous type separator", lexer.span())),
        false => {
            for object in object_names.into_iter() {
                objects.push(Object {
                    name: object,
                    type_name: None,
                });
            }
        }
    }

    Ok(objects)
}

#[cfg(test)]
mod test {
    use super::{Object, Result, Token};
    use logos::Logos;
    use rstest::rstest;

    #[rstest]
    #[case(Ok(vec![Object { name: "a", type_name: None }]), "a)")]
    #[case(Ok(vec![Object { name: "a", type_name: Some("b") }]), "a - b)")]
    #[case(Ok(vec![
        Object { name: "a", type_name: Some("c") }, 
        Object { name: "b", type_name: Some("c") }
    ]), "a b - c)")]
    fn parse(#[case] expected: Result<Vec<Object>>, #[case] input: &str) {
        let mut lexer = Token::lexer(input);
        assert_eq!(expected, super::parse(&mut lexer));
    }
}