clean-macro-docs 1.0.2

Hide internal rules when documenting `macro_rules!` macros.
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

use clean_macro_docs::clean_docs;

#[clean_docs]
#[macro_export]
macro_rules! simple_macro {
    (@impl $e:expr) => {
        format!("{}", $e)
    };
    ($e:expr) => {
        simple_macro!(@impl $e)
    };
}

#[clean_docs(impl = "#internal")]
#[macro_export]
macro_rules! custom_impl_macro {
    (#internal $e:expr) => {
        format!("{}", $e)
    };
    ($e:expr) => {
        custom_impl_macro!(#internal $e)
    };
}

#[clean_docs]
#[macro_export]
macro_rules! multiple_internal_macro {
    (@impl[0] $e:expr) => {
        multiple_internal_macro!(@impl[1] ->[$e]<-)
    };
    (@impl[1] $($t:tt)+) => {
        multiple_internal_macro!(@impl[2] stringify!($($t)+))
    };
    (@impl[2] $e:expr) => {
        format!("{}", $e)
    };
    ($e:expr) => {
        multiple_internal_macro!(@impl[0] $e)
    };
}

#[clean_docs]
#[macro_export]
macro_rules! multiple_public_macro {
    (@impl[parens] $e:expr) => {
        format!("({})", $e)
    };
    (@impl[braces] $e:expr) => {
        format!("{{{}}}", $e)
    };
    (@impl[brackets] $e:expr) => {
        format!("[{}]", $e)
    };
    (() $e:expr) => {
        multiple_public_macro!(@impl[parens] $e)
    };
    ({} $e:expr) => {
        multiple_public_macro!(@impl[braces] $e)
    };
    ([] $e:expr) => {
        multiple_public_macro!(@impl[brackets] $e)
    };
}

#[clean_docs]
#[macro_export]
macro_rules! no_internal_macro {
    ($e:expr) => {
        format!("{}", $e)
    };
}

#[clean_docs]
#[macro_export]
macro_rules! back_and_forth_macro {
    (@impl $t:tt) => {
        (back_and_forth_macro!($t), back_and_forth_macro!($t))
    };
    ([$t:tt]) => {
        back_and_forth_macro!(@impl $t)
    };
    ($t:tt) => {
        $t
    };
}

#[test]
fn simple() {
    assert_eq!(simple_macro!(54321), "54321");
}

#[test]
fn custom_impl() {
    assert_eq!(custom_impl_macro!(54321), "54321");
}

#[test]
fn multiple_internal() {
    assert_eq!(multiple_internal_macro!(54321), "-> [54321] <-");
}

#[test]
fn multiple_public() {
    assert_eq!(multiple_public_macro!(() 54321), "(54321)");
    assert_eq!(multiple_public_macro!({} 54321), "{54321}");
    assert_eq!(multiple_public_macro!([] 54321), "[54321]");
}

#[test]
fn no_internal() {
    assert_eq!(no_internal_macro!(54321), "54321");
}

#[test]
fn back_and_forth() {
    assert_eq!(back_and_forth_macro!([[3]]), ((3, 3), (3, 3)));
}