struct_field_names 0.2.1

Derive macros for generating the name of each field in a struct and each variant name in an enum as `&'static str`
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

use struct_field_names::{EnumVariantNames, StructFieldNames};

#[test]
fn test_field_names() {
    #[allow(dead_code)]
    #[derive(StructFieldNames)]
    struct Struct {
        field_one: i32,
        field_two: Vec<bool>,
        hello: (String,),
        world: [u64; 3],
    }
    assert_eq!(Struct::FIELD_NAMES.field_one, "field_one");
    assert_eq!(Struct::FIELD_NAMES.field_two, "field_two");
    assert_eq!(Struct::FIELD_NAMES.hello, "hello");
    assert_eq!(Struct::FIELD_NAMES.world, "world");
}

#[test]
fn test_with_generic_struct() {
    #[allow(dead_code)]
    #[derive(StructFieldNames)]
    struct Struct<'a, T: PartialEq, U> {
        field_one: &'a T,
        field_two: Vec<U>,
    }
    assert_eq!(Struct::<'_, (), ()>::FIELD_NAMES.field_one, "field_one");
    assert_eq!(Struct::<'_, (), ()>::FIELD_NAMES.field_two, "field_two");
}

#[test]
fn not_a_test_skip_attribute() {
    #[allow(dead_code)]
    #[derive(StructFieldNames)]
    struct Struct {
        field_one: bool,
        #[struct_field_names(skip)]
        field_two: usize,
    }
    assert_eq!(Struct::FIELD_NAMES.field_one, "field_one");
    // Uncommenting the line below should produce an error.
    // assert_eq!(Struct::FIELD_NAMES.field_two, "field_two");
}

#[test]
fn not_a_test_field_visibility() {
    mod module {
        use struct_field_names::StructFieldNames;
        #[allow(dead_code)]
        #[derive(StructFieldNames)]
        pub struct PublicStruct {
            pub public_field: i32,
            private_field: i32,
        }
        #[allow(dead_code)]
        #[derive(StructFieldNames)]
        struct PrivateStruct {
            pub public_field: i32,
            private_field: i32,
        }
    }
    assert_eq!(
        module::PublicStruct::FIELD_NAMES.public_field,
        "public_field"
    );
    // Uncommenting any of the lines below should produce an error.
    /*
    let _ = module::PublicStruct::FIELD_NAMES.private_field;
    let _ = module::PublicStructFieldStaticStr {
        public_field: "asdf",
        private_field: "asdf",
    };
    let _ = module::PrivateStructFieldStaticStr {
        public_field: "asdf",
        private_field: "asdf"
    };
    */
}

#[test]
fn test_variant_names() {
    #[allow(dead_code)]
    #[derive(EnumVariantNames)]
    enum Enum {
        VarOne(i32),
        VarTwo,
        VarThree { inner: String },
    }
    assert_eq!(Enum::VARIANT_NAMES.VarOne, "VarOne");
    assert_eq!(Enum::VARIANT_NAMES.VarTwo, "VarTwo");
    assert_eq!(Enum::VARIANT_NAMES.VarThree, "VarThree");
}