derive-debug 0.1.2

Customizable derive macro for Debug trait
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153

# derive-debug


This crate implements a more customizable version of `#[derive(Debug)]`.

# Usage

The usage is very similar to `#[derive(Debug)]` with a few extra customization options.

## Deriving a struct

```rust
use derive_debug::Dbg;

#[derive(Dbg)]

struct Foo {
    field_a: u32,
    #[dbg(placeholder = "...")]
    field_b: Vec<u32>, // will be printed as "field_b: ..."
    #[dbg(skip)]
    field_c: bool, // will be left out
    #[dbg(alias = "my_string")]
    field_d: u32, // will be printed as "my_string: 42"
    #[dbg(fmt = "{:#06X}")]
    field_e: u32, // will be printed with the specified format
}
```

# Deriving an enum

```rust
use derive_debug::Dbg;

#[derive(Dbg)]

enum Foo {
    VariantA(u32, u32, u32),
    #[dbg(skip)]
    VariantB{a: u32, b: bool}, // Will be printed as "VariantB"

    // same options available as for struct fields
    VariantC{a: u32, #[dbg(placeholder = "...")] b: bool}
}
```

## Detailed options

### Field Options

- `#[dbg(skip)]` completely omits a field in the output
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(skip)]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true }
```
- `#[dbg(placeholder = "xyz")]` will print `xyz` instead of the actual contents of a field
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(placeholder = "...")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, field_b: ... }
```
- `#[dbg(alias = "some_alias")]` will print `some_alias` as field name instead of the real name
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(alias="not_field_b")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, not_field_b: 42 }
```
- `#[dbg(fmt = "{:#06X}")]` will print the field with the specified format
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo {
        field_a: bool,
        #[dbg(fmt = "{:#06X}")]
        field_b: u32,
    }

    // Outputs: Foo { field_a: true, field_b: 0x002A }
```
- `#[dbg(formatter = "my_func")]` will print the field using the specified function.  
The function has to return a type that can be formatted using "{}"
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    struct Foo(u32, #[dbg(formatter = "fmt_not_zero")] u32);

    fn fmt_not_zero(v: &u32) -> &'static str {
        if *v == 0 {
            "0"
        } else {
            "not 0"
        }
    }

    // Outputs: Foo(42, not 0)
```

### Enum Variant Options

- `#[dbg(skip)]` only prints the name of the variant and omits its contents
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    enum Foo {
        #[dbg(skip)]
        SomeVariant{a: bool, b: u32},
    }

    // Outputs: SomeVariant
```
- `#[dbg(alias = "some_alias")]` will use `some_alias` as variant name instead of the real name
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    enum Foo {
        #[dbg(alias = "NotSomeVariant")]
        SomeVariant{a: bool, b: u32},
    }

    // Outputs: NotSomeVariant { a: true, b: 42 }
```

### struct Options

- `#[dbg(alias = "MyAlias")]` will use `MyAlias` as struct name instead of the real name
```rust
    use derive_debug::Dbg;

    #[derive(Dbg)]
    #[dbg(alias = "NotFoo")]
    struct Foo {
        field_a: bool,
        field_b: u32,
    }

    // Outputs: NotFoo { field_a: true, not_field_b: 42 }
```