enum-helper 0.1.0

Yet another enum helper. Macros that generate common boilerplate for enums.
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

use assert2::check;
use enum_helper::EnumStr;

#[derive(EnumStr, PartialEq, Eq)]
#[enum_str(rename_all = "snake_case")]
#[enum_str(alias_all = "lowercase")]
enum RenameAliasAll {
    FooBar,
    Baz,
}

#[test]
fn rename_all_alias_all_as_aliases() {
    check!(RenameAliasAll::FooBar.as_aliases() == &["foo_bar", "foobar"]);
    check!(RenameAliasAll::Baz.as_aliases() == &["baz"]);
}

#[test]
fn rename_all_alias_all_from_str() {
    check!("foo_bar".parse::<RenameAliasAll>().unwrap() == RenameAliasAll::FooBar);
    check!("foobar".parse::<RenameAliasAll>().unwrap() == RenameAliasAll::FooBar);
    check!("baz".parse::<RenameAliasAll>().unwrap() == RenameAliasAll::Baz);
}

#[derive(EnumStr, PartialEq, Eq)]
#[enum_str(rename_all = "lowercase")]
enum RenameOverride {
    #[enum_str(rename = "CustomName")]
    FooBar,
    Baz,
}

#[test]
fn rename_override_as_name() {
    check!(RenameOverride::FooBar.as_name() == "CustomName");
    check!(RenameOverride::Baz.as_name() == "baz");
}

#[test]
fn rename_override_from_str() {
    check!("CustomName".parse::<RenameOverride>().unwrap() == RenameOverride::FooBar);
    check!("baz".parse::<RenameOverride>().unwrap() == RenameOverride::Baz);
    check!("FooBar".parse::<RenameOverride>().is_err());
    check!("foobar".parse::<RenameOverride>().is_err());
}

#[derive(EnumStr, PartialEq, Eq)]
enum WithAlias {
    #[enum_str(alias = "foo")]
    #[enum_str(alias = "f")]
    FooBar,
    Baz,
}

#[test]
fn alias_as_aliases() {
    check!(WithAlias::FooBar.as_aliases() == &["FooBar", "foo", "f"]);
    check!(WithAlias::Baz.as_aliases() == &["Baz"]);
}

#[test]
fn alias_from_str() {
    check!("FooBar".parse::<WithAlias>().unwrap() == WithAlias::FooBar);
    check!("foo".parse::<WithAlias>().unwrap() == WithAlias::FooBar);
    check!("f".parse::<WithAlias>().unwrap() == WithAlias::FooBar);
    check!("Baz".parse::<WithAlias>().unwrap() == WithAlias::Baz);
    check!("baz".parse::<WithAlias>().is_err());
}

#[derive(EnumStr, PartialEq, Eq)]
#[enum_str(alias_all = "lowercase")]
enum DedupAlias {
    Foo,
    Baz,
}

#[test]
fn dedup_alias_as_aliases() {
    // "Foo" name stays, "foo" from alias_all is added (different from name)
    check!(DedupAlias::Foo.as_aliases() == &["Foo", "foo"]);
    check!(DedupAlias::Baz.as_aliases() == &["Baz", "baz"]);
}

#[derive(EnumStr, PartialEq, Eq)]
#[enum_str(rename_all = "snake_case")]
#[enum_str(alias_all = "lowercase")]
enum FullCombo {
    #[enum_str(rename = "overridden")]
    #[enum_str(alias = "extra")]
    #[enum_str(alias = "foobar")]
    FooBar,
    BazQux,
}

#[test]
fn full_combo_as_aliases() {
    check!(FullCombo::FooBar.as_aliases() == &["overridden", "foobar", "extra"]);
    check!(FullCombo::BazQux.as_aliases() == &["baz_qux", "bazqux"]);
}

#[test]
fn full_combo_from_str() {
    check!("overridden".parse::<FullCombo>().unwrap() == FullCombo::FooBar);
    check!("foobar".parse::<FullCombo>().unwrap() == FullCombo::FooBar);
    check!("extra".parse::<FullCombo>().unwrap() == FullCombo::FooBar);
    check!("baz_qux".parse::<FullCombo>().unwrap() == FullCombo::BazQux);
    check!("bazqux".parse::<FullCombo>().unwrap() == FullCombo::BazQux);
    check!("foo_bar".parse::<FullCombo>().is_err());
}