tagname 0.3.1

get the name of a variant in your enum as a string
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use tagname::TagName;

#[derive(TagName)]
enum SimpleUnion {
    Yes,
    No,
}

#[derive(TagName)]
enum SimpleUnionSingleTag {
    Yes,
}

#[allow(dead_code)]
struct Arbitrary {
    x: String,
    y: Option<usize>,
}

#[derive(TagName)]
enum ComplexUnion {
    Yes,
    No,
    Maybe(usize),
    Maybe2(usize, usize),
    Maybe3(Arbitrary),
    #[allow(unused)]
    Maybe4 {
        x: Option<String>,
    },
}

#[derive(TagName)]
enum ComplexUnionSingleTag {
    Maybe(usize),
}

#[derive(TagName)]
enum DifferentCasesUnion {
    #[tag(case = "lower")]
    Lower,
    #[tag(case = "upper")]
    Upper,
    #[tag(case = "lower")]
    LowerWith(usize),
    #[tag(case = "upper")]
    UpperWith(usize),
    Normal(usize),
}

// It happened that I ommited the fact that other attributes can be also used
// on the same field and I need to take this into account so this checks that
// compilation still succeeds.
#[allow(dead_code)]
#[allow(invalid_doc_attributes)]
#[derive(TagName)]
enum CheckTagNameAllowsOtherAttributes {
    #[tag(case = "lower")]
    Tag1(usize),
    #[doc("other attribute")]
    #[tag(case = "upper")]
    Tag2(usize),
    #[tag(case = "upper")]
    #[doc("other attribute")]
    Tag3(usize),
    #[doc("other attribute")]
    #[tag(case = "upper")]
    #[doc("other attribute")]
    Tag4(usize),
}

#[test]
fn simple_union_return_correct_tag_names() {
    let v1 = SimpleUnion::Yes;
    let v2 = SimpleUnion::No;
    assert_eq!(v1.tag_name(), "Yes");
    assert_eq!(v2.tag_name(), "No");
}

#[test]
fn simple_union_single_tag_return_correct_tag_names() {
    let v1 = SimpleUnionSingleTag::Yes;
    assert_eq!(v1.tag_name(), "Yes");
}

#[test]
fn complex_union_return_correct_tag_names() {
    let v1 = ComplexUnion::Yes;
    let v2 = ComplexUnion::No;
    let v3 = ComplexUnion::Maybe(1);
    let v4 = ComplexUnion::Maybe2(1, 2);
    let v5 = ComplexUnion::Maybe3(Arbitrary {
        x: String::from("x"),
        y: Some(1),
    });
    let v6 = ComplexUnion::Maybe4 {
        x: Some("x".to_owned()),
    };
    assert_eq!(v1.tag_name(), "Yes");
    assert_eq!(v2.tag_name(), "No");
    assert_eq!(v3.tag_name(), "Maybe");
    assert_eq!(v4.tag_name(), "Maybe2");
    assert_eq!(v5.tag_name(), "Maybe3");
    assert_eq!(v6.tag_name(), "Maybe4");
}

#[test]
fn complex_union_single_tag_return_correct_tag_names() {
    let v3 = ComplexUnionSingleTag::Maybe(1);
    assert_eq!(v3.tag_name(), "Maybe");
}

#[test]
fn diffrent_cases_are_applied() {
    let v1 = DifferentCasesUnion::Lower;
    let v2 = DifferentCasesUnion::Upper;
    let v3 = DifferentCasesUnion::LowerWith(1);
    let v4 = DifferentCasesUnion::UpperWith(1);
    let v5 = DifferentCasesUnion::Normal(1);

    assert_eq!(v1.tag_name(), "lower");
    assert_eq!(v2.tag_name(), "UPPER");
    assert_eq!(v3.tag_name(), "lowerwith");
    assert_eq!(v4.tag_name(), "UPPERWITH");
    assert_eq!(v5.tag_name(), "Normal");
}