fievar 0.2.0

Proc macrs to generate functions that return static slices of struct field names or enum variant names.
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

This crate provides procedural macrs to generate functions that return static slices
of struct field names or enum variant names.

# Examples
```rust
use fievar::Fields;

#[derive(Fields)]
struct File {
    id: String,
    name: String,
    mime_type: String,
}

assert_eq!(&["id", "name", "mime_type"], File::fields());
```

You can also rename fields.
```rust
use fievar::Fields;

#[derive(Fields)]
struct File {
    id: String,
    name: String,
    #[fievar(name = "mimeType")]
    mime_type: String,
}

assert_eq!(&["id", "name", "mimeType"], File::fields());
```

# Transformations
## Syntax
*Expression:*  
   [[*T*][`|`*Sep*]]

*Sep:* Word separator.  
   Can be any text.

*T:*
Determines how to transform field/variant.  
   [[*TrCase*][` `*NumAlign*]]

*NumAlign:* Controls alignment of numerals.  
   `1__` | `__1` | `_1_`  

*TrCase:* Controls the case of letters.  
   [*TrWord*[` `*TrWord*[` `*TrWord*]]]  

*TrWord:* Controls the case of individual words.  
   [*TrChar*[*TrChar*[*TrChar*]]]

*TrChar:* Controls the case of individual characters in words.  
   `c` | `C`  

*TrCase* consists of upto three *TrWord*s separated by a space. If there is
only one *TrWord* then it is used to transform all words in field/variant. If
there are two *TrWord*s then the first *TrWord* is applied to the first word of
the field/variant and the second *TrWord* is applied to the rest of the words.
If there are three *TrWord*s then the first and last *TrWord*s are applied to
the first and last words of the field/variant and the second *TrWord* is
applied to the rest of the words. *TrChar*s work similarly on characters in a
word.

## Examples
```rust
use fievar::Variants;

#[derive(Variants)]
enum E {
    #[fievar(transform = "c")] // lowercase
    AVeryLong0Variant,

    #[fievar(transform = "C")] // uppercase
    AVeryLong1Variant,

    #[fievar(transform = "1__|_")] // align numeral left
    AVeryLong2Variant,

    #[fievar(transform = "__1|_")] // align numeral right
    AVeryLong3Variant,

    #[fievar(transform = "_1_|_")] // align numeral middle
    AVeryLong4Variant,

    #[fievar(transform = "c Cc")] // camelCase
    AVeryLong5Variant,

    #[fievar(transform = "c|_")] // snake_case
    AVeryLong6Variant,

    #[fievar(transform = "CcC cCc CcC _1_|*-*")] // something different
    LastVeryLong7Variant,
}

let v = &[
    "averylong0variant",
    "AVERYLONG1VARIANT",
    "A_Very_Long2_Variant",
    "A_Very_Long_3Variant",
    "A_Very_Long_4_Variant",
    "aVeryLong5Variant",
    "a_very_long6_variant",
    "LasT*-*vERy*-*lONg*-*7*-*VarianT"
];
assert_eq!(v, E::variants());
```