restructed 0.2.2

Quickly derive subsets of your structs
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

#![allow(dead_code)]
extern crate restructed;

use restructed::Models;

//------------------ Structs

#[derive(Models)]
#[view(UserProfile, fields(display_name, bio))]
struct User {
    /// This should be omitted
    id: i32,
    /// This shouldn't be omitted
    display_name: String,
    bio: String,
    password: String,
}

impl User {
    pub fn new() -> Self {
        User {
            id: 123,
            display_name: "Cool Doode".to_string(),
            bio: "I'm a cool doode, what can I say?".to_string(),
            password: "Pls don't hack me".to_string(),
        }
    }
}

#[test]
fn from_original() {
    let user = User::new();

    let profile: UserProfile = user.into();

    assert_eq!(profile.display_name, profile.display_name);
    assert_eq!(profile.bio, profile.bio);
}

#[test]
fn only_fields() {
    let user = User::new();

    let profile = UserProfile {
        display_name: user.display_name,
        bio: user.bio,
    };

    assert_eq!(profile.display_name, profile.display_name);
    assert_eq!(profile.bio, profile.bio);
}

//------------------ Structs -- attributes_with = "all"

#[derive(Models)]
#[view(UserProfileAll, fields(display_name, bio), attributes_with = "all")]
struct UserAttrAll {
    /// This should be omitted
    id: i32,
    /// This shouldn't be omitted
    display_name: String,
    bio: String,
    password: String,
}

//------------------ Structs -- attributes_with = "deriveless"

#[derive(Models)]
#[view(UserProfileDeriveless, fields(display_name, bio), attributes_with = "deriveless")]
struct UserAttrDeriveless {
    /// This should be omitted
    id: i32,
    /// This shouldn't be omitted
    display_name: String,
    bio: String,
    password: String,
}

//------------------ Structs -- attributes_with = "none"

#[derive(Models)]
#[view(UserProfileNone, fields(display_name, bio), attributes_with = "none")]
struct UserAttrNone{
    /// This should be omitted
    id: i32,
    /// This shouldn't be omitted
    display_name: String,
    bio: String,
    password: String,
}

//------------------ Structs -- defaults

#[derive(Models)]
#[model(defaults(fields(display_name, bio), attributes_with = "none"))]
#[view(UserProfileDefaults)]
struct UserDefaults{
    id: i32,
    display_name: String,
    bio: String,
    password: String,
}

//------------------ Enums

#[derive(Debug, Clone, Models)]
#[view(ApiErrorReads, fields(NotFound, Unauthorized, InternalServerError))]
pub enum ApiError {
    /// This "NotFound" rustdoc will carry over <br/>
    /// Even for multiple lines
    NotFound(String),
    ConflictX(String),
    ConflictY(u64),
    Unauthorized { code: u16, reason: String },
    InternalServerError,
}



#[test]
fn mapping_enum() {
    let reads = ApiErrorReads::NotFound("No User".to_string());

    let err: ApiError = reads.into();

    let is_match = matches!(err.clone(), ApiError::NotFound(v) if v == "No User");
    assert!(is_match, "Expected NotFound, got {:?}", err);
}