cmdparse 0.1.1

Parsing user's commands into arbitrary Rust types
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

#![doc(hidden)]
//! These macro are intended for testing the implementation in this crate and in the order crates
//! that are part of the `cmdparse` repository. Although these macros are public, they can be
//! changed, removed, renamed at any point for any reason.

#[doc(hidden)]
#[macro_export]
macro_rules! token {
    (--$text:literal) => {
        $crate::tokens::Token::Attribute($crate::tokens::RawLexeme::new($text))
    };
    ($text:literal) => {
        $crate::tokens::Token::Text($crate::tokens::RawLexeme::new($text))
    };
}

pub use token;

#[doc(hidden)]
#[macro_export]
macro_rules! test_parse {
    ($name:ident, $type:ty, $input:literal => Ok($value:expr, $next_token:expr)) => {
        #[test]
        fn $name() {
            let parser = <$type as $crate::Parsable<()>>::Parser::default();
            let stream = $crate::tokens::TokenStream::new($input);
            let (result, remaining) = $crate::Parser::<()>::parse(&parser, stream, ()).unwrap();
            assert_eq!(result, $value);
            assert_eq!(remaining.peek().transpose().unwrap(), $next_token);
        }
    };
    ($name:ident, $type:ty, $input:literal => Error($error:expr)) => {
        #[test]
        fn $name() {
            let parser = <$type as $crate::Parsable<()>>::Parser::default();
            let stream = $crate::tokens::TokenStream::new($input);
            let error = $crate::Parser::<()>::parse(&parser, stream, ()).unwrap_err();
            match error {
                $crate::error::ParseFailure::Error(error) => assert_eq!(error, $error),
                $crate::error::ParseFailure::Unrecognized(unrecognized) => {
                    panic!("expected Error, but found {:?}", unrecognized)
                }
            }
        }
    };
    ($name:ident, $type:ty, $input:literal => Unrecognized($token:expr, $next_token:expr)) => {
        #[test]
        fn $name() {
            let parser = <$type as $crate::Parsable<()>>::Parser::default();
            let stream = $crate::tokens::TokenStream::new($input);
            let error = $crate::Parser::<()>::parse(&parser, stream, ()).unwrap_err();
            match error {
                $crate::error::ParseFailure::Error(error) => {
                    panic!("expected Unrecognized, but found {:?}", error)
                }
                $crate::error::ParseFailure::Unrecognized(unrecognized) => {
                    assert_eq!(unrecognized.token(), $token);
                    assert_eq!(
                        unrecognized.remaining().peek().transpose().unwrap(),
                        $next_token
                    );
                }
            }
        }
    };
}

pub use test_parse;

#[doc(hidden)]
#[macro_export]
macro_rules! test_complete {
    ($name:ident, $type:ty, $input:literal => { consumed: $consumed:expr, remaining: $remaining:expr, suggestions: [$($suggestion:expr),*] $(,)?}) => {
        #[test]
        #[allow(clippy::bool_assert_comparison)]
        fn $name() {
            let parser = <$type as $crate::Parsable<()>>::Parser::default();
            let stream = $crate::tokens::TokenStream::new($input);
            let result = $crate::Parser::<()>::complete(&parser, stream, ());
            assert_eq!(result.suggestions, ::std::collections::BTreeSet::from([$($suggestion.into()),*]));
            assert_eq!(result.value_consumed, $consumed);
            assert_eq!(result.remaining.map(|input| input.peek().transpose().unwrap()), $remaining);
        }
    };
}

pub use test_complete;