parse-variants 1.0.8

Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
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

use assert2::check;
use assert2::let_assert;
use syn::Expr;
use syn::LitInt;

use crate::Parse;

mod keywords {
    syn::custom_keyword!(or);
}

#[derive(Parse)]
enum EnumWithNamedVariants {
    TwoIntegersWithComma {
        first: syn::LitInt,
        _comma: syn::token::Comma,
        second: syn::LitInt,
    },
    TwoExpressionsSeparatedByKeyword {
        first: syn::Expr,
        _or: keywords::or,
        second: syn::Expr,
    },
}

#[test]
fn the_first_variant_that_parses_is_returned2() {
    // this tests that expression will be parsed although the ident is just as suitable
    // this is because the order matters
    let variant = syn::parse_str::<EnumWithNamedVariants>("1+1 or x+y").unwrap();
    let expected_first = syn::parse_str::<Expr>("1+1").unwrap();
    let expected_second = syn::parse_str::<Expr>("x+y").unwrap();
    let_assert!(
        EnumWithNamedVariants::TwoExpressionsSeparatedByKeyword { first, _or, second } = variant
    );
    check!(first == expected_first);
    check!(second == expected_second);
}

#[test]
fn the_first_variant_that_parses_is_returned1() {
    // this tests that expression will be parsed although the ident is just as suitable
    // this is because the order matters
    let variant = syn::parse_str::<EnumWithNamedVariants>("123,456").unwrap();
    let expected_first = syn::parse_str::<LitInt>("123").unwrap();
    let expected_second = syn::parse_str::<LitInt>("456").unwrap();
    let_assert!(
        EnumWithNamedVariants::TwoIntegersWithComma {
            first,
            _comma,
            second
        } = variant
    );
    check!(first == expected_first);
    check!(second == expected_second);
}

#[test]
fn parsing_gives_error_if_none_of_the_variants_can_be_parsed() {
    let variant = syn::parse_str::<EnumWithNamedVariants>("---this cannot be parsed---");
    check!(variant.is_err());
}