branded 0.2.1

Branded types for Rust.
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

use branded::Branded;
use std::fmt::{Debug, Display};
use std::hash::Hash;

#[test]
fn conforms_to_inner_traits() {
    #[derive(Branded)]
    pub struct UserId(u32);

    fn needs_clone<T: Clone>() {}
    fn needs_copy<T: Copy>() {}
    fn needs_default<T: Default>() {}
    fn needs_debug<T: Debug>() {}
    fn needs_display<T: Display>() {}
    fn needs_eq<T: PartialEq>() {}
    fn needs_hash<T: Hash>() {}
    fn needs_ord<T: PartialOrd>() {}

    needs_clone::<UserId>();
    needs_copy::<UserId>();
    needs_default::<UserId>();
    needs_debug::<UserId>();
    needs_display::<UserId>();
    needs_eq::<UserId>();
    needs_hash::<UserId>();
    needs_ord::<UserId>();
}

#[test]
fn test_accessors() {
    #[derive(Branded)]
    pub struct UserId(u32);

    let user_id = UserId::new(123);
    assert_eq!(user_id.inner(), &123);
    assert_eq!(user_id.into_inner(), 123);
}

#[cfg(feature = "serde")]
mod serde {
    use branded::Branded;
    use serde::de::DeserializeOwned;
    use serde::Serialize;

    #[test]
    fn test_serde_derive() {
        #[derive(Branded)]
        #[branded(serde)]
        pub struct UserId(String);

        fn needs_serialize<T: Serialize>() {}
        fn needs_deserialize<T: DeserializeOwned>() {}

        needs_serialize::<UserId>();
        needs_deserialize::<UserId>();

        let id = UserId::new("123".to_string());
        let json = serde_json::to_string(&id).unwrap();
        assert_eq!(json, r#""123""#);
        let recovered: UserId = serde_json::from_str(&json).unwrap();
        assert_eq!(recovered, id);
    }
}

#[cfg(feature = "sqlx")]
mod sqlx {
    use branded::Branded;
    use sqlx::Database;

    #[test]
    fn test_sqlx_derive() {
        #[derive(Branded)]
        #[branded(sqlx)]
        pub struct UserId(String);

        fn needs_type<T: sqlx::Type<DB>, DB: Database>() {}
        fn needs_encode<'en, T: sqlx::Encode<'en, DB>, DB: Database>() {}
        fn needs_decode<'de, T: sqlx::Decode<'de, DB>, DB: Database>() {}

        needs_type::<UserId, sqlx::Sqlite>();
        needs_encode::<UserId, sqlx::Sqlite>();
        needs_decode::<UserId, sqlx::Sqlite>();
    }
}

#[cfg(feature = "uuidv4")]
mod uuidv4 {
    use branded::Branded;

    #[test]
    fn test_uuid_derive() {
        #[derive(Branded)]
        #[branded(uuidv4)]
        pub struct UserId(uuid::Uuid);

        let id = UserId::new_v4();
        let str = id.to_string();
        assert_eq!(str.len(), 36);

        let nil = UserId::nil();
        assert_eq!(nil.inner(), &uuid::Uuid::nil());
    }
}

#[cfg(feature = "uuidv7")]
mod uuidv7 {

    use branded::Branded;

    #[test]
    fn test_uuid_derive() {
        #[derive(Branded)]
        #[branded(uuidv7)]
        pub struct UserId(uuid::Uuid);

        let id = UserId::now_v7();
        let str = id.to_string();
        assert_eq!(str.len(), 36);

        let nil = UserId::nil();
        assert_eq!(nil.inner(), &uuid::Uuid::nil());
    }
}