nnn 1.2.2

Generate your newtypes from a single macro.
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

#![cfg(feature = "macros")]
#![allow(dead_code, unused_imports, reason = "Tests, dead_code is expected.")]
/* Modules */
#[rustfmt::skip] // wants to reorder modules
mod validators {
    // Containers
    mod not_empty;
    mod each;
    mod min_length;
    mod min_length_or_eq;
    mod length;
    mod max_length;
    mod max_length_or_eq;
    // Numerics
    mod min;
    mod min_or_eq;
    mod max;
    mod max_or_eq;
    mod positive;
    mod negative;
    // Float specifics
    mod finite;
    mod not_infinite;
    mod not_nan;
    // String specifics
    mod regex;
    // Common
    mod exactly;
    mod custom;
    mod predicate;
}

mod derives {
    mod as_ref;
    mod borrow;
    mod deref;
    mod from;
    mod from_str;
    mod into;
    mod into_iterator;
    mod serde;
    mod try_from;
}

#[rustfmt::skip] // wants to reorder modules
mod sanitizers {
    // Containers
    mod each;
    mod sort;
    mod dedup;
    // Strings
    mod trim;
    mod lowercase;
    mod uppercase;
    // Common
    mod custom;
}

#[cfg(test)]
mod ui {
    #[test]
    fn ui_pass() {
        trybuild::TestCases::new().pass("tests/ui/pass/*.rs");
        #[cfg(not(feature = "regex_validation"))]
        trybuild::TestCases::new()
            .pass("tests/ui/conditionals/invalid_compile_time_regex.rs");
    }

    #[test]
    fn ui_fail() {
        trybuild::TestCases::new().compile_fail("tests/ui/fail/*.rs");
        #[cfg(feature = "regex_validation")]
        trybuild::TestCases::new().compile_fail(
            "tests/ui/conditionals/invalid_compile_time_regex.rs",
        );
    }
}

#[doc(hidden)]
pub mod utils {
    macro_rules! sign_tests {
        ($sign_test:ident, $($ty:ty, valids = [$($valid:literal),*], invalids = [$($invalid:expr),*]),*) => {
            $(
                paste::paste! {
                    mod [< $sign_test _ $ty >] {
                        use rstest::rstest;
                        use nnn::{nnn, NNNewType as _};

                        #[nnn(validators($sign_test))]
                        struct NNN($ty);

                        #[rstest]
                        $(#[case($valid)])*
                        fn [< valid_ $sign_test _ $ty >](#[case] input: $ty) {
                            NNN::try_new(input).unwrap();
                        }

                        #[rstest]
                        $(#[case($invalid)])*
                        fn [< invalid_ $sign_test _ $ty >](#[case] input: $ty) {
                            assert!(NNN::try_new(input).is_err());
                        }
                    }
                }
            )*
        };
    }

    pub(crate) use sign_tests;
}