structs-from-excel 0.2.2

crate that adds a procedural macro that unravels structs via a given, purpose-formatted Excel spreadsheet
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
127
128
129
130
131
132
133
134
135
136
137
138
139

# structs-from-excel

This crate adds a procedural macro that will generate structs based on a given Excel spreadsheet. It was made for a project where I knew that one of the people helping was not going to want to work with JSON or XML or anything reasonable. I'm sorry.

Invocation of the macro is as follows:

```
use structs_from_excel;

#[sheet("resources/objects.xls")]
pub struct Object; // This struct will get ignored and replaced by whatever structs you define. Anything can go here, pretty much.
```

Each sheet is then read and parsed, keeping the following rules in mind:

- The first cell of the first row should be called name.
- The first cell of every row beyond the first should be used as the name of each struct.
- Subsequent cells in the first row are used for field names.

The following two sheets:

![image](https://user-images.githubusercontent.com/30945097/224210459-093eb187-5847-4a71-8d57-3b093bdff703.png)

![image](https://user-images.githubusercontent.com/30945097/224211840-0a173b35-63ae-4cea-bc63-bf021640e25e.png)

become:

```
    enum StructsFromExcel {
        Slime(Slime),
        OtherSlime(OtherSlime),
        PlayerOne(PlayerOne),
        PlayerTwo(PlayerTwo),
        PlayerThree(PlayerThree),
        PlayerFour(PlayerFour),
    }
    pub struct Slime {
        pub hp: i32,
    }
    impl Default for Slime {
        fn default() -> Self {
            Self { hp: 30 }
        }
    }
    impl Slime {
        pub fn new() -> Self {
            return Default::default();
        }
    }
    pub struct OtherSlime {
        pub hp: i32,
    }
    impl Default for OtherSlime {
        fn default() -> Self {
            Self { hp: 60 }
        }
    }
    impl OtherSlime {
        pub fn new() -> Self {
            return Default::default();
        }
    }
    pub struct PlayerOne {
        pub what: f32,
        pub wa: String,
        pub hp: i32,
    }
    impl Default for PlayerOne {
        fn default() -> Self {
            Self {
                what: 15.5,
                wa: String::from("lorem"),
                hp: 20,
            }
        }
    }
    impl PlayerOne {
        pub fn new() -> Self {
            return Default::default();
        }
    }
    pub struct PlayerTwo {
        pub hp: i32,
        pub wa: String,
        pub what: f32,
    }
    impl Default for PlayerTwo {
        fn default() -> Self {
            Self {
                hp: 20,
                wa: String::from("ipsum"),
                what: 15.5,
            }
        }
    }
    impl PlayerTwo {
        pub fn new() -> Self {
            return Default::default();
        }
    }
    pub struct PlayerThree {
        pub what: f32,
        pub wa: String,
        pub hp: i32,
    }
    impl Default for PlayerThree {
        fn default() -> Self {
            Self {
                what: 15.5,
                wa: String::from("dot"),
                hp: 20,
            }
        }
    }
    impl PlayerThree {
        pub fn new() -> Self {
            return Default::default();
        }
    }
    pub struct PlayerFour {
        pub what: f32,
        pub wa: String,
        pub hp: i32,
    }
    impl Default for PlayerFour {
        fn default() -> Self {
            Self {
                what: 15.5,
                wa: String::from("ament"),
                hp: 20,
            }
        }
    }
    impl PlayerFour {
        pub fn new() -> Self {
            return Default::default();
        }
    }
```